Spring 持久层整合

Spring 持久层整合

1 持久层整合

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

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

1.2 Spring可以与哪些持久层技术进行整合?

1. JDBC
	|- JDBCTemplate	
2. Hibernate 
	|- HibernateTemplate
3. MyBatis
	|- SqlSessionFactoryBean MapperScannerConfigurer
	

2 Spring与MyBatis整合

2.1 MyBatis 开发步骤的回顾

1. 实体
2. 实体别名    			配置繁琐
3. 表
4. 创建dao接口
5. 实现mapper文件
6. 注册的mapper文件 		配置繁琐
7. MyBatis API调用 	   代码冗余

2.2 MyBatis在开发过程中存在问题

配置繁琐 代码冗余

2.3 Spring与MyBatis 整合思路分析

  • SqlSessionFactoryBean
    • dataSource
    • typeAliasesPackage
    • mapperLocations
    • (可有) configLocation
  • MapperScannerConfigure
    • sqlSessinFactoryBeanName
    • basePackage

image-20200920084430899

2.4 Spring与Mybatis整合的开发步骤

  • 配置文件(application.xml) 进行相关配置

    <!--配置 只需要配置-->
    <!--创建SqlSessionFactory-->
    <bean id ="ssfb" class="..SqlSessionFactoryBean">
    	<property name = "dataSouce" ref = ""/>
    	<property name = "typeAliasesPackage" value = "com.leetao.dao"/>指定 实体类所在的包 
        <property name = "mapperLocations">
        	指定 配置文件(映射文件)的路径 还有通用配置
        	mapper/*Mapper.xml
        </property>
    </bean>
    <!--创建DAO接口的实现类-->
    <!--session -> session.getMapper() -> xxxDAO实体类对象 -->
    <!-- XXXDAO -> xXXDAO -->
    <bean id = "scanner" class = "..MapperScannerConfigure">
    	<property name = "sqlSessionFactoryBeanName" value = "ssfb" />
        <property name = "basePackage">
        	指定 DAO接口放置的包 com.leetao.dao 
        </property>
    </bean>
    
  • 编码

    # 实战经常根据需求 写的代码
    1. 实体
    2. 表
    3. 创建dao接口
    4. 实现mapper文件
    

2.5 Spring与MyBatis整合代码

  • 搭建开发环境(jar)
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.5</version>
</dependency>
  • Spring配置文件的配置

    <context:property-placeholder location="classpath:db.properties"/>
    <!--连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--创建SqlSessionFactory SqlSessionFactoryBean-->
    <bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.leetao.mybatis.domain"/>
        <property name="mapperLocations">
            <list>
                <value>classpath:com.leetao.mybatis.mapper/*Mapper.xml</value>
            </list>
        </property>
    </bean>
    <!--创建DAO对象 mapperScannerConfigure-->
    <bean id="scanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="SqlSessionFactory"/>
        <property name="basePackage" value="com.leetao.mybatis.mapper"/>
    </bean>
    
  • 编码

    1. 实体
    2. 表
    3. 创建dao接口
    4. mapper文件配置
    

2.6 Spring与MyBatis整合的细节

  • 问题:Spring与MyBatis整合后,为什么DAO不提交事务,但是数据能够插入数据库中?

    Connection -->tx
    MyBatis(Connection)
    ------------------------------------
    本质上控制连接对象(Connection) ---> 连接池(DataSource)
    1. Mybatis 提供的连接池对象 --> 创建Connection
    	Connection.setAutoCommit(false) 手工的控制了事务,操作完成后,手动提交
    2. Druid(C3P0 DBCP)作为连接池 -->创建Connection
    	Connection.setAutoCommit(true) true默认值,保持自动控制事务,一条sql 自动提交
    -----------------------------------
    
    注意:在未来实战中,我们还会手工控制事务(多条sql一起成功,一起失败),后续Spring通过事务控制解决这个问题
    
    事实上所有上面这些连接池都是自动提交的
    包括 pooledDataSource 
    
    以上为孙帅老师讲解.
    
    
    1. 菅江晖个人认为 mybatis没整合之前 使用SqlSession来获取Mapper.而SqlSession默认是不自动提交的. 
    
    2. mybatis与Spring整合后.使用SqlSessionTemplase类通过动态代理创建来执行Mapper方法.SqlSessionTemplase中的SqlSession其实也是不自动提交的,其中invoke方法中会判读是否为sql会话事务.如果不是将会提交.同时执行结束后也会关闭sqlSession 这也解释了为什么使用代理后的mapper 无需手动创建 关闭sqlsession 都是动态代理的功劳 AOP  
    

3 Spring的事务处理

3.1 什么是事务? ACID

保证业务操作完整性的一种数据库机制
事务4特点  A C I D
1. A 原子性
2. C 一致性
3. I 隔离性
4. D 持久性

3.2 如何控制事务

JDBC: 
	Connection.setAutoCOmmit(false);
	Connection.commit();
	COnnetion.rollback();
MyBatis:
	MyBatis自动开始事务
	SqlSession(Connection).commit();
	SqlSession(Connection).rollback();
    
结论:控制事务的底层,都是Connection对象完成的.

3.3 Spring控制事务的开发

Spring是通过AOP的方式进行事务开发的
  1. 原始对象

    public class xxxUserServiceImpl{
    	1.原始对象---> 原始方法 ---> 核心功能(业务处理+DAO调用)
    	2.DAO作为Service的成员变量,依赖注入的方式进行赋值
    }
    
  2. 额外功能

    1. org.springframework.jdbc.datasource.DataSourceTransactionManager
    2. 注入DataSource
    1. MethodInterceptor
    ---------------------------------------------------------
    	public Object invoke(MethodInvocation invocation) {
    		Connection.setAutoCommit(false);
    		invocation.proceed();
    		Connection.commit();
    		if throw Exception
    		Commction.rollback();	
    	}
    2. @Aspect
    	@Around
    
  3. 切入点

    @Transactional
    事务的额外功能加入给那些业务方法.
    
    1.类上:类中所有方法都会加入事务
    2.方法上:这个方法会加入事务
    
  4. 组装切面

    1. 切入点
    2. 额外功能
    <tx:annotaion-driven transaction-manager="" />
    

3.4 Spring控制事务的编码

  • 搭建开发环境(jar)

  • 编码

    <bean id = "userService" class="com.leetao.mybatis.service.impl.UserServiceImpl">
    <property name="userMapper" ref="userMapper"/>
    </bean>
    
    <!--DataSourceTransactionManager-->
    <bean id = "dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
    </bean>
    --------------------------
    
    @Transactional
    public class UserServiceImpl implements UserService {}
    --------------------------
    
    <tx:annotation-driven transaction-manager = "dataSourceTransactionManager"/>
    
    
  • 细节

    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>
    进行动态代理底层的切换 proxy-target-class
    	默认 false 	JDK
    		true   	 Cglib
    

4 Spring中的事务属性 Transaction Attribute

4.1 什么是事务属性

属性:描述物体特征的一系列值
	性别 身高 体重 ...
事务属性:描述事务特征的一系列值
1. 隔离属性
2. 传播属性
3. 只读属性
4. 超时属性
5. 异常属性 

4.2 如何添加事务属性

@Transactional(isolation=,propagation=
readOnly=,timeout=,rollbackFor=,noRollbackFor=,)

4.3 事务属性详解

4.3.1 隔离事务(ISOLATION)

  • 隔离属性的概念

    概念: 他描述了事务解决并发问题的特征
    1. 什么是并发
    	多个事务(用户)在同一时间,访问操作了相同的数据
    	
    	同一时间: 0.000几秒 微小前,微小后
    2. 并发会产生哪些问题
    	1.脏读
    	2.不可重复读
    	3.幻影读
    3. 并发问题如何解决
    	通过隔离属性解决 隔离属性中设置不同的值,解决并发处理过程中的问题.
    
  • 事务并发产生的问题

    1.脏读

    一个事务,读取了另一个事务中没有提交的数据.会在本事务中产生数据不一致的问题.
    解决方案: @Transactional(isolation=Isolation.READ_COMMITTED)
    

    2.不可重复读

    一个事务中,多次读取相同的数据,但是读取结果不一样.会在本事务中产生数据不一致的问题
    注意:1 不是脏读 2 一个事务中
    解决方案: @Transactional(isolation=Isolation.REPEATABLE_READ)
    本质 行锁
    

    3.幻影读

    一个事务中,多次对整表进行查询统计,但是结果不一样,会在本事务中产生数据不一致的问题
    解决方案: @Transactional(isolation.SERIALIZABLE)
    本质 表锁
    
  • 总结

    并发安全: SERIALIZABLE > REPEATABLE > READ_COMMITTED
    运行效率:READ_COMMITTED > REPEATABLE > SERIALIZABLE
    
  • 数据库对于隔离属性的支持

隔离属性的值MySQLOracle
ISOLATION.READ_COMMENTTED
ISOLATION.REPEATABLE_READ
ISOLATION.SERIALIZABLE
Oracle不支持REPEATABLE_READ值 如何解决不可重复读
采用的是多版本对比的方式 解决不可重复读的问题
  • 默认隔离属性

    ISOLATION_DEFAULT:会第哦啊用不同数据库所设置额默认隔离属性
    
    MySQL -> REPEATABLE_READ
    Oracle -> READ_COMMITTED
    
    
    • MySQL

      select @@tx_isolation;
      
    • Oracle

    image-20200920160653594

  • 隔离属性在实战中的建议

    推荐使用Spring指定调度ISOLATION.DEFAULT
    MySQL -> REPEATABLE_READ
    Oracle -> READ_COMMITTED
    未来中的实战中,并发访问情况 很低
    
    如果真遇到并发问题,乐观锁
    	Hibernate(JPA) Version
    	MyBatis 通过拦截器自定义开发
    

4.3.2 传播属性(PROPAGATION)

  • 传播属性的概念

    概念:他描述了事务解决嵌套问题的特征
    
    什么叫做事务的嵌套:一个大的事务中,包含了若干个小的事务.
    问题:大事务中融入了很多小的事务,他们彼此影响,最终导致大的事务丧失了事务的原子性
    
    

    image-20200920161843153

    传播属性的值外部不存在事务外部存在事务用法备注
    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)极其不常用
  • 默认的传播属性

    REQUIRED是传播属性的默认值
    
  • 推荐传播属性的使用方式

    增删改 方法:直接使用默认的REQUIRED
    查询 	 操作:显示指定传播属性的值为SUPPORTS 
    

4.3.3 只读属性(readOnly)

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

4.3.4 超时属性(timeout)

指定了事务等待的最长时间 
1. 为什么事务进行等待?
当前事务访问数据时,有可能访问的数据被别的事务进行加锁的处理,那么此时本事务就必须进行等待.
2. 等待时间 秒
3. 如何应用 @Transactional(timeout=2)
4. 超时属性的默认值 -1 
	最终由对应的数据库来指定

4.3.5 异常属性

Spring 事务处理中
默认 对于RuntimeException及其子类 采用的是回滚的策略
默认 对于Exception 采用的是提交的策略

//让他回滚
rollbackFor = (..Exception,*Exception)
//让他不回滚 
noRollbackFor = (..RuntimeException)

@Trancastional(rollbackFor= {java.lang.Exception.class},noRollbackFor = {java.lang.RuntimeException.class})
建议:实战中使用RuntimeException极其子类 使用事务异常属性的默认值.

4.4 事务属性常见配置总结

1. 隔离属性	默认值
2. 传播属性 Required(默认值) 增删改   Supports 查询操作
3. 只读属性 false(默认值) 增删改 		true 查询操作
4. 超时属性 默认值 -1
5. 异常属性 默认值

增删 改操作   @Transactional
查询操作	@Transactional(Propagation=Propagetion.SUPPORTS,readOnly=true)

5 基于标签的事务配置方式(事务开发的第二种形式)

基于注解 @Transactional的事务配置回顾
<bean id = "userService" class="com.leetao.mybatis.service.impl.UserServiceImpl">
    <property name="userMapper" ref="userMapper"/>
</bean>

<!--DataSourceTransactionManager-->
<bean id = "dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

@Transactional
public class UserServiceImpl implements UserService { }

<tx:annotation-driven transaction-manager="dataSourceTransactionManager"  />


基于标签的事务配置
<bean id = "userService" class="com.leetao.mybatis.service.impl.UserServiceImpl">
    <property name="userMapper" ref="userMapper"/>
</bean>

<!--DataSourceTransactionManager-->
<bean id = "dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
事务属性
<tx:advice id = "txAdvice" transaction-manager = "dataSourceTransactionManager">
	<tx:attributes>
    	<tx:method name = "register"isolation = "" propagation=""></tx:method>
        等效于 
        @Transactional(isolation=,propagation=,)
        public void register(){
        }
    </tx:attributes>
</tx:advice>
	<!--AOP -->
<aop:config>
    <aop:pointcut id="pc" expression="execution(* com.leetao.mybatis.service..*(..))"/>
    <aop:advisor advice-ref="interceptor" pointcut-ref="pc"/>
</aop:config>
  • 基于标签的事务配置在实战中的应用方式
<bean id = "userService" class="com.leetao.mybatis.service.impl.UserServiceImpl">
    <property name="userMapper" ref="userMapper"/>
</bean>

<!--DataSourceTransactionManager-->
<bean id = "dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

编程时候 servie中负责进行增删改操作的方法 都以modify开头
				查询 命名无所谓
<tx:advice id="txAdvice" transaction-manager = "dataSOurceTransactionManager">
	<tx:attributes>
        <!--先配置的优先级更高-->
    	<tx:method name = "modify*"></tx:method>
    	<tx:method name = "*" propagation="SUPPORTS" readOnly="true"></tx:method>
    </tx:attributes>
</tx:advice>

应用的过程中,service放置到service包中
<aop:config>
    <aop:pointcut id="pc" expression="execution(* com.leetao.mybatis.service..*.*(..))"/>
    <aop:advisor advice-ref="interceptor" pointcut-ref="pc"/>
</aop:config>

约定大于配置

异常汇总

BeanCurrentlyInCreationException Bean循环依赖异常

检查代码 分析错误

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页