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

2023-08-18 15:24:40

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

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

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

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

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

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

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

　　具体代码如下：

 package com.example.demo;

 import org.springframework.boot.SpringApplication;

 import org.springframework.boot.autoconfigure.SpringBootApplication;

 import org.springframework.transaction.annotation.EnableTransactionManagement;

 // @SpringBootApplication是Sprnig Boot项目的核心注解，主要目的是开启自动配置

 @SpringBootApplication

 @EnableTransactionManagement // 启注解事务管理，等同于xml配置方式的 <tx:annotation-driven />

 public class DemoApplication {

     public static void main(String[] args) {

         SpringApplication.run(DemoApplication.class, args);

     }

 }

　　然后，注解@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();

}
 package com.example.demo.service;

 import com.example.demo.bean.ResPartner;

 import org.springframework.transaction.annotation.Transactional;

 import java.util.List;

 import java.util.Map;

 @Transactional

 public interface IPartnerService {

     int add(ResPartner resPartner);

     int deleteByIds(String ids);

     int update(ResPartner resPartner);

     ResPartner queryById(int id);

     List<ResPartner> queryList(Map<String, Object> params);

 }

　　实现类

 package com.example.demo.service.impl;

 import com.example.demo.bean.ResPartner;

 import com.example.demo.dao.PartnerMapperXml;

 import com.example.demo.service.IPartnerService;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

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

 import org.springframework.stereotype.Component;

 import java.util.List;

 import java.util.Map;

 @Component("partnerService")

 public class PartnerServiceImpl implements IPartnerService {

     private Logger logger = LoggerFactory.getLogger(this.getClass());

     @Autowired

     private PartnerMapperXml partnerMapperXml;

     @Override

     public int add(ResPartner resPartner) {

         StringBuilder sbStr = new StringBuilder();

         sbStr.append("id = ").append(resPartner.getId())

                 .append(", name = ").append(resPartner.getName())

                 .append(", city = ").append(resPartner.getCity())

                 .append(", displayName = ").append(resPartner.getDisplayName());

         this.logger.info(sbStr.toString());

         return this.partnerMapperXml.add(resPartner);

     }

 }
 package com.example.demo.service.impl;

 import com.example.demo.bean.ResPartner;

 import com.example.demo.bean.ResUser;

 import com.example.demo.dao.PartnerMapperXml;

 import com.example.demo.dao.ResUserMapper;

 import com.example.demo.service.IUserService;

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

 import org.springframework.stereotype.Component;

 import java.util.List;

 @Component("userService")

 public class UserServiceImpl implements IUserService {

     @Autowired

     private ResUserMapper resUserMapper;

     @Autowired

     private PartnerMapperXml partnerMapperXml;

     @Override

     public int insertUser(ResUser resUser) {

         int i = resUserMapper.insert(resUser);

 //        ResPartner partner = new ResPartner();

 //        partner.setId(resUser.getId());

 //        partner.setName(resUser.getName());

 //        partner.setDisplayName(resUser.getLogin());

 //

 //        if (true) // 用来验证异常，使事务回滚

 //            throw new RuntimeException("xxxxxxxxxxxxxxx");

 //        int a = 1/0;

 //        partnerMapperXml.add(partner);

         return i;

     }

 }

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

 package com.example.demo.controllers;

 import com.alibaba.fastjson.JSONObject;

 import com.example.demo.bean.JSONMsg;

 import com.example.demo.bean.ResPartner;

 import com.example.demo.bean.ResUser;

 import com.example.demo.service.IPartnerService;

 import com.example.demo.service.IUserService;

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

 import org.springframework.jdbc.datasource.DataSourceTransactionManager;

 import org.springframework.transaction.PlatformTransactionManager;

 import org.springframework.transaction.TransactionDefinition;

 import org.springframework.transaction.TransactionStatus;

 import org.springframework.web.bind.annotation.*;

 import java.util.List;

 @RestController

 @RequestMapping("/users")

 public class UserController {

     @Autowired

     private IUserService userService;

     @Autowired

     private IPartnerService partnerService;

     @Autowired

     private PlatformTransactionManager platformTransactionManager;

     @Autowired

     private TransactionDefinition transactionDefinition;

     @RequestMapping(value = "/insert", method = RequestMethod.POST)

     @ResponseBody

     public JSONMsg insertUser(@RequestBody String data){

         JSONMsg jsonMsg = new JSONMsg();

         jsonMsg.setCode(400);

         jsonMsg.setMsg("error");

         System.out.println(data);

         JSONObject jsonObject = JSONObject.parseObject(data);

         if (!jsonObject.containsKey("data")){

             return jsonMsg;

         }

         ResUser user = JSONObject.parseObject(jsonObject.get("data").toString(), ResUser.class);

         int i = userService.insertUser(user);

         System.out.println(i);

         if (i!=0){

             jsonMsg.setCode(200);

             jsonMsg.setMsg("成功");

             jsonMsg.setData(user);

         }

         return jsonMsg;

     }

 //    该方法中的代码用来验证手动控制事务时使用

 //    @RequestMapping(value = "/insert", method = RequestMethod.POST)

 //    @ResponseBody

 //    public JSONMsg insertUser(@RequestBody String data){

 //        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);

 //

 //        System.out.println(transactionStatus.isCompleted());

 //        System.out.println(transactionStatus.isRollbackOnly());

 //

 //

 //        JSONMsg jsonMsg = new JSONMsg();

 //        jsonMsg.setCode(400);

 //        jsonMsg.setMsg("error");

 //        System.out.println(data);

 //        try{

 //            JSONObject jsonObject = JSONObject.parseObject(data);

 //            if (!jsonObject.containsKey("data")){

 //                return jsonMsg;

 //            }

 //

 //            ResUser user = JSONObject.parseObject(jsonObject.get("data").toString(), ResUser.class);

 //            int i = userService.insertUser(user);

 //

 //            i= 1/0;

 //

 //            ResPartner partner = new ResPartner();

 //            partner.setId(user.getId());

 //            partner.setName(user.getName());

 //            partner.setDisplayName(user.getLogin());

 //            partnerService.add(partner);

 //

 //            if (i!=0){

 //                jsonMsg.setCode(200);

 //                jsonMsg.setMsg("成功");

 //                jsonMsg.setData(user);

 //            }

 //

 //            platformTransactionManager.commit(transactionStatus);

 //            System.out.println("提交事务");

 //        }catch (Exception e){

 //            e.printStackTrace();

 //            platformTransactionManager.rollback(transactionStatus);

 //            System.out.println("回滚事务");

 //        }finally {

 //

 //        }

 //        return jsonMsg;

 //    }

 }

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

 package com.example.demo.configs;

 import org.aspectj.lang.annotation.Aspect;

 import org.springframework.aop.Advisor;

 import org.springframework.aop.aspectj.AspectJExpressionPointcut;

 import org.springframework.aop.support.DefaultPointcutAdvisor;

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

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.transaction.PlatformTransactionManager;

 import org.springframework.transaction.TransactionDefinition;

 import org.springframework.transaction.interceptor.DefaultTransactionAttribute;

 import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;

 import org.springframework.transaction.interceptor.TransactionInterceptor;

 /**

  * @ClassName: GlobalTransactionAdviceConfig

  * @Description: AOP全局事务管理配置

  *

  * 声明式事务说明：

  *      1.如果将业务逻辑放到service层面来处理，则能够保证事务安全，即便使用了AOP来切入service方法也能保证事务安全；

  *      2.如果多个service在controller层做业务逻辑（本身就是错误的），则不能保证事务安全。

  * 对于2中的情况，应该尽量避免，因为本身就是错误的；

  * 这种情况在面向切面编程中也有可能碰到，如，因为必要切入点为controller（应尽量避免，原则应切service），切面程序跟controller业务逻辑不同，

  *   service不同，会导致事务混乱；

  *

  * 如果出现上述情况，则可以使用编程式事务管理（也就是手动控制事务）

  *      在controller逻辑开始之前手动开启/获取事务，然后在controller逻辑结束后再根据需要提交或者回滚事务；

  *      在AOP中也是如此，在before中手动开启/获取事务（这一步是必须的），在after中处理切面逻辑，然后根据需要提交或者回滚事务，如果由于异常需要回滚事务，记得修改返回信息

  *

  * @Author:

  * @Date: 2019-08-01

  * @Version: V2.0

  **/

 @Aspect

 @Configuration

 public class GlobalTransactionAdviceConfig {

     private static final String AOP_POINTCUT_EXPRESSION = "execution (* com.example.demo.service..*.*(..))";

     @Autowired

     private PlatformTransactionManager transactionManager;

     @Bean

     public TransactionInterceptor txAdvice() {

         DefaultTransactionAttribute txAttr_REQUIRED = new DefaultTransactionAttribute();

         txAttr_REQUIRED.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

         DefaultTransactionAttribute txAttr_REQUIRED_READONLY = new DefaultTransactionAttribute();

         txAttr_REQUIRED_READONLY.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

         txAttr_REQUIRED_READONLY.setReadOnly(true);

         NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();

         source.addTransactionalMethod("add*", txAttr_REQUIRED);

         source.addTransactionalMethod("insert*", txAttr_REQUIRED);

         source.addTransactionalMethod("save*", txAttr_REQUIRED);

         source.addTransactionalMethod("create*", txAttr_REQUIRED);

         source.addTransactionalMethod("delete*", txAttr_REQUIRED);

         source.addTransactionalMethod("update*", txAttr_REQUIRED);

         source.addTransactionalMethod("exec*", txAttr_REQUIRED);

         source.addTransactionalMethod("set*", txAttr_REQUIRED);

         source.addTransactionalMethod("get*", txAttr_REQUIRED_READONLY);

         source.addTransactionalMethod("query*", txAttr_REQUIRED_READONLY);

         source.addTransactionalMethod("find*", txAttr_REQUIRED_READONLY);

         source.addTransactionalMethod("list*", txAttr_REQUIRED_READONLY);

         source.addTransactionalMethod("count*", txAttr_REQUIRED_READONLY);

         source.addTransactionalMethod("is*", txAttr_REQUIRED_READONLY);

         source.addTransactionalMethod("select*", txAttr_REQUIRED_READONLY);

         return new TransactionInterceptor(transactionManager, source);

     }

     @Bean

     public Advisor txAdviceAdvisor() {

         AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();

         pointcut.setExpression(AOP_POINTCUT_EXPRESSION);

         return new DefaultPointcutAdvisor(pointcut, txAdvice());

     }

 }

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

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

　　

 package com.example.demo.configs;

 import com.example.demo.bean.JSONMsg;

 import com.example.demo.bean.ResPartner;

 import com.example.demo.bean.ResUser;

 import com.example.demo.service.IPartnerService;

 import org.aspectj.lang.JoinPoint;

 import org.aspectj.lang.annotation.AfterReturning;

 import org.aspectj.lang.annotation.Aspect;

 import org.aspectj.lang.annotation.Before;

 import org.aspectj.lang.annotation.Pointcut;

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

 import org.springframework.stereotype.Component;

 import org.springframework.transaction.PlatformTransactionManager;

 import org.springframework.transaction.TransactionDefinition;

 import org.springframework.transaction.TransactionStatus;

 import org.springframework.transaction.annotation.Transactional;

 @Component

 @Aspect

 public class ResUserAspect {

     @Autowired

     private IPartnerService partnerService;

     @Autowired

     private PlatformTransactionManager platformTransactionManager;

     @Autowired

     private TransactionDefinition transactionDefinition;

     private TransactionStatus transactionStatus;

     @Pointcut("execution(public * com.example.demo.controllers.UserController.insertUser(..))")

 //    @Pointcut("execution(public * com.example.demo.service.IUserService.insertUser(..))") // 验证切入点为service时，AOP编程中的事务问题

     private void insertUser(){}

     @Before(value = "insertUser()")

     public void before(){

         //在切入点程序执行之前手动开启事务 - 必须的操作

         transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);

     }

 　　　　// 验证切入点为service时，AOP编程中的事务问题

 //    @AfterReturning(pointcut = "insertUser()", returning = "result")

 //    public void afterReturning(JoinPoint joinPoint, Object result){

 //

 //        Object[] args = joinPoint.getArgs();

 //        System.out.println(args[0]);

 //        if (((Integer)result) != 0){

 //            ResPartner partner = new ResPartner();

 //            ResUser user = (ResUser) args[0];

 //            partner.setId(user.getId());

 //            partner.setName(user.getName());

 //            partner.setDisplayName(user.getLogin());

 //

 //            int a = 1/0;

 //            int i = partnerService.add(partner);

 //

 //            System.out.println(i);

 //        }

 //    }

 　　　//切入点为controller时的事务验证

     @Transactional

     @AfterReturning(pointcut = "insertUser()", returning = "result")

     public void afterReturning(JoinPoint joinPoint, Object result){

         if (!(result instanceof JSONMsg)){

             System.out.println(result.getClass());

             return;

         }

         JSONMsg jsonMsg = (JSONMsg) result;

         try{

             if (jsonMsg.getCode() == 200){

                 ResPartner partner = new ResPartner();

                 ResUser user = (ResUser) jsonMsg.getData();

                 partner.setId(user.getId());

                 partner.setName(user.getName());

                 partner.setDisplayName(user.getLogin());

                 int a = 1/0;

                 int i = partnerService.add(partner);

                 System.out.println(i);

             }

             platformTransactionManager.commit(transactionStatus);  // 手动提交事务

             System.out.println("提交事务");

         }catch (Exception e){

             platformTransactionManager.rollback(transactionStatus); // 出现异常，回滚事务

             System.out.println("回滚事务");

             System.out.println(e.getMessage());

             //修改返回数据

             jsonMsg.setCode(400);

             jsonMsg.setMsg(e.getMessage());

         }

     }

 }

　　用到的实体bean

 // ResUser.java中的属性

 private Integer id;

 private String login;

 private String name;

 private Integer age;

 // ResPartner.java中的属性

 private int id;

 private String name;

 private String city;

 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 同类方法调用）

　　

　　

　　

　　

上一篇：阿里云 EDAS-HSF 用户指南


下一篇：ubuntu中创建新用户并添加管理员权限