在日常工作中，如果對 Spring 的事務管理功能使用不當，則會造成 Spring 事務不生效的問題。而針對 Spring 事務不生效的問題，也是在跳槽面試中被問的比較頻繁的一個問題。
今天，我們就一起梳理下有哪些場景會導致 Spring 事務失效。

Spring 事務失效的8中場景

下面就舉例說明這8種失效場景及解決方法

1.使用不支持事務的存儲引擎

Spring 事務生效的前提是所連接的數據庫要支持事務，如果底層的數據庫都不支持事務，則 Spring 的事務肯定會失效。例如，如果使用的數據庫為 MySQL，并且選用了 MyISAM 存儲引擎，則 Spring 的事務就會失效。

解決方法：使用MySQL中的InnoDB存儲引擎就支持事務

2.拋出檢查異常導致事務不能正確回滾

以下是一個示例，演示了拋出檢查異常導致事務不能正確回滾的情況：

public class UserService {  
  
    @Autowired  
    private JdbcTemplate jdbcTemplate;  
  
    @Transactional(propagation = Propagation.REQUIRES_NEW)  
    public void saveUser(User user) {  
        try {  
            jdbcTemplate.update("INSERT INTO users (name, age) VALUES (?, ?)", user.getName(), user.getAge());  
            // 拋出檢查異常，事務將不會回滾  
            throw new Exception("模擬檢查異常");  
        } catch (Exception e) {  
            // 異常處理邏輯  
            e.printStackTrace();  
        }  
    }  
}

在上面的示例中，saveUser()方法被標記為@Transactional，并指定了propagation = Propagation.REQUIRES_NEW傳播行為。這意味著該方法必須在一個新的事務中運行。如果在執行插入操作后拋出了檢查異常（Exception），事務將不會回滾。這是因為檢查異常是開發者可以預見的異常，并且開發者通過捕獲并處理這些異常來控制程序的流程。因此，事務管理器不會回滾事務，以保持數據庫的一致性。

解決方法：使用運行時異常：在Spring框架中，建議使用RuntimeException或其子類作為事務方法中拋出的異常。RuntimeException是未檢查異常的子類，因此不會導致事務回滾。相反，檢查異常（即那些直接或間接繼承自Exception的異常）會導致事務回滾。

3.業務方法內自己 try-catch導致事務不能正確回滾

public class UserService {  
  
    @Autowired  
    private JdbcTemplate jdbcTemplate;  
  
    @Transactional(propagation = Propagation.REQUIRES_NEW)  
    public void saveUser(User user) {  
        try {  
            jdbcTemplate.update("INSERT INTO users (name, age) VALUES (?, ?)", user.getName(), user.getAge());  
            // 模擬拋出異常，但被try-catch捕獲并靜默處理  
            throw new Exception("模擬異常");  
        } catch (Exception e) {  
            // 異常被捕獲并靜默處理，事務不會回滾  
            e.printStackTrace();  
        }  
    }  
}

在上面的示例中，saveUser()方法被標記為@Transactional，并指定了propagation = Propagation.REQUIRES_NEW傳播行為。這意味著該方法必須在一個新的事務中運行。在try塊中，我們執行了一個插入操作，然后模擬拋出了一個異常。這個異常被catch塊捕獲，并靜默處理（只是打印堆棧跟蹤）。由于異常被靜默處理，事務不會回滾。

解決方法: 要避免這種情況，你應該確保在事務方法中捕獲的異常被適當地向外拋出，以便Spring的事務管理器可以檢測到異常并回滾事務。你可以選擇拋出運行時異?；驒z查異常，但重要的是要確保異常被正確地傳遞給調用者，以便于調試和錯誤處理。

4.非public方法導致的事務時效

當事務方法被標記為非public時，會導致事務失效。這是因為在Spring的聲明式事務管理機制中，代理類只能代理public方法。如果方法被聲明為非public，代理類無法訪問該方法，從而導致事務失效。
以下是一個示例，演示了非public方法導致的事務失效場景：

public class UserService {  
  
    @Autowired  
    private JdbcTemplate jdbcTemplate;  
  
    @Transactional  
    private void saveUser(User user) {  
        jdbcTemplate.update("INSERT INTO users (name, age) VALUES (?, ?)",  user.getName(), user.getAge());  
    }  
}

