signed

QiShunwang

“诚信为本、客户至上”

Java | Spring框架学习笔记--(3)持久层整合

2021/1/28 12:21:30   来源:

持久层整合

Spring框架为什么要与持久层技术进行整合?

  1. JavaEE开发需持久层进行数据库的访问操作
  2. JDBC Hibernate MyBatis 进行持久层开发过程存在大量的代码冗余
  3. Spring基于模板设计模式对于上述的持久层技术进行了封装

Spring可以与哪些持久性技术整合?

  1. JDBC – JdbcTemplate
  2. Hibernate(JPA) – HibernateTemplate
  3. MyBatis – SqlSessionFactoryBean MapperScannerConfigure

Spring与MyBatis整合

  1. 数据表

    create table users(
    	id primary key auto_increment,
        username varchar(16),
        password varchar(16)
    )
    
  2. 实体类

    public class User implements Serializable {
        private int id;
        private String username;
        private String password;
    	//---构造方法、getter/setter/toString略--
    }
    
  3. DAO接口

    public interface UserDao {
        void insert(User user);
    }
    
    
  4. SqlMapConfig.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
        <typeAliases>
            <typeAlias type="com.prince.User" alias="user" />
        </typeAliases>
    
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <!--com.mysql.jdbc.Driver过期了 -->
                    <property name="url" value="jdbc:mysql:///mydata"/>
                    <!-- 实验证明URL后面不加“?serverTimezone=UTC”会报异常 -->
                    <property name="username" value="root"/>
                    <property name="password" value="root"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <mapper resource="Mapper.xml"/>
        </mappers>
    </configuration>
    
  5. Mapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <mapper namespace="com.prince.UserDao">
        <!-- namespace放接口的全类名 -->
        <insert id="insert" parameterType="user">
            insert into users(username,password) values(#{username},#{password});
        </insert>
    </mapper>
    
  6. 测试类

    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    public class TestMybatis {
        @Test
        public void test() throws IOException {
            InputStream in = TestMybatis.class.getResourceAsStream("/SqlMapConfig.xml");
            SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
            SqlSession sqlSession = sessionFactory.openSession();
            UserDao userDao = sqlSession.getMapper(UserDao.class);
            userDao.insert(new User("mpr","456789"));
            sqlSession.commit();
            sqlSession.close();
            in.close();
        }
    }
    
    

Mybatis开发中存在的问题

配置繁琐 代码冗余

  1. 实体
  2. 实体别名 配置繁琐
  3. 创建DAO接⼝
  4. 实现Mapper⽂件
  5. 注册Mapper⽂件 配置繁琐
  6. MybatisAPI调⽤ 代码冗余

Spring整合MyBatis分析

  1. 创建SqlSessionFactory过于繁琐,SqlMapConfig.xml的配置也过于复杂

    InputStream in = TestMybatis.class.getResourceAsStream("/SqlMapConfig.xml");
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
    

    Spring的整合方法:SqlSessionFactoryBean对象,在applicationContext.xml中配置这个对象的时候

    通过dataSource属性指定数据库连接池
    通过typeAliasesPackage属性指定别名(传实体类所在的包进去,Spring会自动给这个包下的类设置别名,比如这个包下有一个User类,那么就会有一个别名叫做User)
    通过mapperLocations属性指定Mapper.xml所在的位置(可以使用通用配置,比如*Mapper.xml代表的是所有以Mapper.xml结尾的文件)

  2. 创建SqlSession和DAO的时候,Spring也进行了整合

    SqlSession sqlSession = sessionFactory.openSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    

    使用到的类是MapperScannerConfigure,在applicationContext.xml中配置这个对象的时候
    通过sqlSessionFactoryBeanName 属性来指定上一步创建的那个SqlSessionFactoryBean对象,value是这个对象的id值
    通过basePackage属性来指定DAO接口所在的包
    创建DAO接口的时候,直接在Spring中通过getBean()传入id获取,id为DAO接口的名称,首字母小写。比如UserDAO,id就是userDAO

Spring整合Mabatis开发步骤

  • 环境配置(3个jar包)

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.1</version>
    </dependency>
    
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.9</version>
    </dependency>
    
  • applicationContext.xml的配置

    <!--配置数据库连接池-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydata"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    
    <!--配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factoryBean">
        <!--指定DataSource数据库连接池-->
        <property name="dataSource" ref="dataSource" />
        <!--给实体类设置别名-->
        <property name="typeAliasesPackage" value="com.prince.entity" />
        <!--设置mapper.xml的文件路径-->
        <property name="mapperLocations">
            <list>
                <value>mapper/*Mapper.xml</value>
            </list>
        </property>
    </bean>
    
    <!--配置MapperScannerConfigurer-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="configurer">
        <!--SqlSessionFactoryBean-->
        <property name="sqlSessionFactoryBeanName" value="factoryBean" />
        <!--指定Dao接口所在的包-->
        <property name="basePackage" value="com.prince.dao" />
    </bean>
    
  • 测试类

    public class TestSpringMybatis {
        @Test
        public void test(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDao userDao = applicationContext.getBean("userDao", UserDao.class);	//直接通过getBean()传入id来获取对象,id值就是Dao借口的名字,首字母小写
            userDao.insert(new User("anong","fdsjh"));
        }
    }
    

细节:Spring整合MyBatis的时候,插入数据时,不需要commit(),会自动提交,而原来的Mybatis需要手动提交事务。

分析:本质上控制连接对象(Connection)的是—>连接池(DataSource)

  1. MyBatis提供的连接池对象,创建Connection的时候会自动将Connection设置为手动提交事务

    Connection.setAutoCommit(false);
    
  2. Spring整合Mybatis的时候,我们使用的是Druid连接池,这些连接池在创建对象的时候不会设置setAutoCommit为false,而是保持默认值true,即会自动提交事务。

未来实战中,还会设置手动提交事务,Spring可以通过事务控制解决这个问题。

Spring的事务处理

事务:保证业务操作完整性的一种数据库机制
事务的4个特点:A(原子性)、C(一致性)、I(隔离性)、D(持久性)

如何控制事务?

JDBC:
	Connection.setAutoCommit(false);  开启事务
	Connection.commit();			提交事务
	Connection.rollback();			回滚
MyBatis:
	自动开启事务
	sqlSession.commit();	提交事务
	sqlSession.rollback();	回滚
(Mybatis控制事务的底层 都是通过Connection来实现的)

Spring控制事务分析

Spring是通过AOP的方式来控制事务开发的

在这里插入图片描述
在这里插入图片描述

Spring控制事务编码

  1. 导入依赖jar包

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.3.1</version>
    </dependency>
    
  2. 配置ApplicationContext.xml

    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
        <!--传入dataSource数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <!--组装切面-->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" />
    

    注意:<tx:annotation-driven>标签在写上<tx:anno后,idea有多个提示,要选择链接是tx结尾的那个!
    在这里插入图片描述

    组装切面的时候,也可以指定proxy-target-class属性为true,来代表使用CGlib的代理模式

    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true" />
    
  3. UserService

    public interface UserService {
    
        void insert(User user);
    }
    
    
    @Transactional  //给这个类的所有方法都加入事务
    public class UserServiceImpl implements UserService{
        private UserDao userDao;
    
        public UserDao getUserDao() {
            return userDao;
        }
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void insert(User user) {
            userDao.insert(user);
        }
    }
    
  4. applicationContext.xml里面配置UserService

    <bean class="com.prince.service.UserServiceImpl" id="userService">
        <!--Spring与Mybatis整合的时候会创建一个UserDao,直接把这个UserDao注入即可-->
        <property name="userDao" ref="userDao"/>
    </bean>
    
  5. 测试类

    @Test
    public void test2(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.insert(new User("interesting","hhhhaaaa"));
    }
    

注意:不需要手动提交事务,当UserService的方法抛出异常时,会自动回滚。

完整的配置代码:

<?xml version="1.0" encoding="UTF-8"?>
<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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--配置数据库连接池-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydata"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <!--配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factoryBean">
        <!--指定DataSource数据库连接池-->
        <property name="dataSource" ref="dataSource" />
        <!--给实体类设置别名-->
        <property name="typeAliasesPackage" value="com.prince.entity" />
        <!--设置mapper.xml的文件路径-->
        <property name="mapperLocations">
            <list>
                <value>mapper/*Mapper.xml</value>
            </list>
        </property>
    </bean>

    <!--配置MapperScannerConfigurer-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="configurer">
        <!--SqlSessionFactoryBean-->
        <property name="sqlSessionFactoryBeanName" value="factoryBean" />
        <!--指定Dao接口所在的包-->
        <property name="basePackage" value="com.prince.dao" />

    </bean>

    <!--上面是Spring整合Mybatis-->

    <!--额外功能-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
        <!--传入dataSource数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--组装切面-->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true" />

    <!--创建UserService对象-->
    <bean class="com.prince.service.UserServiceImpl" id="userService">
        <!--Spring与Mybatis整合的时候会创建一个UserDao,直接把这个UserDao注入即可-->
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

Spring的事务属性

属性:描述物体特征的一系列值(性别、身高、体重、…)
事务属性:描述事务特征的一系列值,主要有5个方面:隔离属性、传播属性、只读属性、超时属性、异常属性

隔离属性(isolation)

概念:描述了事务解决并发问题的特征
并发:多个事务在同一时间内,访问操作了相同的数据
产生的问题:脏读、不可重复读、幻影读
解决:通过隔离属性解决,隔离属性设置不同的值,解决并发的问题

  • 脏读:⼀个事务,读取了另⼀个事务中没有提交的数据。会在本事务中产⽣数据不⼀致的问题
    解决:

    @Transactional(isolation=Isolation.READ_COMMITTED)
    
  • 不可重复读:一个事务中,多次读取相同的数据,但是读取结果不一样,产生数据不一致的问题。
    注意:1. 不是脏读 2. 一个事务中
    解决:

    @Transactional(isolation = Isolation.REPEATABLE_READ) 
    

    本质:一把行锁

  • 幻影读:一个事务中,多次对整表进行查询统计,但是结果不一样,会在本事务中产生数据不一致的问题
    解决:

    @Transactional(isolation = Isolation.SERIALIZABLE)
    

    本质:表锁

总结:
并发安全:SERIALIZABLE > REPEATABLE_READ > READ_COMMITTED
运行效率:READ_COMMITTED > REPEATABLE_READ > SERIALIZABLE

数据库对隔离属性的支持:

隔离属性的值MysqlOracle
READ_COMMITTED支持支持
REPEATABLE_READ支持不支持
SERIALIZABLE支持支持

Oracle不支持REPEATABLE_READ的值,采用多版本比对的方式解决不可重复读的问题。

默认隔离属性(ISOLATION_DEFAULT):会调用不同数据库数组的默认隔离属性
MySQL --> REPEATABLE_READ
Oracle --> READ_COMMITTED

查看数据库的默认隔离属性

-- MySQL
select @@tx_isolation;

-- Oracle
SELECT s.sid, s.serial#,
	CASE BITAND(t.flag, POWER(2, 28))
		WHEN 0 THEN 'READ COMMITTED'
		ELSE 'SERIALIZABLE'
	END AS isolation_level
FROM v$transaction t
JOIN v$session s ON t.addr = s.taddr
AND s.sid = sys_context('USERENV', 'SID');

在这里插入图片描述

在实战中的建议:

  1. 推荐使用Spring指定的ISOLATION_DEFAULT
  2. 未来实战中,并发访问情况很低,如果真遇到并发问题,可以使用乐观锁 Hibernate(JPA)

传播属性(propagation)

概念:描述了事务嵌套之间的特征(嵌套:指的是一个大的事务中,包含了若干个小的事务)
问题:大事务中融入了很多小的事务,他们彼此影响,最终就会导致外部大的事务,丧失了事务的原子性。
举例:比如在A事务里面嵌套着B、C两个事务,当B事务完成之后提交,随后运行C事务,若C事务产生异常,则会回滚,然后A事务也会回滚,但是B事务已经提交成功,无法再回滚了。

传播事务的值及其用法:

传播属性的值外部不存在事务外部存在事务用法备注
REQUIRED开启新的事务融合到外部事务中@Transactional(propagation = Propagation.REQUIRED)增删改方法
SUPPORTS不开启事务融合到外部事务中@Transactional(propagation = Propagation.SUPPORTS)查询方法
REQUIRES_NEW开启新的事务挂起外部事务,创建新的事务@Transactional(propagation = Propagation.REQUIRES_NEW)日志记录方法中
NOT_SUPPORTED不开启事务挂起外部事务@Transactional(propagation = Propagation.NOT_SUPPORTED)及其不常用
NEVER不开启事务抛出异常@Transactional(propagation = Propagation.NEVER)及其不常用
MANDATORY抛出异常融合到外部事务中@Transactional(propagation = Propagation.MANDATORY)及其不常用

Spring为我们制定的传播属性的默认值是 REQUIRED

只读属性(readOnly)

针对于只进行查询操作的业务方法,可以加入只读属性,提高运行效率。

@Transactional(readOnly = true)

超时属性(timeout)

指定了事务等待的最长时间。

  1. 为什么要进行等待?
    答: 当前事务访问数据时,有可能访问的数据被事务进行加锁的处理,那么此时本事务就必须等待。

  2. 等待时间是以秒为单位的

  3. 使用方法:

    @Transactional(timeout = 2)
    
  4. 默认值:-1(最终由对应的数据库决定)

异常属性

Spring 在对事务处理过程中,如果程序抛出异常,会进行自动回滚。
默认请况下是当抛出RuntimeException及其子类的时候,会回滚;
而当抛出Exception时不会回滚,会直接提交。

如果想要改变,可以指定以下两个属性rollbackFor = {}noRollbackFor = {}

@Transactional(rollbackFor = {Exception.class})  //注意是class字节码

总结

使用建议:

  1. 隔离属性 默认值
  2. 传播属性 Required(默认值) 增删改 Supports 查询操作
  3. 只读属性 readOnly false 增删改 true 查询操作
  4. 超时属性 默认值 -1
  5. 异常属性 默认值
@Transactional //增删改操作
@Transactional(propagation=Propagation.SUPPORTS,readOnly=true)  //查询操作

基于标签的事务配置方式

完整配置如下:(只是把原来的<tx:annotation-driven>标签换掉了)

<?xml version="1.0" encoding="UTF-8"?>
<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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--配置数据库连接池-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydata"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <!--配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factoryBean">
        <!--指定DataSource数据库连接池-->
        <property name="dataSource" ref="dataSource" />
        <!--给实体类设置别名-->
        <property name="typeAliasesPackage" value="com.prince.entity" />
        <!--设置mapper.xml的文件路径-->
        <property name="mapperLocations">
            <list>
                <value>mapper/*Mapper.xml</value>
            </list>
        </property>
    </bean>

    <!--配置MapperScannerConfigurer-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="configurer">
        <!--SqlSessionFactoryBean-->
        <property name="sqlSessionFactoryBeanName" value="factoryBean" />
        <!--指定Dao接口所在的包-->
        <property name="basePackage" value="com.prince.dao" />

    </bean>

    <!--上面是Spring整合Mybatis-->

    <!--额外功能-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
        <!--传入dataSource数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--创建UserService对象-->
    <bean class="com.prince.service.UserServiceImpl" id="userService">
        <!--Spring与Mybatis整合的时候会创建一个UserDao,直接把这个UserDao注入即可-->
        <property name="userDao" ref="userDao"/>
    </bean>

    <!--事务属性-->
    <tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
        <tx:attributes>
            <!--相当于给login()方法加入@Transactional注解-->
            <tx:method name="login" propagation="SUPPORTS" read-only="true"/>
            <!--相当于给insert()方法加入@Transactional注解-->
            <tx:method name="insert"  />
        </tx:attributes>
    </tx:advice>

    <!--组装切面-->
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* com.prince.service.UserServiceImpl.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
    </aop:config>

</beans>

踩坑:一定要导入AOP编程的3个依赖spring-aop、aspectjrt、aspectjweaver,否则会报错!!!!

实战中的建议:

随着业务功能的增加,方法会越来越多,那么<tx:advice>里面的<tx:method>标签页会越来越多。
解决方案:

<!--事务属性-->
<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
    <tx:attributes>
        <tx:method name="modify*"/>	<!--所有的增删改方法以modify开头,加上通配符*可以匹配所有以modify开头的方法-->
        <tx:method name="*" propagation="SUPPORTS" read-only="true"/>  <!--剩下的查询方法,方法名可以是任意-->
    </tx:attributes>
</tx:advice>

<!--组装切面-->
<aop:config>
    <!--所有的业务类都放在service包下,匹配所有的方法-->
    <aop:pointcut id="pc" expression="execution(* com.prince.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
</aop:config>

ng-aop、aspectjrt、aspectjweaver,否则会报错!!!!==

实战中的建议:

随着业务功能的增加,方法会越来越多,那么<tx:advice>里面的<tx:method>标签页会越来越多。
解决方案:

<!--事务属性-->
<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
    <tx:attributes>
        <tx:method name="modify*"/>	<!--所有的增删改方法以modify开头,加上通配符*可以匹配所有以modify开头的方法-->
        <tx:method name="*" propagation="SUPPORTS" read-only="true"/>  <!--剩下的查询方法,方法名可以是任意-->
    </tx:attributes>
</tx:advice>

<!--组装切面-->
<aop:config>
    <!--所有的业务类都放在service包下,匹配所有的方法-->
    <aop:pointcut id="pc" expression="execution(* com.prince.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
</aop:config>