通過實際案例摸清楚Spring事務傳播的行爲

事務傳播

對於Spring事務傳播的七大行爲，我們往往還停留在一些概念上，比如下面這張表：

定義	說明
PROPAGATION_REQUIRED	如果當前沒有事務，就新建一個事務，如果已經存在一個事務，則加入到這個事務中。這是最常見的選擇。
PROPAGATION_SUPPORTS	支持當前事務，如果當前沒有事務，就以非事務方式執行。
PROPAGATION_MANDATORY	表示該方法必須在事務中運行，如果當前事務不存在，則會拋出一個異常。
PROPAGATION_REQUIRED_NEW	表示當前方法必須運行在它自己的事務中。一個新的事務將被啓動。如果存在當前事務，在該方法執行期間，當前事務會被掛起。
PROPAGATION_NOT_SUPPORTED	表示該方法不應該運行在事務中。如果當前存在事務，就把當前事務掛起。
PROPAGATION_NEVER	表示當前方法不應該運行在事務上下文中。如果當前正有一個事務在運行，則會拋出異常。
PROPAGATION_NESTED	如果當前存在事務，則在嵌套事務內執行。如果當前沒有事務，則執行與PROPAGATION_REQUIRED類似的操作。

本文旨在通過實際案例代碼進行分析Spring事務傳播行爲的各種特性。

案例準備

構建一個SpringBoot項目，增加以下代碼：

實體類

/**
*  User.java ： 用戶類
*/
@Entity
public class User implements Serializable {
    // 用戶id
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // 用戶名
    @NotBlank(message = "用戶名稱不能爲空")
    @Column(name="name")
    private String name;
    // 郵箱
    @Column(name="email")
    @Pattern(message ="郵箱格式不符", regexp = "^[A-Za-z0-9\\u4e00-\\u9fa5]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$")
    private String email;
    
    public User(){}

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", createTime=" + createTime +
                ", updateTime=" + updateTime +
                '}';
    }
}

DAO接口與實現類

/**
 * 用戶數據訪問層(DAO)接口
 */
public interface UserDAO {
    // 查找所有用戶
    List<User> findAll();

    // 根據id查找用戶
    User findById(Long id) throws SQLException;

    // 新增用戶
    Long addUser(User user) throws SQLException;

    // 更新用戶
    void updateUser(User user);

    // 刪除用戶
    void deleteById(Long id);

    // 自定義添加通過用戶名稱查找用戶信息
    List<User> findByName(String name);
}

/**
 * 使用JdbcTemplate模板類實現用戶數據訪問層
 *
 */
@Repository
public class UserDAOImpl implements UserDAO {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public List<User> findAll() {
        return jdbcTemplate.query("select id,name,email from user;",
                new Object[]{}, new BeanPropertyRowMapper<>(User.class));
    }

    @Override
    public User findById(Long id) {
        return jdbcTemplate.queryForObject("select id,name,email from user where id=?;",
                new Object[]{id}, new BeanPropertyRowMapper<>(User.class));
    }

    @Override
    public Long addUser(User user) {
        return Integer.toUnsignedLong(
                jdbcTemplate.update("insert into  user(id,name,email) values(?,?,?);"
                        , user.getId(), user.getName(), user.getEmail()));
    }

    @Override
    public void updateUser(User user) {
        jdbcTemplate.update("update user set name=?,email=? where id =?;"
                , user.getName(), user.getEmail(), user.getId());
    }

    @Override
    public void deleteById(Long id) {
        jdbcTemplate.update("delete from user where id=?", new Object[]{id});
    }

    @Override
    public List<User> findByName(String name) {
        return jdbcTemplate.query("select id,name,email from user where name=?;",
                new Object[]{name}, new BeanPropertyRowMapper<>(User.class));
    }
}

測試類

/**
 * 事務傳播測試案例
 */
public class TransactionalTest {

    @Autowired
    private UserDAO userDAO;

    // 無事務
    public void noneTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 增加一個與user1主鍵相同的用戶
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
        
    }
	//....

}

案例解析

1、無事務

插入兩個id(主鍵)相同的用戶數據。

// 無事務
    public void noneTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 增加一個與user1主鍵相同的用戶
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
        
    }

插入第一條數據成功，第二條數據失敗
由於沒有事務控制，數據庫表中會存在一條數據：

2、 Propagation.REQUIRED

這個是默認的事務傳播行爲：如果當前沒有事務，就新建一個事務，如果已經存在一個事務，則加入到這個事務中。
仍然插入兩個id(主鍵)相同的用戶數據。

    // 事務傳播爲PROPAGATION_REQUIRED
    @Transactional(propagation = Propagation.REQUIRED)
    public void requiredTransaction() throws SQLException {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 增加一個與user1主鍵相同的用戶
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
    }

