Spring之ORM

野性酷女 2022-01-13 09:01 352阅读 0赞

ORM: 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说,ORM是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到关系数据库中。那么,到底如何实现持久化呢?一种简单的方案是采用硬编码方式,为每一种可能的数据库访问操作提供单独的方法。

  • 这种方案存在以下不足:
    1.持久化层缺乏弹性。一旦出现业务需求的变更,就必须修改持久化层的接口
    2.持久化层同时与域模型与关系数据库模型绑定,不管域模型还是关系数据库模型发生变化,毒药修改持久化曾的相关程序代码,增加了软件的维护难度。

ORM提供了实现持久化层的另一种模式,它采用映射元数据来描述对象关系的映射,使得ORM中间件能在任何一个应用的业务逻辑层和数据库层之间充当桥梁。Java典型的ORM中间件有:Hibernate,ibatis,speedframework。

  • ORM的方法论基于三个核心原则:
      · 简单:以最基本的形式建模数据。
      · 传达性:数据库结构被任何人都能理解的语言文档化。
      · 精确性:基于数据模型创建正确标准化了的结构。
    代码展示:
    目录结构:
    在这里插入图片描述pom.xml

    <?xml version=”1.0” encoding=”UTF-8”?>


    4.0.0

    groupId
    Demo01
    1.0-SNAPSHOT



    junit
    junit
    4.12



    org.springframework
    spring-context
    5.1.7.RELEASE


    org.springframework
    spring-test
    5.1.7.RELEASE


    org.aspectj
    aspectjweaver
    1.9.2


    com.mchange
    c3p0
    0.9.5.2


    org.springframework
    spring-orm
    5.1.7.RELEASE


    mysql
    mysql-connector-java
    5.1.47




User.java

  1. package com.xbj.po;
  2. public class User {
  3. private Integer id;
  4. private String username;
  5. private String password;
  6. private Integer age;
  7. //get set toString
  8. }

applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
  3. <!--导入配置文件-->
  4. <context:property-placeholder location="classpath:db.properties" />
  5. <!--1.数据源-->
  6. <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
  7. <property name="jdbcUrl" value="${jdbc.url}" />
  8. <property name="driverClass" value="${jdbc.driver}" />
  9. <property name="user" value="${jdbc.username}" />
  10. <property name="password" value="${jdbc.password}" />
  11. </bean>
  12. <context:component-scan base-package="com.xbj.dao.impl" />
  13. <!--1. 配置事务管理器-->
  14. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  15. <property name="dataSource" ref="dataSource" />
  16. </bean>
  17. <!-- 通知 映射到上面的事务管理器-->
  18. <tx:advice transaction-manager="transactionManager" id="transactionInterceptor">
  19. <tx:attributes>
  20. <tx:method name="add*" />
  21. <tx:method name="insert*"/>
  22. <tx:method name="save*"/>
  23. <tx:method name="update*"/>
  24. <tx:method name="change*" />
  25. <tx:method name="del*"/>
  26. <tx:method name="remove*"/>
  27. <tx:method name="drop*"/>
  28. </tx:attributes>
  29. </tx:advice>
  30. <!-- aop切面并配置切入点入进行事物管理 指向上面的映射 -->
  31. <aop:config>
  32. <aop:advisor advice-ref="transactionInterceptor" pointcut="execution(* com.xbj.service.impl.*.*(..))" />
  33. </aop:config>
  34. </beans>

db.properties

  1. jdbc.url=jdbc:mysql://localhost:3306/db1
  2. jdbc.driver=com.mysql.jdbc.Driver
  3. jdbc.username=root
  4. jdbc.password=root

UserDAO.java

  1. package com.xbj.dao;
  2. import com.xbj.po.User;
  3. import java.util.List;
  4. public interface UserDAO {
  5. void addUser(User user);
  6. void delUser(Integer id);
  7. void updateUser(User user);
  8. User findUserById(Integer id);
  9. List<User> findAll();
  10. User findUserById2(Integer id);
  11. }

