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

　　具体代码如下：

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