spring boot中的声明式事务管理及编程式事务管理

这几天在做一个功能，具体的情况是这样的：

　　项目中原有的几个功能模块中有数据上报的功能，现在需要在这几个功能模块的上报之后生成一条消息记录，然后入库，在写个接口供前台来拉取消息记录。

　　看到这个需求，首先想到的是使用AOP来实现了，然后，我去看了下现有功能模块中的代码，发现了问题，这些模块中的业务逻辑并没有放在service层来处理，直接在controller中处理了，controller中包含了两个甚至多个service处理，这样是不能保证事务安全的，既然这样，那么我们如何实现能保证事务安全呢。我想直接在controller中定义切入点，然后before中手动开启事务，在afterReturn之后根据需要来提交或者回滚事务。

　　然后趁着这个机会就查了下spring boot中的事务这块，就从最基础的说起。

　　1.spring boot中声明式事务的使用

　　想要在spring boot中使用声明式事务，有两种方式，一种是在各个service层中添加注解，还有一种是使用AOP配置全局的声明式事务管理

　　先来说第一种，需要用到两个注解就，一个是@EnableTransactionManagement用来开启注解事务管理，等同于xml配置方式的 <tx:annotation-driven />，另一个是@Transactional

　　具体代码如下：

 1 package com.example.demo;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 import org.springframework.transaction.annotation.EnableTransactionManagement;
 6 
 7 // @SpringBootApplication是Sprnig Boot项目的核心注解，主要目的是开启自动配置
10 @SpringBootApplication
11 @EnableTransactionManagement // 启注解事务管理，等同于xml配置方式的 <tx:annotation-driven />
12 public class DemoApplication {
14     public static void main(String[] args) {
16         SpringApplication.run(DemoApplication.class, args);
18     }
19 
20 }

　　然后，注解@Transactional直接加在service层就可以了，放两个service用来验证事务是否按预期回滚

package com.example.demo.service;

import com.example.demo.bean.ResUser;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

/**
* 注解加在接口上表名接口的所有方法都支持事务；
* 如果加在方法上，则只有该方法支持事务
* 可以根据需要在CUD操作上加注解
**/
@Transactional 
public interface IUserService {

    int insertUser(ResUser resUser);

    int updateUser(ResUser resUser);

    List<ResUser> getResUserList();

}

 1 package com.example.demo.service;
 2 
 3 import com.example.demo.bean.ResPartner;
 4 import org.springframework.transaction.annotation.Transactional;
 5 
 6 import java.util.List;
 7 import java.util.Map;
 8 
 9 @Transactional
10 public interface IPartnerService {
11 
12     int add(ResPartner resPartner);
13 
14     int deleteByIds(String ids);
15 
16     int update(ResPartner resPartner);
17 
18     ResPartner queryById(int id);
19 
20     List<ResPartner> queryList(Map<String, Object> params);
21 
22 }

　　实现类

 1 package com.example.demo.service.impl;
 2 
 3 import com.example.demo.bean.ResPartner;
 4 import com.example.demo.dao.PartnerMapperXml;
 5 import com.example.demo.service.IPartnerService;
 6 import org.slf4j.Logger;
 7 import org.slf4j.LoggerFactory;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.stereotype.Component;
10 
11 import java.util.List;
12 import java.util.Map;
13 
14 @Component("partnerService")
15 public class PartnerServiceImpl implements IPartnerService {
16 
17     private Logger logger = LoggerFactory.getLogger(this.getClass());
18     @Autowired
19     private PartnerMapperXml partnerMapperXml;
20 
21     @Override
22     public int add(ResPartner resPartner) {
23         StringBuilder sbStr = new StringBuilder();
24         sbStr.append("id = ").append(resPartner.getId())
25                 .append(", name = ").append(resPartner.getName())
26                 .append(", city = ").append(resPartner.getCity())
27                 .append(", displayName = ").append(resPartner.getDisplayName());
28         this.logger.info(sbStr.toString());
29         return this.partnerMapperXml.add(resPartner);
30     }
31 }

 1 package com.example.demo.service.impl;
 2 
 3 import com.example.demo.bean.ResPartner;
 4 import com.example.demo.bean.ResUser;
 5 import com.example.demo.dao.PartnerMapperXml;
 6 import com.example.demo.dao.ResUserMapper;
 7 import com.example.demo.service.IUserService;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.stereotype.Component;
