11-@Transaction与AOP冲突解决

本是古典何须时尚 2024-02-21 07:13 41阅读 0赞

如题，最近碰到了一个问题，在public方法上添加@Transaction没有生效，事务没有回滚。  
我自己模拟了一个功能，向数据库表User里面插入用户数据。说一下代码背景，  
数据库MySQL，持久化层Mybatis，项目使用SpringBoot。  
数据表User如下，已有一条数据：  
![table表：User][table_User]  
下面是代码

1.  Application启动类

package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import tk.mybatis.spring.annotation.MapperScan;
    
    @SpringBootApplication(scanBasePackages = {
        "com.example.demo","com.example.demo.dao"})
    //启动事务
    @EnableTransactionManagement
    //mapper接口扫描
    @MapperScan("com.example.demo.dao")
    @RestController
    public class DemoApplication {
        
    
    	@GetMapping("/")
    	String home() {
        
    		return "Spring is here!";
    	}
    
    	public static void main(String[] args) {
        
    		SpringApplication.run(DemoApplication.class, args);
    	}
    }

1.  实体类User，对应数据表user表

@Data
    @Table(name = "`user`")
    public class User {
        
        @Id
        @Column(name = "`id`")
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private int id;
        @Column(name = "`name`")
        private String name;
        @Column(name = "`created_time`")
        private Date createdTime;
    }

1.  Mapper类

package com.example.demo.dao;
    
    import com.example.demo.domain.po.User;
    import org.springframework.stereotype.Repository;
    import tk.mybatis.mapper.common.Mapper;
    import tk.mybatis.mapper.common.MySqlMapper;
    
    /**
     * TOrderMapper
     *
     * @author zhouxy@133.cn
     * @date 2022/8/15
     **/
    @Repository
    public interface UserMapper extends Mapper<User>, MySqlMapper<User> {
        
    }

1.  Service接口，处理业务逻辑，添加@Transaction

package com.example.demo.service;
    
    import com.example.demo.domain.po.User;
    import org.springframework.stereotype.Service;
    
    /**
     * @Description: TODO
     * @Author: zhouxy
     * @CreateTime: 2023-10-17
     */
    public interface IUserService {
        
        Integer addUser(User user);
    }

1.  service实现类

package com.example.demo.service.impl;
    
    import com.example.demo.dao.UserMapper;
    import com.example.demo.domain.po.User;
    import com.example.demo.service.IUserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    /**
     * @Description: TODO
     * @Author: zhouxy
     * @CreateTime: 2023-10-17
     */
    @Service
    public class UserService implements IUserService {
        
        @Autowired
        private UserMapper userMapper;
    
        @Override
        @Transactional
        public Integer addUser(User user) {
        
            Integer result = userMapper.insertSelective(user);
        }
    }

1.  AOP类

package com.example.demo.aop;
    
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    /**
     * @Description: TODO
     * @Author: zhouxy
     * @CreateTime: 2023-05-17
     */
    @Aspect
    @Component
    @Slf4j
    public class LogAop {
        
        @Pointcut(value = "execution(* com.example.demo.service.*.*(..))")
        public void controller() {
        
            log.info("223432");
        }
    
        @Around("controller()")
        public Object around(ProceedingJoinPoint joinPoint) {
        
            log.info("before================");
            try {
        
                Object res = joinPoint.proceed();
                return res;
            } catch (Throwable throwable) {
        
                log.error("", throwable);
            }finally {
        
                log.info("after================");
            }
            return null;
        }
    }

1.  测试类

import com.example.demo.DemoApplication;
    import com.example.demo.dao.UserMapper;
    import com.example.demo.domain.po.User;
    import com.example.demo.service.IUserService;
    import lombok.extern.slf4j.Slf4j;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    /**
     * MybatisTest
     *
     * @author zhouxy@133.cn
     * @date 2021/7/20
     **/
    @Slf4j
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = DemoApplication.class)
    public class MybatisTest {
        
        @Autowired
        private IUserService userService;
    
        @Test
        public void test() {
        
            User user = new User();
            user.setName("LISI222");
            userService.addUser(user);
        }
    }

当正常执行的时候，会在数据库中插入数据。  
![table表：User][table_User]

打印日志：  
![在这里插入图片描述][368998dc01264da08f96f7ddde954148.png]

此时在实现类中加入一行异常，看一下出现异常之后，事务是否会回滚，数据能否成功插入到数据表中。

我们看执行完之后，数据库的变化，我刚才插入的是用户：LISI222  
![在这里插入图片描述][9887d632416849aa85f2060ef190adf1.png]