第二條數據插入時報重複主鍵錯誤
由於啓用了事務，提示事務回滾，表中沒有插入任何數據

3. Propagation.SUPPORTS

支持當前事務，如果當前沒有事務，就以非事務方式執行。這裏我們做兩個測試，首先以原來的代碼，即調用外層沒有啓用事務來運行：

    // 事務傳播爲PROPAGATION_SUPPORTS
    // 調用的外層沒有事務
    @Transactional(propagation = Propagation.SUPPORTS)
    public void supportsTransaction() throws SQLException {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 增加一個與user1主鍵相同的用戶
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
    }

第一條插入成功，插入第二條事務時報主鍵重複錯誤，由於調用方外層啓用事務，表中存留第一條數據。
接下來修改代碼，用一個已啓事務的調用方來調用該測試過程：

    // 事務傳播爲PROPAGATION_SUPPORTS
    // 調用方已啓用事務
    @Transactional
    public void callSupportsTransaction() throws SQLException {
        supportsTransaction();
    }
    
	@Transactional(propagation = Propagation.SUPPORTS)
    public void supportsTransaction() throws SQLException {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 增加一個與user1主鍵相同的用戶
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
    }

第一條插入成功，插入第二條事務時報主鍵重複錯誤，但由於這次調用方已啓用了事務，表中沒有插入任何數據。

4. Propagation.MANDATORY

表示該方法必須在事務中運行，如果當前事務不存在，則會拋出一個異常。
我們首先直接運行以下代碼

    // 事務傳播爲PROPAGATION_MANDATORY
    @Transactional(propagation = Propagation.MANDATORY)
    public void mandatoryTransaction() throws SQLException {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
    }

由於調用外層沒有啓用事務，該段測試代碼判斷當前事務不存在，則會拋出不存在事務的錯誤
接下來使用調用方的外層啓用事務，再調用這段測試代碼:

// 事務傳播爲PROPAGATION_MANDATORY
    // 調用方啓用事務
    @Transactional
    public void callMandatoryTransaction() throws SQLException {
        User user = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user);
        mandatoryTransaction();
    }

	 @Transactional(propagation = Propagation.MANDATORY)
    public void mandatoryTransaction() throws SQLException {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
    }

測試程序在插入第二條數據時報主鍵錯誤
由於調用方啓用事務，事務回滾，沒有插入任何數據。

5. Propagation.REQUIRED_NEW

表示當前方法必須運行在它自己的事務中。一個新的事務將被啓動。如果存在當前事務，在該方法執行期間，當前事務會被掛起。
針對這種特性，我們做一個有趣的實驗：調用方啓用默認事務，並調用事務傳播爲PROPAGATION_REQUIRES_NEW的程序，並故意造成事務回滾。

// 調用方啓用默認事務，並調用事務傳播爲PROPAGATION_REQUIRES_NEW的程序，在外層故意造成事務回滾
    @Transactional
    public void callRequiresNewTransaction() throws SQLException {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        requiresNewTransaction();
        // 增加一個主鍵重複的用戶，故意造成事務回滾
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
    }

    // 事務傳播爲PROPAGATION_REQUIRES_NEW
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void requiresNewTransaction() throws SQLException {
        User user = new User(101L, "Jack", "[email protected]");
        userDAO.addUser(user);
    }

測試情況如下：在外層事務造成回滾後，表中沒有插入任何數據。
接下來再改下程序，調用方啓用默認事務，並調用事務傳播爲PROPAGATION_REQUIRES_NEW的程序，但在調用的程序內層故意造成事務回滾。

  // 調用方啓用默認事務，並調用事務傳播爲PROPAGATION_REQUIRES_NEW的程序
    @Transactional
    public void callRequiresNewTransaction() throws SQLException {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 調用事務傳播爲PROPAGATION_REQUIRES_NEW的過程
        requiresNewTransaction();
       
        User user2 = new User(101L, "Rose", "[email protected]");
        userDAO.addUser(user2);
    }

    // 事務傳播爲PROPAGATION_REQUIRES_NEW
    // 內層錯誤造成事務回滾
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void requiresNewTransaction(){
        // 增加一個主鍵重複的用戶，故意造成事務回滾
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
    }

同樣會造成事務回滾，表中無任何數據插入

6. Propagation.NOT_SUPPORTED

該方法不應該運行在事務中。如果當前存在事務，就把當前事務掛起。
爲了測試該特性，我們首先定義另外一個測試服務類，該服務類中定義了事務傳播爲Propagation.NOT_SUPPORTED的方法

