1. 什么是事务?

保证业务操作完整性的一种数据库机制

事务的4特点: A C I D
1. A 原子性
2. C 一致性
3. I 隔离性
4. D 持久性

1.1 如何控制事务(不包含spring)

JDBC:
	Connection.setAutoCommit(false)
	Connection.commit();
	Connection.rollback();
Mybatis:
	Mybatis自动开启事务
	
	sqlSession(底层Connection对象).commit();
	sqlSession(底层Connection对象).rollback();
	
结论: 控制事务的底层,都是Connection对象完成的

1.2 Spring控制事务的开发

Spring是通过AOP方式进行事务开发

1.2.1 原始对象

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

1.2.2 额外功能

1. Spring 处理事务的额外功能
	org.springFramework.jdbc.datasource.DateSourceTransactionManager
	注入Connection  ---> 实际上 注入DateSource


2. 普通事务的处理过程
	MethodInterceptor
	    public Object invoke(MethodInvoke invocation){
            try{
                //开启事务
                Connection.setAutoCommit(false)

                Object ret = invocation.proceed();

                //事务提交
                Connection.commit();
               } catch(Exception e){
                    //事务回滚
                    Connection.rollback();
               }
                return ret;
		}
	
3. 注解普通事务处理过程
	@Aspect
	@Around

1.2.3 切入点

@Transactional
事务的额外功能加入给那些业务方法

1. 类上: 类中所有的方法都会加入事务
2. 方法上: 这个方法会加入事务

1.2.4 组装切面

1. 切入点
2. 额外功能

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

1.3 Spring控制事务的编码

• 搭建开发环境(jar)

  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.1.14.RELEASE</version>
  </dependency>
  

• 编码

  <!--原始对象-->
  <bean id="userService" class="com.fadedos.service.UserServiceImpl">
      <property name="userDao" ref="userDao"/>
  </bean>
  
  <!--额外功能 Spring的DateSourceTransactionManager-->
  <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dateSource"/>
  </bean>
  
  <!--切入点-->
  @Transactional
  public class UserServiceImpl  implements UserService{
      private UserDao userDao;
  
  <!--组装 注意名称空间 结尾为tx-->
  <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
  

• 细节

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

2. Spring中事务属性(Transaction Attribute)

2.1 什么是事务属性

属性: 描述物体特征的一系列值
		性别 身高 体重 ....

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

2.2 如何添加事务属性

@Transactional(isoloation= , propagation= , readonly= ,timeout= , rollbackFor= ,noRollbackFor=)

2.3 事务属性详解

2.3.1 隔离属性(isolation)

• 隔离属性的概念

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

• 事务并发产生的问题

  • 脏读

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

  • 不可重复读

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

  • 幻读

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

  • 总结

    并发安全: SERIALIZABLE > REPEATABLE_READ > READ_COMMITED
    
    运行效率: READ_COMMITED > REPEATABLE_READ > SERIALIZABLE
    

• 数据库对于隔离属性的支持

  隔离属性的值	Mysql	Oracle
  Isolation.READ_COMMITED	Yes	Yes
  Isolation.REPEATABLE_READ	Yes	No
  Isolation.SERIALIZABLE	Yes	Yes

  Oracle不支持REPEATABLE_READ值 如何解决不可重复读
  采用的是多版本比对的方式 解决不可重复读的问题  version+乐观锁
  

• 默认的隔离属性

  ISOLATION_DEFAULT: 会调用不同数据库所设置的默认隔离属性
  
  Mysql : RepeatAble_read
  
  Oracle : read_committed
  

• 隔离属性在实战中建议

  推荐使用Spring指定的ISOLATION_DEFAULT
  1. Mysql repeatable_read
  2. Oracle read_commited
  
  实际开发项目,并发访问情况 很低
  
  如果真遇到并发问题,使用乐观锁
  	HIbernate(JPA) Version
  	Mybatis        通过拦截器自定义开发
  

2.3.2 传播属性(PROPAGATION)

• 传播属性的概念

  概念: 它描述了事务解决嵌套问题的特征 
  
  什么叫做事务的嵌套?
  
  问题: 大事务中融于了很多小事务,他们彼此影响,最终就会导致外部大的事务,丧失了事务的原子性
  

• 传播属性的值及其用法

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

• 默认的传播属性

  PROPAGATION_REQUIRED: 是传播属性的默认值
  

• 推荐传播属性的使用方式

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

2.3.3 只读属性(readOnly)

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

默认值: false

@Transactional(propagation = Propagation.MANDATORY)
public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
	
    // 增加方法 使用外部方法默认的 
    @Override
    public void register(User user) {
        userDao.save(user);
        throw new RuntimeException("测试");
    }

	
    //login 查询
    @Override
    @Transactional(propagation = Propagation.SUPPORTS,readOnly = true)
    public void login(String name, String password) {

    }
}