10 
11 import java.util.List;
12 
13 @Component("userService")
14 public class UserServiceImpl implements IUserService {
15 
16     @Autowired
17     private ResUserMapper resUserMapper;
18     @Autowired
19     private PartnerMapperXml partnerMapperXml;
20 
21     @Override
22     public int insertUser(ResUser resUser) {
23 
24         int i = resUserMapper.insert(resUser);
25 //        ResPartner partner = new ResPartner();
26 //        partner.setId(resUser.getId());
27 //        partner.setName(resUser.getName());
28 //        partner.setDisplayName(resUser.getLogin());
29 //
30 //        if (true) // 用来验证异常，使事务回滚
31 //            throw new RuntimeException("xxxxxxxxxxxxxxx");
32 //        int a = 1/0;
33 //        partnerMapperXml.add(partner);
34 
35         return i;
36     }
37 
38 }

　　controller代码，JSONMsg是一个自定义类，就三个属性code,msg,data用来给前台返回数据。

  1 package com.example.demo.controllers;
  2 
  3 import com.alibaba.fastjson.JSONObject;
  4 import com.example.demo.bean.JSONMsg;
  5 import com.example.demo.bean.ResPartner;
  6 import com.example.demo.bean.ResUser;
  7 import com.example.demo.service.IPartnerService;
  8 import com.example.demo.service.IUserService;
  9 import org.springframework.beans.factory.annotation.Autowired;
 10 import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 11 import org.springframework.transaction.PlatformTransactionManager;
 12 import org.springframework.transaction.TransactionDefinition;
 13 import org.springframework.transaction.TransactionStatus;
 14 import org.springframework.web.bind.annotation.*;
 15 
 16 import java.util.List;
 17 
 18 @RestController
 19 @RequestMapping("/users")
 20 public class UserController {
 21 
 22     @Autowired
 23     private IUserService userService;
 24     @Autowired
 25     private IPartnerService partnerService;
 26     @Autowired
 27     private PlatformTransactionManager platformTransactionManager;
 28     @Autowired
 29     private TransactionDefinition transactionDefinition;
 30 
 31     @RequestMapping(value = "/insert", method = RequestMethod.POST)
 32     @ResponseBody
 33     public JSONMsg insertUser(@RequestBody String data){
 34 
 35         JSONMsg jsonMsg = new JSONMsg();
 36         jsonMsg.setCode(400);
 37         jsonMsg.setMsg("error");
 38         System.out.println(data);
 39         JSONObject jsonObject = JSONObject.parseObject(data);
 40         if (!jsonObject.containsKey("data")){
 41             return jsonMsg;
 42         }
 43 
 44         ResUser user = JSONObject.parseObject(jsonObject.get("data").toString(), ResUser.class);
 45         int i = userService.insertUser(user);
 46 
 47         System.out.println(i);
 48         if (i!=0){
 49             jsonMsg.setCode(200);
 50             jsonMsg.setMsg("成功");
 51             jsonMsg.setData(user);
 52         }
 53 
 54         return jsonMsg;
 55     }
 56 
 57 //    该方法中的代码用来验证手动控制事务时使用
 58 //    @RequestMapping(value = "/insert", method = RequestMethod.POST)
 59 //    @ResponseBody
 60 //    public JSONMsg insertUser(@RequestBody String data){
 61 //        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
 62 //
 63 //        System.out.println(transactionStatus.isCompleted());
 64 //        System.out.println(transactionStatus.isRollbackOnly());
 65 //
 66 //
 67 //        JSONMsg jsonMsg = new JSONMsg();
 68 //        jsonMsg.setCode(400);
 69 //        jsonMsg.setMsg("error");
 70 //        System.out.println(data);
 71 //        try{
 72 //            JSONObject jsonObject = JSONObject.parseObject(data);
 73 //            if (!jsonObject.containsKey("data")){
 74 //                return jsonMsg;
 75 //            }
 76 //
 77 //            ResUser user = JSONObject.parseObject(jsonObject.get("data").toString(), ResUser.class);
 78 //            int i = userService.insertUser(user);
 79 //
 80 //            i= 1/0;
 81 //
 82 //            ResPartner partner = new ResPartner();
 83 //            partner.setId(user.getId());
 84 //            partner.setName(user.getName());
 85 //            partner.setDisplayName(user.getLogin());
 86 //            partnerService.add(partner);
 87 //
 88 //            if (i!=0){
 89 //                jsonMsg.setCode(200);
 90 //                jsonMsg.setMsg("成功");
 91 //                jsonMsg.setData(user);
 92 //            }
 93 //
 94 //            platformTransactionManager.commit(transactionStatus);
 95 //            System.out.println("提交事务");
 96 //        }catch (Exception e){
 97 //            e.printStackTrace();
 98 //            platformTransactionManager.rollback(transactionStatus);
 99 //            System.out.println("回滚事务");
100 //        }finally {
101 //
102 //        }
103 //        return jsonMsg;
104 //    }
105 }