在上面的示例中，saveUser()方法被聲明為private，導致Spring的代理類無法訪問該方法。因此，事務失效，并且無法正確地回滾事務。要解決這個問題，你可以將方法聲明為public，以確保Spring的代理類可以訪問該方法并正確地管理事務。
解決方法: 使用public方法

5.@Transactional沒有保證原子行為

當事務方法中存在SELECT方法時，Spring的@Transactional注解無法保證原子性。這是因為SELECT方法不會阻塞，事務的原子性僅僅涵蓋INSERT、UPDATE、DELETE、SELECT...FOR UPDATE語句。
以下是一個示例，演示了@Transactional沒有保證原子行為導致的事務失效場景：

public class UserService {  
  
    @Autowired  
    private JdbcTemplate jdbcTemplate;  
  
    @Transactional  
    public void updateUser(User user) {  
        // SELECT方法不會阻塞，事務的原子性無法保證  
        User existingUser = jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", user.getId());  
        // 更新操作  
        jdbcTemplate.update("UPDATE users SET name = ? WHERE id = ?", user.getName(), user.getId());  
    }  
}

在上面的示例中，事務方法中包含了一個SELECT方法，用于查詢用戶信息。然后執行了一個更新操作。由于SELECT方法不會阻塞，事務的原子性無法得到保證。如果其他線程在SELECT和UPDATE之間修改了數據，可能會出現數據不一致的情況。要解決這個問題，你可以考慮使用其他方式來保證原子性，例如使用數據庫鎖或使用Spring的事務傳播行為。
解決方法：

1. 使用數據庫鎖：通過數據庫鎖來保證多個操作在一個事務中的原子性。你可以使用數據庫提供的鎖機制，例如行鎖或表鎖，來確保在事務中的操作不會被其他線程干擾。
2. 修改存儲引擎：將數據庫的存儲引擎改為InnoDB，而不是默認的MyISAM。InnoDB引擎支持事務，并提供了行級鎖定和外鍵約束等特性，可以更好地保證數據的一致性和完整性。
3. 使用Spring的事務傳播行為：通過設置@Transactional注解的propagation屬性，你可以指定事務的傳播行為。例如，你可以設置propagation = Propagation.REQUIRES_NEW，這樣每個事務方法都會運行在一個新的事務中，確保其原子性。
4. 修改SELECT語句：將SELECT語句替換為SELECT...FOR UPDATE語句。這樣，在查詢時會對選定的行加鎖，直到事務結束時才會釋放鎖，從而避免了其他線程的干擾。
5. 使用同步機制：在事務方法中使用同步機制，確保同一時間只有一個線程可以執行該方法。這樣可以避免并發爭搶資源的情況，保證原子性。

6.AOP切面順序導致事務不能正確回滾

以下是一個例子，展示了由于Spring AOP切面順序導致事務不能正確回滾的場景：
假設你有一個服務層方法，使用@Transactional注解進行事務管理。在調用該方法之前，你希望先進行日志記錄，以便記錄方法的調用信息和參數。因此，你使用了AOP切面來實現日志記錄功能。

@Service  
public class UserService {  
    @Transactional  
    public void createUser(User user) {  
        // 業務邏輯代碼  
    }  
}

@Aspect  
@Component  
public class LoggingAspect {  
    // 定義日志切面  
}  
@Aspect  
@Component  
public class TransactionAspect {  
    // 定義事務切面  
}

在上述示例中，createUser()方法被標記為@Transactional，用于管理事務。同時，你定義了兩個切面：日志切面和事務切面。

日志切面：用于記錄方法的調用信息和參數。
事務切面：用于管理事務的開始和回滾。

如果在Spring配置中，日志切面在事務切面前執行，那么當createUser()方法拋出異常時，日志切面可能會先捕獲到異常并記錄日志，而事務切面可能還沒有開始事務。這樣，事務切面無法正確地回滾事務，導致數據不一致和其他潛在問題。

解決方法: 為了解決這個問題，你可以在Spring配置中明確指定切面的順序，確保事務切面在日志切面前執行。你可以使用@Order注解或通過XML配置來定義切面的順序。例如：

@Aspect  
@Component  
@Order(1) // 定義日志切面的順序為1  
public class LoggingAspect {  
    // 定義日志切面邏輯  
}  
  