2.3.4 超时属性(timeout)

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

1. 为什么事务进行等待
	当前事务访问数据时,有可能访问的数据被别的事务进行加锁的处理,那么此时本事务就必须进行等待
	
2. 等待时间    秒

3. 如何应用 @Transactional(timeout=2)

4. 超时属性的默认值 -1 
	最终对应的数据来指定

2.3.5 异常属性

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

rollbackFor = {java.lang.Exception,xxx,xxx}
noRollbackFor = {java.lang.RunException,xxx,xxx}

@Transactional(rollbackFor = {Exception.class},noRollbackFor = {RuntimeException.class})

建议: 项目开发中使用RuntimeException及其子类 使用事务异常属性默认值

2.4 事务属性常见配置总结

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


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

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

基于注解@Transactional的事务回顾
<!--原始对象-->
<bean id="userService" class="com.fadedos.service.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
</bean>

<!--额外功能 Spring的DateSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dateSource"/>
</bean>

<!--切入点-->
@Transactional(isolation= ,propagation= ,...)
public class UserServiceImpl  implements UserService{
    private UserDao userDao;

<!--组装 注意名称空间 结尾为tx-->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>


基于标签的事务配置
<!--原始对象-->
<bean id="userService" class="com.fadedos.service.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
</bean>

<!--额外功能 Spring的DateSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dateSource"/>
</bean>

事务属性
<tx:advice id="txadvice" transaction-Manager="dataSourceTransactionManager">
    <tx:attributes>
        <tx:method name="register" isolation="" propagation=""></tx:method>
        <tx:method name="login" isolation="" propagation=""></tx:method>
        等效于
    		@Transactional(isolation= ,propagation= ,...)
    		public void register(User user) {

    		}
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="pc" expression="execution(* com.fadedos.service.UserServiceImpl.register(..))"></aop:pointcut>
    <aop:advisor advice-ref="txadvice" pointcut-ref=""></aop:advisor>
</aop:config>

• 基于标签的事务配置方式在实战中的应用方式

  <!--原始对象-->
  <bean id="userService" class="com.fadedos.service.UserServiceImpl">
      <property name="userDao" ref="userDao"/>
  </bean>
  
  <!--额外功能 Spring的DateSourceTransactionManager-->
  <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dateSource"/>
  </bean>
  
  编程时候 service中负责进行增删改操作的方法 都已modify开头
  					  查询操作 命名无所无
  <tx:advice id="txadvice" transaction-Manager="dataSourceTransactionManager">
      <tx:attributes>
          <tx:method name="register"></tx:method>
          <tx:method name="modify*"></tx:method>
          <tx:method name="*" propagation="SUPPORTS" read-only="true"></tx:method>
      </tx:attributes>
  </tx:advice>
  
  应用过程中 service放置到service包中
  <aop:config>
      <aop:pointcut id="pc" expression="execution(* com.fadedos.service..*.*(..))"></aop:pointcut>
      <aop:advisor advice-ref="txadvice" pointcut-ref=""></aop:advisor>
  </aop:config>