spring基于注解配置实现事务控制操作

• • 3、创建jdbcconfig数据源配置类
  • 4、创建transactionconfig事务配置类
  • 5、创建jdbcconfig.properties
• spring注解方式的事务实现机制
• • aop动态代理进行方法拦截
• • 正确的设置 @transactional 的 propagation 属性（熟知事务的传播特性）
  • 正确的设置 @transactional 的 rollbackfor 属性
  • @transactional 只能应用到 public 方法才有效
  • 避免 spring 的 aop 的自调用问题，必须要跨service调用

spring注解配置实现事务控制

1、导入相关依赖

这个项目当中使用了spring的jdbctemplate模板类来用在控制层简化jdbc代码，如果你所用的项目运用的别的持久层框架，进行切换即可。

<dependencies>
      <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-context</artifactid>
            <version>5.0.2.release</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-jdbc</artifactid>
            <version>5.0.2.release</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-tx</artifactid>
            <version>5.0.2.release</version>
        </dependency>
</dependencies>

2、创建spring配置类

package config;
import org.springframework.context.annotation.componentscan;
import org.springframework.context.annotation.configuration;
import org.springframework.context.annotation.import;
import org.springframework.context.annotation.propertysource;
import org.springframework.transaction.annotation.enabletransactionmanagement;
/**
 * spring的配置类，相当于bean.xml
 */
@configuration	//声明是配置类
@componentscan("com.gzl") //开启spring注解扫描
@import({jdbcconfig.class,transactionconfig.class}) //加载jdbcconfig和transactionconfig类
@propertysource("jdbcconfig.properties") //加载.properties 文件中的配置
@enabletransactionmanagement //开启事务注解
public class springconfiguration {
}

3、创建jdbcconfig数据源配置类

package config;
import org.springframework.beans.factory.annotation.value;
import org.springframework.context.annotation.bean;
import org.springframework.jdbc.core.jdbctemplate;
import org.springframework.jdbc.datasource.drivermanagerdatasource;
import javax.sql.datasource;
/**
 * 和连接数据库相关的配置类
 */
public class jdbcconfig {
    @value("${jdbc.driver}")
    private string driver;
    @value("${jdbc.url}")
    private string url;
    @value("${jdbc.username}")
    private string username;
    @value("${jdbc.password}")
    private string password;
    /**
     * 创建jdbctemplate
     * @param datasource
     * @return
     */
    @bean(name="jdbctemplate")
    public jdbctemplate createjdbctemplate(datasource datasource){
        return new jdbctemplate(datasource);
    }
    /**
     * 创建数据源对象
     * @return
     */
    @bean(name="datasource")
    public datasource createdatasource(){
        drivermanagerdatasource ds = new drivermanagerdatasource();
        ds.setdriverclassname(driver);
        ds.seturl(url);
        ds.setusername(username);
        ds.setpassword(password);
        return ds;
    }
}

4、创建transactionconfig事务配置类

package config;
import org.springframework.context.annotation.bean;
import org.springframework.jdbc.datasource.datasourcetransactionmanager;
import org.springframework.transaction.platformtransactionmanager;
import javax.sql.datasource;
/**
 * 和事务相关的配置类
 */
public class transactionconfig {
    /**
     * 用于创建事务管理器对象
     * @param datasource
     * @return
     */
    @bean(name="transactionmanager")
    public platformtransactionmanager createtransactionmanager(datasource datasource){
        return new datasourcetransactionmanager(datasource);
    }
}

5、创建jdbcconfig.properties

jdbc.driver=com.mysql.jdbc.driver
jdbc.url=jdbc:mysql://localhost:3306/eesy
jdbc.username=root
jdbc.password=1234

6、使用事务注解

在需要添加事务的方法上添加@transactional

spring注解方式的事务实现机制

1、事务的实现机制

aop动态代理进行方法拦截

在应用系统调用声明@transactional 的目标方法时，spring framework 默认使用 aop 代理，在代码运行时生成一个代理对象，根据@transactional 的属性配置信息，这个代理对象决定该声明@transactional 的目标方法是否由拦截器 transactioninterceptor 来使用拦截。

在 transactioninterceptor 拦截时，会在在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最后根据执行情况是否出现异常，利用抽象事务管理器abstractplatformtransactionmanager 操作数据源 datasource 提交或回滚事务, 如下图所示。

注：上面两个xxxserviceimpl，表示的是同一个service的调用，前面用虚线，表示欲调用该service的方法，进入该service的方法前经历了aop进行拦截，然后才真正进入该service方法（后面的实线表示的service）

spring aop 代理有 cglibaopproxy 和 jdkdynamicaopproxy 两种，上图是以 cglibaopproxy 为例

• 对于 cglibaopproxy，需要调用其内部类的 dynamicadvisedinterceptor 的 intercept 方法。
• 对于 jdkdynamicaopproxy，需要调用其 invoke 方法。

事务管理器进行事务提交或回滚

