Spring 事务失效那点事

最新推荐文章于 2024-02-27 17:49:01 发布
最新推荐文章于 2024-02-27 17:49:01 发布
阅读量9.5k 收藏 6
点赞数
分类专栏： 技术 文章标签： spring 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rylan11/article/details/76609643
版权

工作满三年了，总觉得不看点源码啥的，肚子里没啥东西。前一阵打算实际的看点spring源码啥的看了，看了几天也没记住多少，还是带着问题分析源码记忆比较深
刻，好闲话少说，上问题。
前几天在处理事务的时候遇到了，事务不生效的情况。

public interface VideoTestService {

    void test1();

    void test2();

    void test3();

    void test4();

    void test5();
}

@Service
public class VideoTestServiceImpl implements VideoTestService{
    @Override
    public void test1() {
        System.out.println("test1()");
    }

    @Override
    public void test2() {
        System.out.println("test2()");
        test3();
    }

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

    @Override
    public void test4() {
        System.out.println("test4()");
        VideoTestService service = (VideoTestService)AopContext.currentProxy();
        service.test5();
    }

    @Override
    public void test5() {
        System.out.println("test3()");
    }
}

@Service
public class VideoTestService2 {

    private static final Logger logger = LoggerFactory.getLogger(VideoTestService2.class);

    public void test1() {
        System.out.println("test1()");
    }

    public void test2() {
        System.out.println("test2()");
        test3();
    }

    public void test3() {
        System.out.println("test3()");
    }
    public void test4() {
        System.out.println("test4()");
        VideoTestService2 service = (VideoTestService2)AopContext.currentProxy();
        service.test5();
    }

    public void test5() {
        System.out.println("test5()");
    }
    public void add() {
        System.out.println("add()");
        test1();

    }
}

事务切点配置 execution(* com.test.java.service..impl..test*(..))

@Aspect
public class ServiceConfigAspect {

    /**
     * 定义切入点函数
     */
    @Pointcut("execution(* com.test.java.service.impl.*.test*(..))")
    void pointcut() {
    }

    /**
     * 使用@Before声明前置通知
     * @param thisJoinPoint
     */
    @Before("pointcut()")
    public void beforeExecute(JoinPoint thisJoinPoint){
        System.out.println("before ...");
    }

    /**
     * 使用@After 注解声明后置通知
     * @param thisJoinPoint
     */
    @After("pointcut()")
    public void afterExecute(JoinPoint thisJoinPoint){
        System.out.println("end......");
    }
}

public class TestServiceAop extends BaseTest {

    @Autowired
    private VideoTestService videoTestService;

    @Autowired
    private VideoTestService2 videoTestService2;

    @Test
    public void test(){
         System.out.println(""+ AopUtils.isCglibProxy(videoTestService));
        System.out.println(""+AopUtils.isJdkDynamicProxy(videoTestService));
        System.out.println(""+ AopUtils.isCglibProxy(videoTestService2));
        System.out.println(""+AopUtils.isJdkDynamicProxy(videoTestService2));

        System.out.println("\n--------------------------");
        videoTestService.test1();

        videoTestService.test2();

        videoTestService.test4();

        System.out.println("\n--------------------------");

        videoTestService2.test1();

        videoTestService2.test2();

        videoTestService2.test4();

        videoTestService2.add();

        System.out.println("\n--------------------------");
     } 
   }

为了直观的显示过程，用ServiceConfigAspect模拟了 事务处理过程，把开启事务和事务提交用beforeExecute和afterExecute分别代替。
执行结果：
false
true
true
false

before …
test1()
end……
before …
test2()
test3()
end……
before …
test4()
before …
test3()
end……
end……

before …
test1()
end……
before …
test2()
test3()
end……
before …
test4()
before …
test5()
end……
end……
add()
test1()

