spring 事务详解，原理及其代码实现

已于 2022-01-26 08:51:05 修改
阅读量874 收藏 3
点赞数
分类专栏： 事务 文章标签： spring java 数据库
于 2022-01-25 17:59:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42219478/article/details/122680360
版权

事务分为编程式事务和声明式事务

1、所谓编程式事务，毫无疑问代码实现

如下：

//编程式事务
public class OrderServiceImpl implements orderService{

    @Autowired
    @Qualifier("transactionManager")//获取事务管理器
    private DataSourceTransactionManager transactionManager;

    public void update(Order order){

        //定义事务
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        //开启一个事务
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        //获取当前开启的事务状态   
        TransactionStatus transactionStatus = transactionManager.getTransaction(def);
        try{
            //update order 操作

            //提交
            transactionManager.commit(transactionStatus);
        }catch (Exception e){
            //回滚
            transactionManager.rollback(transactionStatus);
            logger.error("异常，已回滚",e);
        }
    }

}

1.1 编程式事务的优点：

1、代码实现，灵活度高；

2、可以调用内部方法。原因：；

3、回滚不受限于运行时异常，灵活选择是否回滚。

1.2 缺点：

操作复杂；

声明式事务，@Transactional注解

代码实现如下：

声明在方法上，则仅仅此方法加入事务管理。

@Service
public class OrderServiceImpl implements OrderService{
    
    @Transactional()
    public void update(Order order){
        //更新操作
    }
}

声明在类上 ，则，此类的所有方法均加入事务管理

@Transactional
public class OrderServiceImpl implements OrderService{
    
    
    public void update(Order order){
        //更新操作
    }
}

声明在接口上。

@Transactional
public interface OrderService{
    

}


public interface OrderService{

    @Transactional
    void update();
}

 不推荐这种使用方法，因为一旦标注在Interface上并且配置了Spring AOP 使用CGLib动态代理，将会导致@Transactional注解失效；

 @Transactional 注解是怎么生成代理类的呢？背后有怎么样的逻辑呢？我们一起来看看

生成代理类有两种方式：

1、jdk的反射实现，Porxy.newInstance(),强转目标代理类。实现来看看具体的代码（手动敲的哦，望各位赏个赞）；

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 代理工厂类
 */
public class ProxyFactory {

    @Autowired
    private TransactionalProcess transactionalProcess;

    /**
     * 动态代理实现
     */
    public void dynamicProxy(){
        //生成代理类
        TestService testService = new TestServiceImpl();
         //先判断是否有@Transactional注解
        if("有Transactional注解"){
            TestService proxyTestService = (TestService) java.lang.reflect.Proxy.newProxyInstance(testService.getClass().getClassLoader()
                    ,testService.getClass().getInterfaces(),transactionalProcess);
            proxyTestService.test();
        }
        //否则，直接执行dao方法
    }

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.transaction.TransactionManager;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 实现具体事务的方法
 */
@Component
public class TransactionalProcess implements InvocationHandler {

    @Autowired
    private TransactionManager txManager;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try{
            txManager.begin();
            method.invoke(args);
            txManager.commit();
            return null;
        }catch (Exception e){
            txManager.rollback();
        }finally {
        }
        return null;
    }
}
/**
 * 业务类
 */
@Service
public class TestServiceImpl implements TestService {

    @Override
    public void test() {
        System.out.println("21312331");
    }
}


/**
 * 业务接口
 */
public interface TestService {

    void test();
}

2、调用第三方包cglib实现，

Enhancer.create方法，然后强转，具体代码：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 代理工厂类
 */