UserDAOImpl.java

  1. package com.xbj.dao.impl;
  2. import com.xbj.dao.UserDAO;
  3. import com.xbj.po.User;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.dao.DataAccessException;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  8. import org.springframework.jdbc.core.ResultSetExtractor;
  9. import org.springframework.jdbc.core.RowMapper;
  10. import org.springframework.jdbc.core.support.JdbcDaoSupport;
  11. import org.springframework.stereotype.Repository;
  12. import javax.annotation.Resource;
  13. import javax.sql.DataSource;
  14. import java.sql.ResultSet;
  15. import java.sql.SQLException;
  16. import java.util.List;
  17. @Repository
  18. public class UserDAOImpl extends JdbcDaoSupport implements UserDAO {
  19. @Resource
  20. public void init(DataSource dataSource){
  21. super.setDataSource(dataSource);
  22. }
  23. public void addUser(User user) {
  24. //String sql, @Nullable Object... args
  25. String sql = "INSERT INTO t_user VALUES (NULL,?,?,?)";
  26. this.getJdbcTemplate().update(sql, user.getUsername(), user.getPassword(), user.getAge());
  27. }
  28. public void delUser(Integer id) {
  29. String sql = "DELETE FROM t_user WHERE id=?";
  30. this.getJdbcTemplate().update(sql, id);
  31. }
  32. public void updateUser(User user) {
  33. String sql = "UPDATE t_user SET username=? ,password=?,age=? WHERE id=?";
  34. this.getJdbcTemplate().update(sql, user.getUsername(), user.getPassword(), user.getAge(), user.getId());
  35. }
  36. //自动映射,但要保证User类中的字段名与数据库的要一致
  37. public User findUserById(Integer id) {
  38. String sql = "SELECT * FROM t_user WHERE id=?";
  39. List<User> list = this.getJdbcTemplate().query(sql, new BeanPropertyRowMapper<User>(User.class), id);
  40. return list.size() > 0 ? list.get(0) : null;
  41. }
  42. public List<User> findAll() {
  43. String sql = "SELECT * FROM t_user";
  44. return this.getJdbcTemplate().query(sql, new BeanPropertyRowMapper<User>(User.class));
  45. }
  46. //手动映射
  47. public User findUserById2(Integer id) {
  48. String sql = "SELECT * FROM t_user WHERE id=?";
  49. return this.getJdbcTemplate().query(sql, new ResultSetExtractor<User>() {
  50. public User extractData(ResultSet rs) throws SQLException, DataAccessException {
  51. User user=new User();
  52. if(rs.next()){
  53. user.setId(rs.getInt("id"));
  54. user.setUsername(rs.getString("username"));
  55. user.setPassword(rs.getString("pwd"));
  56. user.setAge(rs.getInt("age"));
  57. }
  58. return user;
  59. }
  60. }, id);
  61. }
  62. }

原生测试方法:

  1. package com.xbj;
  2. import org.junit.Test;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. public class Test01 {
  8. @Test
  9. public void t1() throws Exception {
  10. Class.forName("com.mysql.jdbc.Driver");
  11. //DriverManager JDBC大管家
  12. Connection connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/db1","root","root");
  13. PreparedStatement psmt=connection.prepareStatement("SELECT * from t_user WHERE age > ?");
  14. psmt.setInt(1,33);
  15. ResultSet rs=psmt.executeQuery();
  16. while (rs.next()){
  17. Integer id= rs.getInt("id");
  18. String username=rs.getString("username");
  19. System.out.println(id+"--"+username);
  20. }
  21. }
  22. }

Spring测试方法;

  1. package com.xbj;
  2. import com.xbj.dao.UserDAO;
  3. import com.xbj.po.User;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  9. import java.util.List;
  10. @RunWith(SpringJUnit4ClassRunner.class)
  11. @ContextConfiguration(locations = { "classpath:applicationContext.xml"})
  12. public class Test02 {
  13. @Autowired
  14. private UserDAO userDAO;
  15. @Test
  16. public void t1(){
  17. List<User> users=userDAO.findAll();
  18. for (User user:users){
  19. System.out.println(user);
  20. }
  21. }
  22. @Test
  23. public void t2(){
  24. User user=userDAO.findUserById(8);
  25. System.out.println(user);
  26. }
  27. @Test
  28. public void t3(){
  29. User user=new User();
  30. user.setUsername("hanmeimei");
  31. user.setPassword("ok");
  32. user.setAge(16);
  33. userDAO.addUser(user);
  34. }
  35. @Test
  36. public void t4(){
  37. User user=userDAO.findUserById(5);
  38. user.setUsername("HMM");
  39. userDAO.updateUser(user);
  40. }
  41. @Test
  42. public void t5(){
  43. userDAO.delUser(5);
  44. }
  45. @Test
  46. public void t6(){
  47. User user= userDAO.findUserById2(2);
  48. System.out.println(user);
  49. }
  50. }

发表评论

表情:
评论列表 (有 0 条评论,352人围观)

还没有评论,来说两句吧...

相关阅读

    相关 mysql面试ORM

    先回顾下之前操作数据库的方式,用的是jdbc连接数据库,(操作java代码来操作数据库)jdbc就是一个接口,用它可以来访问数据库,操作数据库。 jbbc操作mysql数据库

    相关 Android ORM 框架 greenDAO

    我相信,在平时的开发过程中,大家一定会或多或少地接触到 [SQLite][]。然而在使用它时,我们往往需要做许多额外的工作,像编写 SQL 语句与解析查询结果等。所以,适用于

    相关 beego ORM

    beego ORM是一个强大的GO语言ROM框架。她的灵感主要来自Django ORM 和 SQLAlchemy.  目前该框架仍处于开发阶段,可能发生任何导致不兼容的改动。

    相关 SpringORM

    ORM: 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说,ORM是通过

    相关 ORM框架JOOQ

    1. 概念 JOOQ 是基于Java访问关系型数据库的工具包。这和一些ORM比如Hibernate映射框架有些不同,比如Hibernate是帮你隐藏了SQL实现。