目录
    • 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()方法

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

以上为个人经验,希望能给大家一个参考,也希望大家多多支持www.887551.com。