　　接下来说下spring boot中配置全局的声明式事务，定义一个configure类，具体代码如下

 1 package com.example.demo.configs;
 2 
 3 import org.aspectj.lang.annotation.Aspect;
 4 import org.springframework.aop.Advisor;
 5 import org.springframework.aop.aspectj.AspectJExpressionPointcut;
 6 import org.springframework.aop.support.DefaultPointcutAdvisor;
 7 import org.springframework.beans.factory.annotation.Autowired;
 8 import org.springframework.context.annotation.Bean;
 9 import org.springframework.context.annotation.Configuration;
10 import org.springframework.transaction.PlatformTransactionManager;
11 import org.springframework.transaction.TransactionDefinition;
12 import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
13 import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;
14 import org.springframework.transaction.interceptor.TransactionInterceptor;
15 
16 /**
17  * @ClassName: GlobalTransactionAdviceConfig
18  * @Description: AOP全局事务管理配置
19  *
20  * 声明式事务说明：
21  *      1.如果将业务逻辑放到service层面来处理，则能够保证事务安全，即便使用了AOP来切入service方法也能保证事务安全；
22  *      2.如果多个service在controller层做业务逻辑（本身就是错误的），则不能保证事务安全。
23  * 对于2中的情况，应该尽量避免，因为本身就是错误的；
24  * 这种情况在面向切面编程中也有可能碰到，如，因为必要切入点为controller（应尽量避免，原则应切service），切面程序跟controller业务逻辑不同，
25  *   service不同，会导致事务混乱；
26  *
27  * 如果出现上述情况，则可以使用编程式事务管理（也就是手动控制事务）
28  *      在controller逻辑开始之前手动开启/获取事务，然后在controller逻辑结束后再根据需要提交或者回滚事务；
29  *      在AOP中也是如此，在before中手动开启/获取事务（这一步是必须的），在after中处理切面逻辑，然后根据需要提交或者回滚事务，如果由于异常需要回滚事务，记得修改返回信息
30  *
31  * @Author: 
32  * @Date: 2019-08-01
33  * @Version: V2.0
34  **/
35 
36 @Aspect
37 @Configuration
38 public class GlobalTransactionAdviceConfig {
39     private static final String AOP_POINTCUT_EXPRESSION = "execution (* com.example.demo.service..*.*(..))";
40 
41     @Autowired
42     private PlatformTransactionManager transactionManager;
43 
44     @Bean
45     public TransactionInterceptor txAdvice() {
46         DefaultTransactionAttribute txAttr_REQUIRED = new DefaultTransactionAttribute();
47         txAttr_REQUIRED.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
48 
49         DefaultTransactionAttribute txAttr_REQUIRED_READONLY = new DefaultTransactionAttribute();
50         txAttr_REQUIRED_READONLY.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
51         txAttr_REQUIRED_READONLY.setReadOnly(true);
52 
53         NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();
54         source.addTransactionalMethod("add*", txAttr_REQUIRED);
55         source.addTransactionalMethod("insert*", txAttr_REQUIRED);
56         source.addTransactionalMethod("save*", txAttr_REQUIRED);
57         source.addTransactionalMethod("create*", txAttr_REQUIRED);
58         source.addTransactionalMethod("delete*", txAttr_REQUIRED);
59         source.addTransactionalMethod("update*", txAttr_REQUIRED);
60         source.addTransactionalMethod("exec*", txAttr_REQUIRED);
61         source.addTransactionalMethod("set*", txAttr_REQUIRED);
62         source.addTransactionalMethod("get*", txAttr_REQUIRED_READONLY);
63         source.addTransactionalMethod("query*", txAttr_REQUIRED_READONLY);
64         source.addTransactionalMethod("find*", txAttr_REQUIRED_READONLY);
65         source.addTransactionalMethod("list*", txAttr_REQUIRED_READONLY);
66         source.addTransactionalMethod("count*", txAttr_REQUIRED_READONLY);
67         source.addTransactionalMethod("is*", txAttr_REQUIRED_READONLY);
68         source.addTransactionalMethod("select*", txAttr_REQUIRED_READONLY);
69         return new TransactionInterceptor(transactionManager, source);
70     }
71 
72     @Bean
73     public Advisor txAdviceAdvisor() {
74         AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
75         pointcut.setExpression(AOP_POINTCUT_EXPRESSION);
76         return new DefaultPointcutAdvisor(pointcut, txAdvice());
77     }
78 }