为什么会出现这样的情况呢？我们自认为的事务videoTestService.test2(); 和videoTestService2.test2(); videoTestService2.add();都没生效，我们考虑下日常的写代码的过程中是不是也写过这样随意加事务(@Transactional)的代码,或是在一个事务里面嵌套this.methodB(事务方法)和一个普通类里面this.methodB (事务方法)，其实这样都是不生效的。下面我们来详细的分析下原因。
首先对于VideoTestService和VideoTestService2的区别是一个是接口的实现类bean另一个是普通的bean，这两个在spring中使用的是不同的方式生成。
Aop 技术其实可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；(AspectJ)；而动态代理则在运行时借助于 默写类库在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。其中java是使用的动态代理模式 (JDK+CGlib)。
Spring的动态代理包括两个部分：
· JDK动态代理
JDK动态代理主要涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。InvocationHandler是一个接口，通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态将横切逻辑和业务逻辑编制在一起。
Proxy利用InvocationHandler动态创建一个符合某一接口的实例，生成目标类的代理对象。

· CGLib动态代理
CGLib全称为Code Generation Library，是一个强大的高性能，高质量的代码生成类库，可以在运行期扩展Java类与实现Java接口，CGLib封装了asm，可以再运行期动态生成新的class。
和JDK动态代理相比较：JDK创建代理有一个限制，就是只能为接口创建代理实例，而对于没有通过接口定义业务方法的类，则可以通过CGLib创建动态代理。
这是为什么jdk 会有两种方式生成代理对象，而这两者的切换是对开发者透明的，我们去翻看源码；

@Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

一目了然，可以看到其中的代理对象可以由JDK或者Cglib来生成的，JdkDynamicAopProxy类和Cglib2AopProxy都实现的是AopProxy的接口，上面的这些逻辑就是要判断采用两种动态代理中的那一种。我们又会问了
既然 CGLib 可以代理任何的类了，那为什么还要用 JDK 的动态代理呢？其实聪明的老罗也想到了，参考网上的观点：CGLib 创建代理的速度比较慢，但创建代理后运行的速度却非常快，而 JDK 动态代理正好相反。如果在运行的时候不断地用 CGLib 去创建代理，系统的性能会大打折扣。
目前我们解析了前面的 false、true、true、false。
这里写图片描述
借用网上的图片，图片展示了过程，我们到达代理对象前test2()，spring为我们开启事务，然后执行模板对象的test2()方法，此时我们内部有个test3()方法都认为是本地test2()的一部分。执行完之后关闭事务。所以总结来说如果持有代理对象已经到达目标对象，然后执行所有的事务方法都是本地方法，不会有事务起作用。
解决之法：
像test4() 这样，使用AopContext.currentProxy();相当于我们又回到了代理对象，使得事务重新起作用。
这里写图片描述
下面列举JdkDynamicAopProxy jdk方式生成代理对象时的源码：
在执行被调用方法的时候 invoke()

 public Object getProxy(ClassLoader classLoader) {
        if(logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }

        Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
        this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); //this 就是JdkDynamicAopProxy实现了InvocationHandler，所以invoke 会被调用。
    }
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 //代码片段    
       ......
            // 得到拦截器链
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // 检查是否定义了拦截器方法，如果没有的话直接调用目标方法

            if (chain.isEmpty()) {

                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
            }
            else {
                //我们需要创建一个调用方法
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // proceed内部实现了递归调用遍历拦截器链
                retVal = invocation.proceed();
            }
......

