Spring基于注解的AOP配置中的事务控制

Spring基于注解的AOP配置中的事务控制

        在Spring基于注解的AOP事务控制配置中，使用四个通知（前置、后置、异常、最终）进行事务控制是出现以下异常：

         事务控制代码如下：

package com.charmless.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.SQLException;

/**
 * 事务管理类：开启事务、提交事务、回滚事务、释放连接
 */
@Component("txManager")
@Aspect
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    @Pointcut("execution(* com.charmless.service.impl.*.*(..))")
    private void pt(){}


    /**
     *  开启事务
     */
    @Before("pt()")
    public void beginTransaction(){
        try {
            connectionUtils.getCurrentConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     *  提交事务
     */
    @AfterReturning("pt()")
    public void commit(){
        try {
            connectionUtils.getCurrentConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     *  回滚事务
     */
    @AfterThrowing("pt()")
    public void rollback(){
        try {
            connectionUtils.getCurrentConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     *  释放连接
     */
    @After("pt()")
    public void release(){
        try {
            connectionUtils.getCurrentConnection().close();
            connectionUtils.removeConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

package com.charmless.utils;

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

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

@Component("connectionUtils")
public class ConnectionUtils {

    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();


    @Autowired
    private DataSource dataSource;


    public  Connection getCurrentConnection(){
        try {
            //1.先从ThreadLocal上获取连接
            Connection con = tl.get();
            //2.判断当前线程上是否有绑定连接
            if (con == null){
                //3.如果没有，获取新的连接
                con = dataSource.getConnection();
                //4.将当前连接与线程绑定
                tl.set(con);
            }
            //5.返回与当前线程绑定的连接
            return  con;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public void removeConnection(){
        //将连接对象与线程解绑
        tl.remove();
    }

}

       Can't call commit when autocommit=true。事务已开启自动提交时，不能手动提交事务。报错位置在提交事务。可是在提交事务之前，在前置通知已经通过代码connectionUtils.getCurrentConnection().setAutoCommit(false)关闭了事务的自动提交。此时有两种可能，要么前置通知没执行，要么后置通知和前置通知里的Connection对象不是同一个。其实第一种可能可以很容易排除，后置通知都执行了，前置通知不可能没有执行。那就只有最后一种可能了，通过打断点的方式发现，每次在执行切入点方法之后会先执行最终通知即释放连接，最后再执行后置通知。
      执行顺序是：前置通知->切入点方法->最终通知（或异常通知）->后置通知。这就导致了执行切入点方法之后与线程绑定的Connection对象被释放，同时与线程解绑。等到执行后置通知的时候会获取一个新的Connection对象，从而导致在后置通知中事务提交不了。通过查阅资料发现这其实是spring基于注解的AOP配置中事务控制的一个bug。在通过注解AOP进行事务控制时，spring对四个通知的调用顺序是前置通知->切入点方法->最终通知（或异常通知）->后置通知。而这样显然是无法实现事务控制的。

解决办法

①不使用注解，通过xml配置四个通知：

<aop:config>
        <!--配置通用切入点表达式-->
        <aop:pointcut id="pt" expression="execution(* com.charmless.service.impl.*.*(..))"></aop:pointcut>
        <aop:aspect id="txAdvice" ref="txManager">
            <!--配置前置通知：开启事务-->
            <aop:before method="beginTransaction" pointcut-ref="pt"></aop:before>
            <!--配置后置通知：提交事务-->
            <aop:after-returning method="commit" pointcut-ref="pt"></aop:after-returning>
            <!--配置异常通知：回滚事务-->
            <aop:after-throwing method="rollback" pointcut-ref="pt"></aop:after-throwing>
            <!--配置最终通知：释放连接-->
            <aop:after method="release" pointcut-ref="pt"></aop:after>
        </aop:aspect>
    </aop:config>

②使用注解，通过环绕通知的方式配置四个通知:
在TransactionManager类中取消四个通知的注解，同时在类中加入以下代码：

	 /**
     * 环绕通知
     * @param pjp
     * @return
     */
    @Around("pt()")
    public Object aroundAdvice(ProceedingJoinPoint pjp){
        Object returnValue = null;
        try {
            Object[] args = pjp.getArgs();
            this.beginTransaction();
            returnValue = pjp.proceed(args);
            this.commit();
            return returnValue;
        } catch (Throwable t) {
            this.rollback();
            throw new RuntimeException(t);
        }finally {
            this.release();
        }
    }