事务管理的框架是由抽象事务管理器 abstractplatformtransactionmanager 来提供的，而具体的底层事务处理实现，由 platformtransactionmanager 的具体实现类来实现，如事务管理器 datasourcetransactionmanager。

不同的事务管理器管理不同的数据资源 datasource，比如 datasourcetransactionmanager 管理 jdbc 的 connection。

platformtransactionmanager，abstractplatformtransactionmanager 及具体实现类关系如图 2 所示。

2、注解方式的事务使用注意事项

当您对 spring 的基于注解方式的实现步骤和事务内在实现机制有较好的理解之后，就会更好的使用注解方式的事务管理，避免当系统抛出异常，数据不能回滚的问题。

正确的设置 @transactional 的 propagation 属性（熟知事务的传播特性）

需要注意下面三种 propagation 可以不启动事务。本来期望目标方法进行事务管理，但若是错误的配置这三种 propagation，事务将不会发生回滚。

• 1.transactiondefinition.propagation_supports：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
• 2.transactiondefinition.propagation_not_supported：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
• 3.transactiondefinition.propagation_never：以非事务方式运行，如果当前存在事务，则抛出异常。

正确的设置 @transactional 的 rollbackfor 属性

默认情况下，如果在事务中抛出了未检查异常（继承自 runtimeexception 的异常）或者 error，则 spring 将回滚事务；除此之外，spring 不会回滚事务。

如果在事务中抛出其他类型的异常，并期望 spring 能够回滚事务，可以指定 rollbackfor。

例：

@transactional(propagation= propagation.required,rollbackfor= myexception.class)

通过分析 spring 源码可以知道，若在目标方法中抛出的异常是 rollbackfor 指定的异常的子类，事务同样会回滚。

清单 3. rollbackruleattribute 的 getdepth 方法

private int getdepth(class<?> exceptionclass, int depth) {
        if (exceptionclass.getname().contains(this.exceptionname)) {
            // found it!
            return depth;
}
        // if we've gone as far as we can go and haven't found it...
        if (exceptionclass == throwable.class) {
            return -1;
}
return getdepth(exceptionclass.getsuperclass(), depth + 1);
}

@transactional 只能应用到 public 方法才有效

只有@transactional 注解应用到 public 方法，才能进行事务管理。

这是因为在使用 spring aop 代理时，spring 在调用transactioninterceptor 在目标方法执行前后进行拦截之前，dynamicadvisedinterceptor（cglibaopproxy 的内部类）的intercept 方法或 jdkdynamicaopproxy 的 invoke 方法会间接调用 abstractfallbacktransactionattributesource（spring 通过这个类获取@transactional 注解的事务属性配置属性信息）的 computetransactionattribute 方法。

abstractfallbacktransactionattributesource

protected transactionattribute computetransactionattribute(method method,
    class<?> targetclass) {
        // don't allow no-public methods as required.
        if (allowpublicmethodsonly() && !modifier.ispublic(method.getmodifiers())) {
return null;}

allowpublicmethodsonly方法由子类annotationtransactionattributesource实现，该子类方法中默认是true，所以当你加了事务注解的方法不是public时，该方法直接返回null

不会获取@transactional 的属性配置信息，最终会造成不会用 transactioninterceptor 来拦截该目标方法进行事务管理。

避免 spring 的 aop 的自调用问题，必须要跨service调用

在 spring 的 aop 代理下，只有目标方法由外部调用（也就是跨service调用），目标方法才由 spring 生成的代理对象来管理，这会造成自调用问题。

若同一类中的其他没有@transactional 注解的方法内部调用有@transactional 注解的方法，有@transactional 注解的方法的事务被忽略，不会发生回滚。

示例：

-->
@service
public class orderservice { 
    private void insert() {
        insertorder();
    }
    
    @transactional
    public void insertorder() {
        //insert log info
        //insertorder
        //updateaccount
    }
}

insertorder 尽管有@transactional 注解，但它被内部方法 insert 调用，事务被忽略，出现异常事务不会发生回滚。

事务的传播问题

propagation_requires_new只有在跨service时才会有效（也是上面自调用引起的）

class servicea{
  @transactional(rollbackfor = exception.class)
  public methoda1(){
     ......
     //该方式，methoda2上的事务注解不起作用，不会开启新的事务，methoda2与methoda1中的数据一起提交或回滚
     1.this.methoda2();
     //该方式，methodb1上的事务会启作用
     2.serviceb.methodb1()
     ......
  };
  @transactional(propagation = propagation.requires_new, rollbackfor = exception.class)
  public methoda2(){
     ......
  };
} 
class serviceb{
  @transactional(propagation = propagation.requires_new, rollbackfor = exception.class)
  public methodb1(){
     ......
  };  
}

原因在于，跨service调用方法时，都会经过

org.springframework.aop.framework.cglibaopproxy.dynamicadvisedinterceptor.intercept()方法

只有经过此处，才能对事务进行控制。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。