显示的是插入成功，看后台日志显示，事务并没有做回滚操作，说明当前事务并没有捕获到异常信息。仔细分析日志头尾可知，日志打印操作包裹了service实现类的addUser方法，应该是aop操作在@Transaction之前执行，导致异常被aop处理了，aop最终也没有抛出异常，所以@Transaction方法没有捕获到异常信息。

2023-11-24 10:53:24.418  INFO [,,,] 29600 --- [           main] com.example.demo.aop.LogAop              : before================
    Creating a new SqlSession
    Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6c3884f5]
    JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5542418c] will be managed by Spring
    ==>  Preparing: INSERT INTO `user` ( `id`,`name` ) VALUES( ?,? )
    ==> Parameters: 0(Integer), LISI222(String)
    <==    Updates: 1
    ==>  Executing: SELECT LAST_INSERT_ID()
    <==    Columns: LAST_INSERT_ID()
    <==        Row: 11
    <==      Total: 1
    Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6c3884f5]
    2023-11-24 10:53:24.566 ERROR [,,,] 29600 --- [           main] com.example.demo.aop.LogAop              : 
    
    java.lang.RuntimeException: null
    	at com.example.demo.service.impl.UserService.addUser(UserService.java:24) ~[classes/:na]
    	at com.example.demo.service.impl.UserService$$FastClassBySpringCGLIB$$9c38b50f.invoke(<generated>) ~[classes/:na]
    	····异常信息打印，忽略
    
    2023-11-24 10:53:24.566  INFO [,,,] 29600 --- [           main] com.example.demo.aop.LogAop              : after================
    这里仍然正常提交事务，说明没有捕获到异常信息
    Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6c3884f5]
    Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6c3884f5]
    Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6c3884f5]

现在是因为aop中没有将异常抛出，做了友好化处理，将异常处理成了返回了错误码。所以需要在aop处理返回结果之前，事务就要捕获到当前事务中抛出的异常并进行回滚或者不提交事务。  
我在网上查找资料的时候查找到@Order注解，@Order的作用是定义Spring IOC容器中Bean的执行顺序的优先级（这里的顺序也可以理解为存放到容器中的先后顺序），所以我给LogAop类加了一个@Order注解，让LogAOP在最后执行，这样@Transaction类就可以提前执行，捕获异常，回滚数据。@Order默认为最低优先级，因此可以直接设置@Order即可

@Aspect
    @Component
    @Slf4j
    @Order(10) //定义LogAOP的顺序最后执行,值越高，优先级越低
    public class LogAop {
        
    ·····
    }

这次再执行一遍，查看是否成功回滚事务。  
![在这里插入图片描述][dd07e43b8d734e0798da421d09dc2a18.png]  
再看下日志，事务在aop之前执行完成。

2023-11-24 10:59:04.879  INFO [,,,] 28412 --- [           main] com.example.demo.aop.LogAop              : before================
    Creating a new SqlSession
    Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@786e2c5e]
    JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@78854721] will be managed by Spring
    ==>  Preparing: INSERT INTO `user` ( `id`,`name` ) VALUES( ?,? )
    ==> Parameters: 0(Integer), LISI333(String)
    <==    Updates: 1
    ==>  Executing: SELECT LAST_INSERT_ID()
    <==    Columns: LAST_INSERT_ID()
    <==        Row: 12
    <==      Total: 1
    Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@786e2c5e]
    Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@786e2c5e]
    这里关闭了事务，并且没有提交操作。
    Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@786e2c5e]
    2023-11-24 10:59:05.271 ERROR [,,,] 28412 --- [           main] com.example.demo.aop.LogAop              : 
    
    java.lang.RuntimeException: null
    	at com.example.demo.service.impl.UserService.addUser(UserService.java:24) ~[classes/:na]
    	at com.example.demo.service.impl.UserService$$FastClassBySpringCGLIB$$9c38b50f.invoke(<generated>) ~[classes/:na]
    2023-11-24 10:59:05.272  INFO [,,,] 28412 --- [           main] com.example.demo.aop.LogAop              : after================

使用@Order注解可以调整运行级别，但是需注意一个问题，aop中不要做一些业务操作，因为transaction不会捕获到aop中抛出的异常。可以使用try…catch捕获aop中的数据库操作，并进行回滚。

[table_User]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/57adf6201df940a683dc06446b457219.png
[368998dc01264da08f96f7ddde954148.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/ced0125289f147c0a61a8bb089409bc7.png
[9887d632416849aa85f2060ef190adf1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/802da08505d64cb2a9cc2ff6436044ed.png
[dd07e43b8d734e0798da421d09dc2a18.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/bd6ba78f697c45a989f04841893f8c26.png