前言
本篇文章主要介紹的是SpringBoot的事物Transaction使用的教程。
SpringBoot Transaction
說明：如果想直接獲取工程那么可以直接跳到底部，通過鏈接下載工程代碼。
Transaction
事務管理方式
在Spring中，事務有兩種實現方式，分別是編程式事務管理和聲明式事務管理兩種方式。
- 編程式事務管理： 編程式事務管理使用TransactionTemplate或者直接使用底層的PlatformTransactionManager。對于編程式事務管理，spring推薦使用TransactionTemplate。
- 聲明式事務管理： 建立在AOP之上的。其本質是對方法前后進行攔截，然后在目標方法開始之前創建或者加入一個事務，在執行完目標方法之后根據執行情況提交或者回滾事務。
- 聲明式事務管理不需要入侵代碼，通過@Transactional就可以進行事務操作，更快捷而且簡單，推薦使用。
事務提交方式
默認情況下，數據庫處于自動提交模式。每一條語句處于一個單獨的事務中，在這條語句執行完畢時，如果執行成功則隱式的提交事務，如果執行失敗則隱式的回滾事務。
對于正常的事務管理，是一組相關的操作處于一個事務之中，因此必須關閉數據庫的自動提交模式。不過，這個我們不用擔心，spring會將底層連接的自動提交特性設置為false。也就是在使用spring進行事物管理的時候，spring會將是否自動提交設置為false，等價于JDBC中的 connection.setAutoCommit(false);，在執行完之后在進行提交，connection.commit(); 。
事務隔離級別
隔離級別是指若干個并發的事務之間的隔離程度。TransactionDefinition 接口中定義了五個表示隔離級別的常量：
- TransactionDefinition.ISOLATION_DEFAULT：這是默認值，表示使用底層數據庫的默認隔離級別。對大部分數據庫而言，通常這值就是TransactionDefinition.ISOLATION_READ_COMMITTED。
- TransactionDefinition.ISOLATION_READ_UNCOMMITTED：該隔離級別表示一個事務可以讀取另一個事務修改但還沒有提交的數據。該級別不能防止臟讀，不可重復讀和幻讀，因此很少使用該隔離級別。比如PostgreSQL實際上并沒有此級別。
- TransactionDefinition.ISOLATION_READ_COMMITTED：該隔離級別表示一個事務只能讀取另一個事務已經提交的數據。該級別可以防止臟讀，這也是大多數情況下的推薦值。
- TransactionDefinition.ISOLATION_REPEATABLE_READ：該隔離級別表示一個事務在整個過程中可以多次重復執行某個查詢，并且每次返回的記錄都相同。該級別可以防止臟讀和不可重復讀。
- TransactionDefinition.ISOLATION_SERIALIZABLE：所有的事務依次逐個執行，這樣事務之間就完全不可能產生干擾，也就是說，該級別可以防止臟讀、不可重復讀以及幻讀。但是這將嚴重影響程序的性能。通常情況下也不會用到該級別。
事務傳播行為
所謂事務的傳播行為是指，如果在開始當前事務之前，一個事務上下文已經存在，此時有若干選項可以指定一個事務性方法的執行行為。在TransactionDefinition定義中包括了如下幾個表示傳播行為的常量：
- TransactionDefinition.PROPAGATION_REQUIRED：如果當前存在事務，則加入該事務；如果當前沒有事務，則創建一個新的事務。這是默認值。
- TransactionDefinition.PROPAGATION_REQUIRES_NEW：創建一個新的事務，如果當前存在事務，則把當前事務掛起。
- TransactionDefinition.PROPAGATION_SUPPORTS：如果當前存在事務，則加入該事務；如果當前沒有事務，則以非事務的方式繼續運行。
- TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事務方式運行，如果當前存在事務，則把當前事務掛起。
- TransactionDefinition.PROPAGATION_NEVER：以非事務方式運行，如果當前存在事務，則拋出異常。
- TransactionDefinition.PROPAGATION_MANDATORY：如果當前存在事務，則加入該事務；如果當前沒有事務，則拋出異常。
- TransactionDefinition.PROPAGATION_NESTED：如果當前存在事務，則創建一個事務作為當前事務的嵌套事務來運行；如果當前沒有事務，則該取值等價于TransactionDefinition.PROPAGATION_REQUIRED。
事務回滾規則
指示spring事務管理器回滾一個事務的推薦方法是在當前事務的上下文內拋出異常。spring事務管理器會捕捉任何未處理的異常，然后依據規則決定是否回滾拋出異常的事務。
默認配置下，spring只有在拋出的異常為運行時unchecked異常時才回滾該事務，也就是拋出的異常為RuntimeException的子類(Errors也會導致事務回滾)，而拋出checked異常則不會導致事務回滾。
可以明確的配置在拋出那些異常時回滾事務，包括checked異常。也可以明確定義那些異常拋出時不回滾事務。
事務常用配置
- readOnly：該屬性用于設置當前事務是否為只讀事務，設置為true表示只讀，false則表示可讀寫，默認值為false。例如：@Transactional(readOnly=true)；
- rollbackFor： 該屬性用于設置需要進行回滾的異常類數組，當方法中拋出指定異常數組中的異常時，則進行事務回滾。例如：指定單一異常類：@Transactional(rollbackFor=RuntimeException.class)指定多個異常類：@Transactional(rollbackFor={RuntimeException.class, Exception.class})；
- rollbackForClassName： 該屬性用于設置需要進行回滾的異常類名稱數組，當方法中拋出指定異常名稱數組中的異常時，則進行事務回滾。例如：指定單一異常類名稱@Transactional(rollbackForClassName=”RuntimeException”)指定多個異常類名稱：@Transactional(rollbackForClassName={“RuntimeException”,”Exception”})。
- noRollbackFor：該屬性用于設置不需要進行回滾的異常類數組，當方法中拋出指定異常數組中的異常時，不進行事務回滾。例如：指定單一異常類：@Transactional(noRollbackFor=RuntimeException.class)指定多個異常類：@Transactional(noRollbackFor={RuntimeException.class, Exception.class})。
- noRollbackForClassName：該屬性用于設置不需要進行回滾的異常類名稱數組，當方法中拋出指定異常名稱數組中的異常時，不進行事務回滾。例如：指定單一異常類名稱：@Transactional(noRollbackForClassName=”RuntimeException”)指定多個異常類名稱：@Transactional(noRollbackForClassName={“RuntimeException”,”Exception”})。
- propagation ： 該屬性用于設置事務的傳播行為。例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)。
- isolation：該屬性用于設置底層數據庫的事務隔離級別，事務隔離級別用于處理多事務并發的情況，通常使用數據庫的默認隔離級別即可，基本不需要進行設置。
- timeout：該屬性用于設置事務的超時秒數，默認值為-1表示永不超時。
事物注意事項
- 要根據實際的需求來決定是否要使用事物，最好是在編碼之前就考慮好，不然到以后就難以維護；
- 如果使用了事物，請務必進行事物測試，因為很多情況下以為事物是生效的，但是實際上可能未生效！
- 事物@Transactional的使用要放再類的公共(public)方法中，需要注意的是在 protected、private 方法上使用 @Transactional 注解，它也不會報錯(IDEA會有提示)，但事務無效。
- 事物@Transactional是不會對該方法里面的子方法生效！也就是你在公共方法A聲明的事物@Transactional，但是在A方法中有個子方法B和C，其中方法B進行了數據操作，但是該異常被B自己處理了，這樣的話事物是不會生效的！反之B方法聲明的事物@Transactional，但是公共方法A卻未聲明事物的話，也是不會生效的！如果想事物生效，需要將子方法的事務控制交給調用的方法，在子方法中使用rollbackFor注解指定需要回滾的異常或者將異常拋出交給調用的方法處理。一句話就是在使用事物的時候子方法最好將異常拋出！
- 事物@Transactional由spring控制的時候，它會在拋出異常的時候進行回滾。如果自己使用catch捕獲了處理了，是不生效的，如果想生效可以進行手動回滾或者在catch里面將異常拋出，比如throw new RuntimeException();。
開發準備
環境要求
JDK：1.8
SpringBoot：1.5.17.RELEASE
首先還是Maven的相關依賴:
pom.xml文件如下:
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <JAVA.version>1.8</java.version> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.17.RELEASE</version> <relativePath /> </parent> <dependencies> <!-- Spring Boot Web 依賴 核心 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring Boot Test 依賴 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.2.0</version> </dependency> <!-- MySQL 連接驅動依賴 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.44</version> </dependency> <!-- Druid 數據連接池依賴 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.8</version> </dependency> </dependencies>
Application.properties的文件的配置:
banner.charset=UTF-8 server.Tomcat.uri-encoding=UTF-8 spring.http.encoding.charset=UTF-8 spring.http.encoding.enabled=true spring.http.encoding.force=true spring.messages.encoding=UTF-8 spring.application.name=springboot-transactional server.port=8182 spring.datasource.url=jdbc:mysql://localhost:3306/springBoot?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driverClassName=com.mysql.jdbc.Driver spring.datasource.type=com.alibaba.druid.pool.DruidDataSource spring.datasource.initialSize=5 spring.datasource.minIdle=5 spring.datasource.maxActive=20 spring.datasource.maxWait=60000 spring.datasource.timeBetweenEvictionRunsMillis=60000 spring.datasource.minEvictableIdleTimeMillis=300000 spring.datasource.validationQuery=SELECT 1 FROM DUAL spring.datasource.testWhileIdle=true spring.datasource.testOnBorrow=false spring.datasource.testOnReturn=false spring.datasource.poolPreparedStatements=true spring.datasource.maxPoolPreparedStatementPerConnectionSize=20 spring.datasource.filters=stat,wall,log4j spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 logging.level.com.pancm.dao=debug
代碼編寫
SpringBoot在使用事物Transactional的時候，要在main方法上加上 @EnableTransactionManagement 注解開發事物聲明，在使用的service層的公共方法加上 @Transactional (spring)注解。
使用示例一
那么首先我們來看下 @Transactional 這個注解的使用方法吧，只需要你在需要添加公共方法上面添加該注解即可。但是這么使用的話需要你將異常拋出，由spring進行去控制。
代碼示例:
@Transactional
public boolean test1(User user) throws Exception {
long id = user.getId();
System.out.println("查詢的數據1:" + udao.findById(id));
// 新增兩次，會出現主鍵ID沖突，看是否可以回滾該條數據
udao.insert(user);
System.out.println("查詢的數據2:" + udao.findById(id));
udao.insert(user);
return false;
}
使用示例二
如果我們在使用事物 @Transactional 的時候，想自己對異常進行處理的話，那么我們可以進行手動回滾事物。在catch中加上 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); 方法進行手動回滾。不過需要注意的是發生異常需要第一時間進行手動回滾事物，也就是要在異常拋出之前！
代碼示例:
@Transactional
public boolean test2(User user) {
long id = user.getId();
try {
System.out.println("查詢的數據1:" + udao.findById(id));
// 新增兩次，會出現主鍵ID沖突，看是否可以回滾該條數據
udao.insert(user);
System.out.println("查詢的數據2:" + udao.findById(id));
udao.insert(user);
} catch (Exception e) {
System.out.println("發生異常,進行手動回滾！");
// 手動回滾事物
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
e.printStackTrace();
}
return false;
}
使用示例三
如果我們在使用事物 @Transactional 的時候，調用了其他的子方法進行了數據庫的操作，但是我們想使其事物生效的話，我們可以使用rollbackFor注解或者將該子方法的異常拋出由調用的方法進行處理，不過這里需要注意的是，子方法也必須是公共的方法！
代碼示例:
@Transactional
public boolean test3(User user) {
/*
* 子方法出現異常進行回滾
*/
try {
System.out.println("查詢的數據1:" + udao.findById(user.getId()));
deal1(user);
deal2(user);
deal3(user);
} catch (Exception e) {
System.out.println("發生異常,進行手動回滾！");
// 手動回滾事物
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
e.printStackTrace();
}
return false;
}
public void deal1(User user) throws SQLException {
udao.insert(user);
System.out.println("查詢的數據2:" + udao.findById(user.getId()));
}
public void deal2(User user) throws SQLException{
if(user.getAge()<20){
//SQL異常
udao.insert(user);
}else{
user.setAge(21);
udao.update(user);
System.out.println("查詢的數據3:" + udao.findById(user.getId()));
}
}
@Transactional(rollbackFor = SQLException.class)
public void deal3(User user) {
if(user.getAge()>20){
//SQL異常
udao.insert(user);
}
}
使用示例四
如果我們不想使用事物 @Transactional 注解，想自己進行事物控制(編程事物管理)，控制某一段的代碼事物生效，但是又不想自己去編寫那么多的代碼，那么可以使用springboot中的DataSourceTransactionManager和TransactionDefinition這兩個類來結合使用，能夠達到手動控制事物的提交回滾。不過在進行使用的時候，需要注意在回滾的時候，要確保開啟了事物但是未提交，如果未開啟或已提交的時候進行回滾是會在catch里面發生異常的！
代碼示例:
@Autowired
private DataSourceTransactionManager dataSourceTransactionManager;
@Autowired
private TransactionDefinition transactionDefinition;
public boolean test4(User user) {
/*
* 手動進行事物控制
*/
TransactionStatus transactionStatus=null;
boolean isCommit = false;
try {
transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
System.out.println("查詢的數據1:" + udao.findById(user.getId()));
// 進行新增/修改
udao.insert(user);
System.out.println("查詢的數據2:" + udao.findById(user.getId()));
if(user.getAge()<20) {
user.setAge(user.getAge()+2);
udao.update(user);
System.out.println("查詢的數據3:" + udao.findById(user.getId()));
}else {
throw new Exception("模擬一個異常!");
}
//手動提交
dataSourceTransactionManager.commit(transactionStatus);
isCommit= true;
System.out.println("手動提交事物成功!");
throw new Exception("模擬第二個異常!");
} catch (Exception e) {
//如果未提交就進行回滾
if(!isCommit){
System.out.println("發生異常,進行手動回滾！");
//手動回滾事物
dataSourceTransactionManager.rollback(transactionStatus);
}
e.printStackTrace();
}
return false;
}
上述的這幾種示例是比較常見使用的，基本可以滿足日常我們對事物的使用，spring里面還有一種事物的控制方法，就是設置斷點進行回滾。但是這種方法個人還沒實際驗證過，可靠性待確認。
使用方法如下:
Object savePoint =null;
try{
//設置回滾點
savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
}catch(Exception e){
//出現異常回滾到savePoint。
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
}
上面的使用示例介紹完畢之后，我們再來介紹一下幾個主要的類。
首先還是實體類:
實體類
又是萬能的用戶表
public class User {
private Long id;
private String name;
private Integer age;
//getter 和 setter 略
}
Controller 控制層
然后便是控制層，控制層這塊的我做了下最后的查詢，用于校驗事物是否成功生效！
控制層代碼如下:
@RestController
@RequestMapping(value = "/api/user")
public class UserRestController {
@Autowired
private UserService userService;
@Autowired
private UserDao userDao;
@PostMapping("/test1")
public boolean test1(@RequestBody User user) {
System.out.println("請求參數:" + user);
try {
userService.test1(user);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("最后查詢的數據:" + userDao.findById(user.getId()));
return true;
}
@PostMapping("/test2")
public boolean test2(@RequestBody User user) {
System.out.println("請求參數:" + user);
userService.test2(user);
System.out.println("最后查詢的數據:" + userDao.findById(user.getId()));
return true;
}
@PostMapping("/test3")
public boolean test3(@RequestBody User user) {
System.out.println("請求參數:" + user);
userService.test3(user);
System.out.println("最后查詢的數據:" + userDao.findById(user.getId()));
return true;
}
@PostMapping("/test4")
public boolean test4(@RequestBody User user) {
System.out.println("請求參數:" + user);
userService.test4(user);
System.out.println("最后查詢的數據:" + userDao.findById(user.getId()));
return true;
}
}
App 入口
和普通的SpringBoot項目基本一樣，只不過需要加上 @EnableTransactionManagement 注解！
代碼如下:
@EnableTransactionManagement
@SpringBootApplication
public class TransactionalApp
{
public static void main( String[] args )
{
SpringApplication.run(TransactionalApp.class, args);
System.out.println("Transactional 程序正在運行...");
}
}
功能測試
我們在啟動程序之后，來進行上述的幾個示例測試，這里的測試示例分別對應上述的使用示例，有的示例需要測試兩邊以上才能驗證事物是否能夠生效！這里我們使用Postman進行測試！
測試示例一
兩次測試，第一次不使用@Transactional注解，第二次使用！
第一次測試:
注釋掉@Transactional注解！
使用進行POST請求
http://localhost:8182/api/user/test1
Body參數為:
{"id":1,"name":"xuwujing","age":18}
控制臺打印的數據:
請求參數:User [id=1, name=xuwujing, age=18] 查詢的數據1:null 查詢的數據2:User [id=1, name=xuwujing, age=18] Duplicate entry '1' for key 'PRIMARY' 最后查詢的數據:User [id=1, name=xuwujing, age=18]
第二次測試:
解除@Transactional注解注釋！
使用進行POST請求
http://localhost:8182/api/user/test1
Body參數為:
{"id":1,"name":"xuwujing","age":18}
控制臺打印的數據:
請求參數:User [id=1, name=xuwujing, age=18] 查詢的數據1:null 查詢的數據2:User [id=1, name=xuwujing, age=18] Duplicate entry '1' for key 'PRIMARY' 最后查詢的數據:null
注: 在第二次測試的之前是把第一次測試寫入數據庫的id為1的數據個刪除了！
第一次測試中由于沒有添加@Transactional注解，因此發生了異常數據還是寫入了，但是第二次測試中添加了@Transactional注解，發現即使數據已經寫入了，但是出現了異常之后，數據最終被回滾了，沒有寫入！
從上述的測試用例中可以看到測試用例一種的事物已經生效了！
測試示例二
由于使用示例二中的代碼幾乎和使用示例一種的一樣，不同的是異常由我們自己進行控制！
使用進行POST請求
http://localhost:8182/api/user/test2
Body參數為:
{"id":1,"name":"xuwujing","age":18}
控制臺打印的數據:
請求參數:User [id=1, name=xuwujing, age=18] 查詢的數據1:null 查詢的數據2:User [id=1, name=xuwujing, age=18] 發生異常,進行手動回滾! Duplicate entry '1' for key 'PRIMARY' 最后查詢的數據:null
可以看到事物生效了！
測試示例三
由于使用示例三中進行了子方法調用，這里我們進行兩次測試，根據不同的請求條件來進行測試！
第一次測試:
使用進行POST請求
http://localhost:8182/api/user/test3
Body參數為:
{"id":1,"name":"xuwujing","age":18}
控制臺打印的數據:
請求參數:User [id=1, name=xuwujing, age=18] 查詢的數據1:null 查詢的數據2:User [id=1, name=xuwujing, age=18] 發生異常,進行手動回滾！ Duplicate entry '1' for key 'PRIMARY' 最后查詢的數據:null
第二次測試:
使用進行POST請求
http://localhost:8182/api/user/test3
Body參數為:
{"id":1,"name":"xuwujing","age":21}
控制臺打印的數據:
請求參數:User [id=1, name=xuwujing, age=21] 查詢的數據1:null 查詢的數據2:User [id=1, name=xuwujing, age=21] 查詢的數據3:User [id=1, name=xuwujing2, age=21] 發生異常,進行手動回滾！ Duplicate entry '1' for key 'PRIMARY' 最后查詢的數據:null
根據上述的兩次測試，可以得出使用rollbackFor注解或者將該子方法的異常拋出由調用的方法進行處理都可以使事物生效！
測試示例四
由于使用示例四中進行了手動控制事物，這里我們進行兩次測試，根據不同的請求條件來進行測試！
第一次測試:
使用進行POST請求
http://localhost:8182/api/user/test4
Body參數為:
{"id":1,"name":"xuwujing","age":18}
控制臺打印的數據:
請求參數:User [id=1, name=xuwujing, age=18] 查詢的數據1:null 查詢的數據2:User [id=1, name=xuwujing, age=18] 查詢的數據3:User [id=1, name=xuwujing2, age=20] 手動提交事物成功! 模擬第二個異常! 最后查詢的數據:User [id=1, name=xuwujing, age=20]
第二次測試:
事先還是把數據庫id為1的數據給刪除！
使用進行POST請求
http://localhost:8182/api/user/test4
Body參數為:
{"id":1,"name":"xuwujing","age":21}
控制臺打印的數據:
請求參數:User [id=1, name=xuwujing, age=21] 查詢的數據1:null 查詢的數據2:User [id=1, name=xuwujing, age=21] 發生異常,進行手動回滾！ 模擬一個異常! 最后查詢的數據:null
根據上述的兩次測試，我們可以得出使用手動控制事物完全ok，只要提交了事物，即使后面發生了異常也不回影響之前的寫入！如果在控制的范圍之類發生了異常，也可以進行回滾！
測試示例圖:
來源：https://www.cnblogs.com/xuwujing/p/11184162.html