@Aspect  
@Component  
@Order(2) // 定義事務切面的順序為2  
public class TransactionAspect {  
    // 定義事務切面邏輯  
}

7.調用本類方法導致傳播行為失效

在Spring事務中，當一個事務方法調用了本類（同一個類）的其他方法時，可能會導致事務的傳播行為失效。
下面是一個示例場景，展示了由于調用本類方法導致事務傳播行為失效的問題：

假設你有一個服務類UserService，其中包含兩個方法：createUser()和updateUser()。createUser()方法被標記為@Transactional，用于管理事務。

@Service  
public class UserService {  
  
    @Transactional  
    public void createUser(User user) {  
        // 調用updateUser()方法  
        updateUser(user);  
    }  
  
    public void updateUser(User user) {  
        // 更新用戶信息的邏輯代碼  
    }  
}

在上述示例中，createUser()方法被標記為@Transactional，并調用了本類的updateUser()方法。這意味著，當createUser()方法執行時，它應該在一個事務的上下文中運行。

然而，由于updateUser()方法沒有被標記為@Transactional，它不會在事務的上下文中執行。這意味著，如果在updateUser()方法中發生了異常，事務不會回滾，因為事務的傳播行為失效了。

解決辦法：你可以將需要事務管理的所有方法都標記為@Transactional，或者使用Spring的事務傳播行為來指定事務的傳播行為。例如，你可以將@Transactional注解的propagation屬性設置為Propagation.REQUIRES_NEW，這樣每個事務方法都會運行在一個新的事務中。

@Service  
public class UserService {  
  
    @Transactional(propagation = Propagation.REQUIRES_NEW)  
    public void createUser(User user) {  
        // 調用updateUser()方法  
        updateUser(user);  
    }  
  
    @Transactional(propagation = Propagation.REQUIRES_NEW)  
    public void updateUser(User user) {  
        // 更新用戶信息的邏輯代碼  
    }  
}

8.@Transactional方法導致的synchronized失效

當你在Spring中使用@Transactional注解時，Spring會為你自動管理事務。但是，@Transactional注解并不會將方法同步化，也就是說，它不會將方法標記為synchronized。

以下是一個示例場景，展示了由于@Transactional方法導致的synchronized失效的場景：

假設你有兩個服務類UserServiceA和UserServiceB，它們都包含一個名為updateUser()的方法，該方法使用synchronized關鍵字進行同步。

@Service  
public class UserServiceA {  
  
    @Transactional  
    public synchronized void updateUser(User user) {  
        // 更新用戶信息的邏輯代碼  
    }  
}  
  
@Service  
public class UserServiceB {  
  
    @Transactional  
    public synchronized void updateUser(User user) {  
        // 更新用戶信息的邏輯代碼  
    }  
}

在上述示例中，updateUser()方法被標記為@Transactional和synchronized。這意味著在多線程環境中，同一時間只能有一個線程調用該方法。

然而，由于@Transactional注解的存在，Spring會為每個事務創建一個新的事務代理對象。這意味著，當兩個線程同時調用UserServiceA.updateUser()和UserServiceB.updateUser()方法時，它們實際上是兩個不同的方法，而不是同一個方法的兩個實例。因此，盡管方法被標記為synchronized，但由于事務代理的存在，這兩個方法的同步性失效了。

解決方法：updateUser()方法被標記為@Transactional。為了確保同一時間只有一個線程執行該方法的同步代碼塊，我們使用了一個同步代碼塊，將this對象作為鎖對象。這樣，當一個線程進入同步代碼塊時，其他線程將會被阻塞，直到第一個線程退出同步代碼塊。

import org.springframework.transaction.annotation.Transactional;  
  
@Service  
public class UserService {  
  
    @Transactional  
    public void updateUser(User user) {  
        // 同步代碼塊，確保同一時間只有一個線程執行  
        synchronized (this) {  
            // 更新用戶信息的邏輯代碼  
        }  
    }  
}

通過使用同步代碼塊，你可以確保同一時間只有一個線程能夠訪問共享資源，即使事務代理存在，也不會導致synchronized失效。這種方法適用于簡單的同步需求，如果你的應用有更復雜的并發控制需求，可能需要考慮其他同步機制或數據庫鎖等更高級的解決方案。

總結

以上是生活随笔為你收集整理的面试官：请列举 Spring 的事务会失效的场景的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。