今天写了一个小项目,熟悉了一下做spring项目的流程以及事务的使用


创建项目的步骤

  1. 新建maven项目
  2. 加入maven的依赖
    (1)spring依赖
    (2)mybatis依赖
    (3)mysql驱动
    (4)spring事务的依赖
    (5)mybatis和spring集成的依赖:mybatis官方提供的,用来在spring项目中创建mybatis的 SQLSessionFactory,dao对象的
  3. 创建实体类
  4. 创建dao接口mapper文件
  5. 创建mybatis主配置文件
  6. 创建service接口和实现类,属性是dao
  7. 创建spring的配置文件:声明mybatis的对象交给spring创建
    (1)数据库
    (2)SQLSessionFactory
    (3)dao对象
    (4)声明自定义的service
  8. 创建测试类,获取service对象,通过service调用dao完成数据库的访问

事务

spring处理事务的模型,使用的步骤都是固定的。把事务使用的信息提供给spring就可以了

  1. 事务内部提交,回滚事务,使用的事务管理器对象,代替你完成commit,rollback
    事务管理器是一个接口和他的众多实现类。
    接口:PlatformTransactionManager ,定义了事务重要方法 commit ,rollback
    实现类:spring把每一种数据库访问技术对应的事务处理类都创建好了。
    mybatis访问数据库---spring创建好的是DataSourceTransactionManager
    hibernate访问数据库----spring创建的是HibernateTransactionManager
    怎么使用:你需要告诉spring 你用是那种数据库的访问技术,怎么告诉spring呢?
    声明数据库访问技术对于的事务管理器实现类, 在spring的配置文件中使用<bean>声明就可以了
    例如,你要使用mybatis访问数据库,你应该在xml配置文件中
    <bean id=“xxx" class="...DataSourceTransactionManager"> </bean>

  2. 你的业务方法需要什么样的事务,说明需要事务的类型。
    说明方法需要的事务:

    1. 事务的隔离级别:有4个值。
      DEFAULT:采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ; Oracle默认为 READ_COMMITTED。
      ➢ READ_UNCOMMITTED:读未提交。未解决任何并发问题。
      ➢ READ_COMMITTED:读已提交。解决脏读,存在不可重复读与幻读。
      ➢ REPEATABLE_READ:可重复读。解决脏读、不可重复读,存在幻读
      ➢ SERIALIZABLE:串行化。不存在并发问题。
    1. 事务的超时时间: 表示一个方法最长的执行时间,如果方法执行时超过了时间,事务就回滚。
      单位是秒, 整数值, 默认是 -1.

    2. 事务的传播行为 : 控制业务方法是不是有事务的, 是什么样的事务的。
      7个传播行为,表示你的业务方法调用时,事务在方法之间是如果使用的。

      PROPAGATION_REQUIRED
      PROPAGATION_REQUIRES_NEW
      PROPAGATION_SUPPORTS
      以上三个需要掌握的

      PROPAGATION_MANDATORY
      PROPAGATION_NESTED
      PROPAGATION_NEVER
      PROPAGATION_NOT_SUPPORTED

  1. 事务提交事务,回滚事务的时机
    1. 当你的业务方法,执行成功,没有异常抛出,当方法执行完毕,spring在方法执行后提交事务。事务管理器commit
    2. 当你的业务方法抛出运行时异常或ERROR, spring执行回滚,调用事务管理器的rollback
      运行时异常的定义: RuntimeException 和他的子类都是运行时异常, 例如NullPointException , NumberFormatException
    3. 当你的业务方法抛出非运行时异常, 主要是受查异常时,提交事务
      受查异常:在你写代码中,必须处理的异常。例如IOException, SQLException

总结spring的事务

  1. 管理事务的是 事务管理和他的实现类
  2. spring的事务是一个统一模型
    1. 指定要使用的事务管理器实现类,使用
    2. 指定哪些类,哪些方法需要加入事务的功能
    3. 指定方法需要的隔离级别,传播行为,超时
    ** 你需要告诉spring,你的项目中类信息,方法的名称,方法的事务传播行为。**

spring框架中提供的事务处理方案

