SpringBoot添加事务管理

在启动类上加入@EnableTransactionManagement

package com.yl.j2005.spc.emp.providerserver;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;

@SpringBootApplication
@EnableEurekaClient
@MapperScan(basePackages = "com.yl.j2005.spc.emp.providerserver.mapper")
@EnableTransactionManagement   //加入事务管理
public class SpcEmpProviderServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpcEmpProviderServerApplication.class, args);
    }

}

再所需加入事务的数据库管理操作上加入 @Transactional(propagation= Propagation.REQUIRED,isolation = Isolation.DEFAULT,rollbackFor=Exception.class)

---

propagation参数，Propagation类型（枚举），默认值为Propogation.REQUIRED，支持的值有REQUIRED、MANDATORY、NESTED、NEVER、NOT_SUPPORTED、REQUIRE_NEW、SUPPORTS。

//propagation值得是事务的传播性
//所谓事务传播性，就是被调用者的事务与调用者的事务之间的关系。举例说明。
//in A.java
Class A {
    @Transactional(propagation=propagation.REQUIRED)
    public void aMethod {
        B b = new B();
        b.bMethod();
    }
}
 
//in B.java
Class B {
    @Transactional(propagation=propagation.REQUIRED)
    public void bMethod { //something }
}

在上面这个例子中，传播性被设为了REQUIRED，注意，这是默认值，也即不进行该参数配置等于配置成REQUIRED。

　　REQUIRED的含义是，支持当前已经存在的事务，如果还没有事务，就创建一个新事务。在上面这个例子中，假设调用aMethod前不存在任何事务，那么执行aMethod时会自动开启一个事务，而由aMethod调用bMethod时，由于事务已经存在，因此会使用已经存在的事务（也就是执行aMethod之前创建的那个事务）。

　　对于这样的配置，如果bMethod过程中发生异常需要回滚，那么aMethod中所进行的所有数据库操作也将同时被回滚，因为这两个方法使用了同一个事务。

　　MANDATORY的含义是，支持当前已经存在的事务，如果还没有事务，就抛出一个异常。如果上例中aMethod的传播性配置为MANDATORY，我们就无法在没有事务的情况下调用aMethod，因此，传播性为MANDATORY的方法必定是一个其他事务的子事务，当逻辑上独立存在没有意义或者可能违反数据、事务完整性的时候，就可以考虑设置这样的传播性设置。

　　NESTED的含义是，在当前事务中创建一个嵌套事务，如果还没有事务，那么就简单地创建一个新事务。

　　REQUIRES_NEW的含义是，挂起当前事务，创建一个新事务，如果还没有事务，就简单地创建一个新事务。

　　请注意以上两者的区别，大多数情况下一上两种传播性行为是类似的，不过在事务回滚的问题上，以上两者有很大的区别。

　　首先，REQUIRES_NEW会创建一个与原事务无关的新事务，尽管是由一个事务调用了另一个事务，但却没有父子关系。

　　如果bMethod的传播性是REQUIRES_NEW，而抛出了一个异常，则bMethod一定会被回滚，而如果aMethod捕获并处理了这个bMethod抛出的异常，那么aMethod仍有可能成功提交。当然，如果aMethod没有处理这个异常，那么aMethod也会被回滚。

　　如果aMethod在bMethod完成后出现了异常，那么bMethod已经提交而无法回滚，只有aMethod被回滚了。

　　而对于NESTED，虽然也会创建一个新事务，但是这个事务与调用者是有父子关系的相互依存的。

　　如果bMethod的传播性是NESTED，而抛出了一个异常，事务的回滚行为与REQUIRES_NEW是一致的。

　　但是如果aMethod在bMethod完成后出现了异常，bMethod同样也会被回滚。因为事实上，EJB中没有对于NESTED传播性的类似实现，NESTED并不是真正启动了一个事务，而是开启了一个新的savepoint。

　　NEVER的含义很简单，就是强制要求不在事务中运行，如果当前存在一个事务，则抛出异常，因此如果bMethod传播性是NEVER，则一定抛出异常。

　　NOT_SUPPORTED的含义是，强制不在事务中运行，如果当前存在一个事务，则挂起该事务。

　　SUPPORTS的含义是，支持当前事务，如果没有事务那么就不在事务中运行。SUPPORTS传播性的逻辑含义比较模糊，因此一般是不推荐使用的。

isolation参数—事务的隔离级别，Isolation类型（枚举），默认值为Isolation.DEFAULT，支持的值有DEFAULT、READ_COMMITTED、READ_UNCOMMITTED、REPEATABLE_READ、SERIALIZABLE。

timeout参数，int类型，事务的超时时间，默认值为-1，即不会超时。
readOnly参数，boolean类型，true表示事务为只读，默认值为false。
rollbackFor参数，Class<? extends Throwable>[]类型，默认为空数组。如果配置了以后，抛出了指定异常或者其子类异常则回滚！

rollbackForClassName参数，String[]类型，默认为空数组。
noRollbackFor参数，Class<? extends Throwable>[]类型，默认为空数组。
noRollbackForClassName参数，String[]类型，默认为空数组。

我配置的事务

Controller层

@RequestMapping(value = "updateemp",method = RequestMethod.PUT)
    public ActionResult updateEmp(@RequestBody EmpQualification empQualification){
        System.out.println("empQualification = " + empQualification);
        try {
            boolean result=empService.updateEmp(empQualification);
            return new ActionResult(200,"update ok",null);
        }catch (Exception e){
            e.printStackTrace();
            log.error("添加失败，事务回滚");
        }return new ActionResult(201,"update false", null);

    }

Service层

 @Transactional(propagation= Propagation.REQUIRED,isolation = Isolation.DEFAULT,rollbackFor=Exception.class)
    @Override
    public boolean updateEmp(EmpQualification empQualification) {

        Integer i=empMapper.updateEmp(empQualification);
        if(i!=0){
            return true;
        }else{
            throw new RuntimeException("修改失败，事务回滚");
        }

    }

dao层

 Integer updateEmp(EmpQualification empQualification);

mapper语句

<update id="updateEmp" parameterType="com.yl.j2005.bean.sto.EmpQualification">
        update emp set em_name=#{emName},
        em_number=#{emNumber},
        em_age=#{emAge},
        em_sex=#{emSex},
        em_birthday=#{emBirthday},
        em_ethnic=#{emEthnic},
        em_tel=#{emTel},
        em_address=#{emAddress},
        em_workspace=#{emWorkspace},
        dept_id=#{deptId},
        group_id=123456 where em_id=#{emId};

        update qualification set em_biye=#{emBiye},em_congye=#{emCongye},em_shanggang#{emShanggang} where em_id=#{emId};
    </update>

这里要强调的是 如果一次执行多个语句，必须再数据库连接字符串url中添加如下配置

&allowMultiQueries=true
示例
spring.datasource.url=jdbc:mysql://192.168.0.109:3307/spcproject?allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false
//最后的&autoReconnect=true&failOverReadOnly=false是配置允许长时间未访问数据库的连接对象可访问，不会被数据库当成死链接