　　添加这个类，根据知己需要修改切入点，然后放到能被spring boot扫描到的包下即可，如果出现事务失败的情况，请查看下addTransactionalMethod是否配置正确，我当初就是用的insert*，而没有添加导致失败。

　　2.切入点为controller时，如何使用编程式事务管理控制事务

 1 package com.example.demo.configs;
 2 
 3 import com.example.demo.bean.JSONMsg;
 4 import com.example.demo.bean.ResPartner;
 5 import com.example.demo.bean.ResUser;
 6 import com.example.demo.service.IPartnerService;
 7 import org.aspectj.lang.JoinPoint;
 8 import org.aspectj.lang.annotation.AfterReturning;
 9 import org.aspectj.lang.annotation.Aspect;
10 import org.aspectj.lang.annotation.Before;
11 import org.aspectj.lang.annotation.Pointcut;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.stereotype.Component;
14 import org.springframework.transaction.PlatformTransactionManager;
15 import org.springframework.transaction.TransactionDefinition;
16 import org.springframework.transaction.TransactionStatus;
17 import org.springframework.transaction.annotation.Transactional;
18 
19 @Component
20 @Aspect
21 public class ResUserAspect {
22 
23     @Autowired
24     private IPartnerService partnerService;
25     @Autowired
26     private PlatformTransactionManager platformTransactionManager;
27     @Autowired
28     private TransactionDefinition transactionDefinition;
29 
30     private TransactionStatus transactionStatus;
31 
32     @Pointcut("execution(public * com.example.demo.controllers.UserController.insertUser(..))")
33 //    @Pointcut("execution(public * com.example.demo.service.IUserService.insertUser(..))") // 验证切入点为service时，AOP编程中的事务问题
34     private void insertUser(){}
35 
36     @Before(value = "insertUser()")
37     public void before(){
38         //在切入点程序执行之前手动开启事务 - 必须的操作
39         transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
40     }
41 　　　　// 验证切入点为service时，AOP编程中的事务问题
42 //    @AfterReturning(pointcut = "insertUser()", returning = "result") 
43 //    public void afterReturning(JoinPoint joinPoint, Object result){
44 //
45 //        Object[] args = joinPoint.getArgs();
46 //        System.out.println(args[0]);
47 //        if (((Integer)result) != 0){
48 //            ResPartner partner = new ResPartner();
49 //            ResUser user = (ResUser) args[0];
50 //            partner.setId(user.getId());
51 //            partner.setName(user.getName());
52 //            partner.setDisplayName(user.getLogin());
53 //
54 //            int a = 1/0;
55 //            int i = partnerService.add(partner);
56 //
57 //            System.out.println(i);
58 //        }
59 //    }
60 　　　//切入点为controller时的事务验证
61     @Transactional
62     @AfterReturning(pointcut = "insertUser()", returning = "result")
63     public void afterReturning(JoinPoint joinPoint, Object result){
64 
65         if (!(result instanceof JSONMsg)){
66             System.out.println(result.getClass());
67             return;
68         }
69         JSONMsg jsonMsg = (JSONMsg) result;
70         try{
71 
72             if (jsonMsg.getCode() == 200){
73                 ResPartner partner = new ResPartner();
74                 ResUser user = (ResUser) jsonMsg.getData();
75                 partner.setId(user.getId());
76                 partner.setName(user.getName());
77                 partner.setDisplayName(user.getLogin());
78 
79                 int a = 1/0;
80                 int i = partnerService.add(partner);
81 
82                 System.out.println(i);
83             }
84 
85             platformTransactionManager.commit(transactionStatus);  // 手动提交事务
86             System.out.println("提交事务");
87         }catch (Exception e){
88             platformTransactionManager.rollback(transactionStatus); // 出现异常，回滚事务
89             System.out.println("回滚事务");
90             System.out.println(e.getMessage());
91 
92             //修改返回数据
93             jsonMsg.setCode(400);
94             jsonMsg.setMsg(e.getMessage());
95         }
96 
97     }
98 }