public class ProxyFactory {

    
    /**
     * cglib实现
     */
    public  void cglibProxy(){
        TestService testService= new TestServiceImpl();
          //先判断是否有@Transactional注解
        if("有Transactional注解"){
            TestService proxyTestService = (TestService)Enhancer.create(testService.getClass(),new TransactionMethodInterceptor());

            proxyTestService.test();
        }
        //否则，直接执行dao方法
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class TransactionMethodInterceptor implements MethodInterceptor {

    @Autowired
    private TestService testService;

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //提供增强的代码
        Object returnValue = null;
        //判断当前方法是不是test方法
        if ("test".equals(method.getName())) {
            returnValue = method.invoke(testService);
        }
        return returnValue;
    }
}

完美了！时间有限，关于这点，我推荐大家读读这篇文章，已引入进来

动态代理简述:有两种实现方式，一是jdk反射机制代理，二是CGLIB增强代理。
这里只简述jdk反射机制的使用步骤:新建接口，新建接口的实现类，并编写具体实现内容，新建处理器类实现InvocationHandler，实现invoke方法，可以在其中写切面内容。然后使用时，调用Proxy.newProxyInstance方法，三个参数分别是，要代理的目标类的加载器，目标类实现的所有接口，处理器类。最后调用切点方法。

spring使用@Transactional事务传递时，假如说controller调用service中的方法A，注意这个调用过程是通过前面说的处理器调用的，a没有@Transactional这个注解，那么在走这个处理器的时候会先判断是否有这个注解，如果没有就不会走这个切点的切面方法，所以也就不会开启事务。接着在a方法里面有调用b方法，b方法有@Transactional注解，但是这个调用属于方法间的调用，不走代理，所以此时的注解并没有起作用，也就不会开启事务。
如果控制层直接调用service的b方法，那么是可以事务的。

如果先调用b方法，再调用a方法，无论a是否带@transactional注解，都会在b的事务中。因为了解aop的都知道，方法的实体是在前置后置之间执行的就如同事务前后的开启和关闭。

为什么呢？因为service层注入到控制层，对象是交给spring容器管理的，这就涉及到了spring三级缓存了，三级缓存中第三级存放的是aop代理对象。当控制层调用注入到自己类中的业务层方法时，是通过代理的，而在这个代理过程中，会有一个判断，判断该方法是否有@transactional注解，有就走带事务的语句，没有就直接执行sql.

解决办法，明白原理了，那么解决办法就是
1:把注解加到整个类上，这样就保证了任何一个方法都是通过代理调用的。
2在当前类中注入当前类，然后.方法去调用。或者是把方法放到别的bean中，注入进来，再.方法调用。

注解的作用:比如这里的@transactional注解作用就是通过所在方法是否有这个注解来判断的。如果这个注解中有方法就扩大了判断范围，比如@transactional提供的七个事务传递参数，也是通过判断走对应流程的
————————————————
版权声明：本文为优快云博主「小爷欣欣」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/csdnliuxin123524/article/details/120525146

@Transactional 的属性 

好了，接下来我们看看@Transactional 的属性（以下内容为摘抄，哈哈哈，望原创见谅哈）

propagation属性，代表事务的传播行为，有以下几种值：

Propagation.REQUIRED：默认的，如果当前存在事务，则加入该事务；如果当前不存在事务，则创建一个新的事务。( 也就是说如果A方法和B方法都添加了注解，在默认传播模式下，A方法内部调用B方法，会把两个方法的事务合并为一个事务 ）
Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行。
Propagation.MANDATORY：如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。
Propagation.REQUIRES_NEW：重新创建一个新的事务，如果当前存在事务，暂停当前的事务。( 当类A中的 a 方法用默认Propagation.REQUIRED模式，类B中的 b方法加上采用 Propagation.REQUIRES_NEW模式，然后在 a 方法中调用 b方法操作数据库，然而 a方法抛出异常后，b方法并没有进行回滚 )
Propagation.NOT_SUPPORTED：以非事务的方式运行，如果当前存在事务，暂停当前的事务。
Propagation.NEVER：以非事务的方式运行，如果当前存在事务，则抛出异常。
Propagation.NESTED ：和 Propagation.REQUIRED 效果一样。
isolation 属性，事务的隔离级别，默认值为 Isolation.DEFAULT：

Isolation.DEFAULT：使用底层数据库默认的隔离级别。
Isolation.READ_UNCOMMITTED
Isolation.READ_COMMITTED
Isolation.REPEATABLE_READ
Isolation.SERIALIZABLE
timeout 属性：事务的超时时间，默认值为 -1，表示没有时间限制。如果超过该时间限制但事务还没有完成，则自动回滚事务。

readOnly 属性：指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。

rollbackFor 属性：用于指定能够触发事务回滚的异常类型，可以指定多个异常类型。默认是RunTimeException

noRollbackFor：抛出指定的异常类型，不回滚事务，也可以指定多个异常类型。
————————————————
版权声明：本文为优快云博主「fei1234456」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/fei1234456/article/details/106646047

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值