适合中小项目使用的, 注解方案。
spring框架自己用aop实现给业务方法增加事务的功能, 使用@Transactional注解增加事务。
@Transactional注解是spring框架自己注解,放在public方法的上面,表示当前方法具有事务。
可以给注解的属性赋值,表示具体的隔离级别,传播行为,异常信息等等

** 使用@Transactional的步骤:**

  1. 需要声明事务管理器对象

    <bean class="DataSourceTransactionManager" id="xx"> </bean>
  2. 开启事务注解驱动, 告诉spring框架,我要使用注解的方式管理事务。
    spring使用aop机制,创建@Transactional所在的类代理对象,给方法加入事务的功能。
    spring给业务方法加入事务:
    在你的业务方法执行之前,先开启事务,在业务方法之后提交或回滚事务,使用aop的环绕通知

    @Around("你要增加的事务功能的业务方法名称")
        Object myAround(){
          开启事务,spring给你开启
             try{
                buy(1001,10);
                 spring的事务管理器.commit();
             }catch(Exception e){
            spring的事务管理器.rollback();
             }
    
        }
  3. 在你的方法的上面加入@Trancational
    下面代码是实际业务中的使用

    <!--声明spring的事务处理-->
    <!--声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <!--连接的数据库-->
       <property name="dataSource" ref="myDataSource"/>
    </bean>
    
    <!--开启事务注解驱动-->
    <!--transaction:事务管理器-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    
    
    

/*
*rollbackFor 表示发生指定的异常一定回滚
*括号里面都是默认值,不写也可以
*/
/
@Transactional(
propagation = Propagation.REQUIRED,
isolation = Isolation.DEFAULT,
readOnly = false,
rollbackFor = {
NullPointerException.class,NotEnoughException.class
}
)*/
@Transactional
//下面是业务方法,这里省略了

***
**适合大型项目,有很多的类,方法,需要大量的配置事务,使用aspectj框架功能,在spring配置文件中**
**声明类,方法需要的事务。这种方式业务方法和事务配置完全分离。**

  **实现步骤: 都是在xml配置文件中实现。** 
   1. 要使用的是aspectj框架,需要加入依赖
```java
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>

   2. 声明事务管理器对象
```java
    <bean id="xx" class="DataSourceTransactionManager">
  1. 声明方法需要的事务类型(配置方法的事务属性【隔离级别,传播行为,超时】)

  2. 配置aop:指定哪些哪类要创建代理。
    下面代码是实际业务中的使用

    //pom中加入依赖
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.5.RELEASE</version>
    </dependency>
    //声明式事务处理,和源代码完全分离的
    //1,声明事务管理对象
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="myDataSource"/>
    </bean>
    //2,声明业务方法它的事务属性(隔离级别,传播行为,超时事件)
      id:自定义名称  表示<tx:advice中的配置内容
      transaction-manager
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
      //<tx:attributes>配置事务属性
      <tx:attributes>
          //<tx:method:给具体的方法配置事务属性,method可以有多个,分别给不同的方法设置事务属性
              //name:方法名称  (1)完整的方法名称,不带有包和类
                             // (2)方法可以使用通配符* 表示任意字符
              //propagation:传播行为,枚举值
              //isolation:隔离级别
              //rollback-for:指定的异常类名,全限定名称。发生异常一定回滚
    
          <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                     rollback-for="java.lang.NullPointerException,com.myproject.execp.NotEnoughException"/>
          //使用通配符 指定很多的方法。一定要有命名规范
    
          <tx:method name="add*" propagation="REQUIRES_NEW"/>
          //可以写很多啊  修改删除这些
    
          //下面这个*表示上面这些方法以外的所有方法,也就是查询啊,要用SUPPORTS和只读
          <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
      </tx:attributes>
    </tx:advice>
    
    //如果想指定哪些类配置,还需要配置aop
    <aop:config>
      /*
          id:切入点表达式的名称,唯一值
          expression:指定哪些类使用事务,aspectj会创建代理对象
    */
     //任意包及其子包的所有service包及其子包的所有类的所有方法和所有参数
      <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
    
      //配置增强器:关联advice和pointcut
      /*advice-ref 通知上面tx:advice哪里配置
          pointcut-ref:切入点表达式的id
      */
      <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    </aop:config>