invocation.proceed(); //源码
@Override
    public Object proceed() throws Throwable {
        //  We start with an index of -1 and increment early.
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint(); //执行目标方法
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

//展示了执行完所有拦截器后执行目标方法。因此此时的test2()内部的test()都相当于内部方法了，不会在调用拦截器了
protected Object invokeJoinpoint() throws Throwable {
        return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
    }

目前我们已经解释了有些情况下事务失效的原因。事情spring AOP 对于我们来说封装的太好了，所以有些东西对我们很透明，但其实只有我们深入内部一定会发现出现问题的原因。

对于spring中的AspectJ 和 MethodInterceptor 和RegexpMethodPointcutAdvisor 为啥共存http://www.importnew.com/21811.html 这篇文章已经写得很清楚了，有兴趣的同学可以看看。

Rylan11
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Spring事务失效Spring事务失效
04-09
Spring事务失效Spring事务失效
java spring 事务失效的12种情况
myStyle的博客
10-11 1393
2. 方法用final修饰 3.方法内部调用 有时候我们需要在某个Service类的某个方法中，调用另外一个事务方法，比如： 在该Service类中注入自己； 在该Service类中注入自己也是一种选择。具体代码如下： 4.未被spring管理 没有添加 @Controller、@Service、@Component、@Repository等注解 5.多线程调用 两个方法不在同一个线程中，获取到的数据库连接不一样，从而是两个不同的事务 6.表不支持事务 数据库 存储引擎 不
Spring事务失效的场景有哪些
最新发布
刘皇叔说Java的博客
02-27 1337
如果在使用@Transactional注解声明事务时，有时想自定义回滚异常，spring也是支持的。可以通过设置rollbackFor参数，来完成这个功能。如下：@Service但是如果在程序执行过程中，出现了sql异常，但是sql异常并不属于我们定义的BusinessException异常，所以事务也不会回滚延伸：1 嵌套事务导致多回滚了怎么办？@Service@Autowired@Service如果说对于这样的代码。
spring事务失效的几种情况与原因
fanhongliang02的博客
08-21 260
本文列举了14种spring事务失效的场景，其实这14种里面有很多都是归根结底都是属于同一类问题引起，比如因为动态代理原因、方法限定符原因、异常类型原因等。
Spring事务失效十种原因
m0_64830897的博客
06-23 5746
本文详细的介绍了Spring事务失效的十种原因，掌握住它们并在工作避免这些情况。
Spring事务失效原因及解决方法
m0_68642284的博客
08-30 1327
spring 提供事务功能需要依赖于数据库的事务支持。而数据库层的事务提交和回滚是通过bin log 或者 redo log 实现的。大部分情况下我们使用基于 @Transactional 注解的声明式事务。声明式事务本质是通过 AOP 功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，在目标方法开始之前加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。对于Spring事务来说，在以下9种情况下会出现事务失效的情况。
Spring @Transactional注解失效解决方案
08-25
主要介绍了Spring @Transactional注解失效解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring事务失效
Aaron的博客
05-25 1770
spring事务失效
spring中事务失效的情况（常见的5种）
荣山的博客
06-25 2164
spring中事务失效的情况（常见的5种）
Spring 事务（Transactional）失效的七种原因及解决方案（含项目代码）
qq_45607784的博客
12-09 2789
Spring框架提供了强大的事务管理功能，能够确保数据库操作的一致性和可靠性。然而，有时候我们可能会遇到Spring事务失效的情况，导致数据不一致或操作失败。本文将探讨Spring事务失效的原因，以及如何避免和解决这些问题。通过深入了解失效原因，我们可以更好地利用Spring事务管理功能，确保系统的稳定性和可靠性。
Spring事务失效的几种原因
热门推荐
dhklsl的专栏
03-08 2万+
1、spring的事务注解@Transactional只能放在public修饰的方法上才起作用，如果放在其他非public（private，protected）方法上，虽然不报错，但是事务不起作用 2、如果采用spring+spring mvc，则context:component-scan重复扫描问题可能会引起事务失败。 如果spring和mvc的配置文件中都扫描了serv...
Spring事务失效问题分析及解决方案
08-25
主要介绍了Spring事务失效问题分析及解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring事务管理失效原因汇总
05-22
Spring声明式事务管理失效的原因，这里面是日常工作中踩过的坑，事务失效所产生的影响比较隐蔽，测试时易忽略，大多是在线上暴露，这可能是对Spring管理下的信任吧
Spring的事务10种常见失效场景总结.zip
02-17
Spring的事务10种常见失效场景总结.zip
spring事务总结.docx
10-09
事务失效、事务回滚、大事务问题、编程式事务
metrics 指标分析——你不在意的p99和p999
持之以恒
09-27 1万+
http://www.strolling.cn/category/metrics/ metrics 统计值。
ed exception is redis.clients.jedis.exceptions.JedisConnectionException: Unknown reply: O 异常处理记录
持之以恒
07-14 1万+
nested exception is redis.clients.jedis.exceptions.JedisConnectionException:
时间复杂度 O(1),O(n),O(n^2),O(logn),O(nlogn) 详解
持之以恒
03-17 1万+
在描述算法复杂度时,经常用到O(1), O(n),O(n^2), O(logn), O(nlogn)来表示对应算法的时间复杂度, 下面解释下他们的含义: 这是算法的时空复杂度的表示。不仅仅用于表示时间复杂度，也用于表示空间复杂度。 O后面的括号中有一个函数，指明某个算法的耗时/耗空间与数据增长量之间的关系。其中的n代表输入数据的量。 比如时间复杂度为O(n)，就代...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值