/**
 * 測試 Propagation.NOT_SUPPORTED
 */
@Service
public class UserServiceTest {
    @Autowired
    private UserDAOImpl userDAO;
    // 事務傳播爲Propagation.NOT_SUPPORTED
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void notSupportedTransaction(){
        User user2 = new User(101L, "Rose", "[email protected]");
        userDAO.addUser(user2);
    }

}

在主測試類啓用默認事務，並調用新增服務類中的事務傳播爲Propagation.NOT_SUPPORTED的方法，並且故意增加重複用戶數據，造成主服務的事務回滾：

 // 主測試類啓用默認事務，並調用Propagation.NOT_SUPPORTED的方法
    @Transactional
    public void callNotSupportedTransaction() {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 調用事務傳播爲Propagation.NOT_SUPPORTED的過程
        userServiceTest.notSupportedTransaction();
        // 增加重複用戶數據
        User user2 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user2);
    }

由於主服務類中啓用了事務，在插入第二條重複用戶數據時，會報主鍵衝突，造成事務回滾，兩條數據都沒有插入；但新增的服務類的方法沒有運行在事務中，新增的用戶數據會插入表中。

7. Propagation.NEVER

表示當前方法不應該運行在事務上下文中。如果當前正有一個事務在運行，則會拋出異常。
按測試Propagation.NOT_SUPPORTED進行改造，主服務類啓用默認事務特性，並調用測試服務類Propagation.NEVER的過程

// 調用方啓用默認事務，並調用Propagation.NEVER的過程
    // 調用方啓用默認事務，並調用Propagation.NEVER的過程
    @Transactional
    public void callNeverTransaction  {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 調用事務傳播爲Propagation.NEVER的過程
        userServiceTest.neverTransaction();
    }

// 事務傳播爲Propagation.NEVER的過程
    @Transactional(propagation = Propagation.NEVER)
    public void neverTransaction() {
        User user2 = new User(101L, "Rose", "[email protected]");
        userDAO.addUser(user2);
    }

由於主服務類啓用了事務，而測試服務類的Propagation.NEVER不允許運行在事務中，會拋出異常。

8. Propagation.NESTED

如果當前存在事務，則在嵌套事務內執行。如果當前沒有事務，則執行與PROPAGATION_REQUIRED類似的操作。
測試案例如下：主服務類不起任何事務，調用測試服務類Propagation.NESTED 的方法，且該方法中故意製造主鍵衝突的重複數據

// 調用方不起事務，並調用Propagation.NESTED的過程
    public void callNestedTransaction(User user)  {
        User user1 = new User(100L, "Jack", "[email protected]");
        userDAO.addUser(user1);
        // 調用事務傳播爲Propagation.NEVER的過程
        userServiceTest.nestedTransaction();
    }

// 事務傳播爲Propagation.NESTED
    @Transactional(propagation = Propagation.NESTED)
    public void nestedTransaction() {
        User user2 = new User(101L, "Rose", "[email protected]");
        userDAO.addUser(user2);
        // 插入重複數據，造成主鍵衝突
        User user3 = new User(101L, "Rose", "[email protected]");
        userDAO.addUser(user3);
    }

由於主服務類沒有啓用事務，則第一條數據會插入表中，但測試服務類啓用了Propagation.NESTED特性的事務，也即相當於默認事務行爲，主鍵衝突拋出異常後，造成事務回滾，後面增加的兩條數據都沒有插入表。

注意點

需要嵌套測試事務傳播特性時應建立兩個服務類，儘量不要在同一服務類中調用。

通過實際案例摸清楚Spring事務傳播的行爲

事務傳播

案例準備

案例解析

1、無事務

2、 Propagation.REQUIRED

3. Propagation.SUPPORTS

4. Propagation.MANDATORY

5. Propagation.REQUIRED_NEW

6. Propagation.NOT_SUPPORTED

7. Propagation.NEVER

8. Propagation.NESTED

注意點

移位操作搞定兩數之商

如何基於surging跨網關跨語言進行緩存降級

2024合集

程序員天天 CURD，怎麼才能成長，職業發展的思考(2)

教你用Perl實現Smgp協議

如何通過前端表格控件在10分鐘內完成一張分組報表？

win11關閉自動檢測病毒刪文件

通用代碼生成器簡介

lightdb 單機模式下數據庫平移

千兆寬帶實際網速能到達多少？

Spring Cloud Alibaba生態探索：Dubbo、Nacos及Sentinel的完美結合

Spring Cloud Alibaba微服務生態的基礎實踐

自己作圖分析分佈式技術架構演化的常用套路

用一個實例項目重新認識分佈式系統

重溫Java Web的技術細節

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結