　　用到的实体bean

 1 // ResUser.java中的属性
 2 private Integer id;
 3 private String login;
 4 private String name;
 5 private Integer age;
 6 
 7 // ResPartner.java中的属性
 8 private int id;
 9 private String name;
10 private String city;
11 private String displayName;

　　最后总结我写在了GlobalTransactionAdviceConfig 类中，也就是如下

* 声明式事务说明：
*      1.如果将业务逻辑放到service层面来处理，则能够保证事务安全，即便使用了AOP来切入service方法也能保证事务安全；
*      2.如果多个service在controller层做业务逻辑（本身就是错误的），则不能保证事务安全。
* 对于2中的情况，应该尽量避免；
* 这种情况在面向切面编程中也有可能碰到，如，因为必要切入点为controller（应尽量避免，原则应切service），切面程序跟controller业务逻辑不同，
*   service不同，会导致事务混乱；
*
* 如果出现上述情况，则可以使用编程式事务管理（也就是手动控制事务）
*      在controller逻辑开始之前手动开启/获取事务，然后在controller逻辑结束后再根据需要提交或者回滚事务；
*      在AOP中也是如此，在before中手动开启/获取事务（这一步是必须的），在after中处理切面逻辑，然后根据需要提交或者回滚事务，如果由于异常需要回滚事务，记得修改返回信息

　　注：

　　　　有时候项目中使用了分布式框架，比如dubbo，则可能存在service层跟controller层分布式部署的问题，这会导致这种方式在controller中获取不到transactionManager，后续有时间在来看下分布式中的事务处理问题。

参考链接：

　　Spring Boot 之事务（声明式、编程式、自定义事务管理器、@EnableAspectJAutoProxy 同类方法调用）