Java 方法中迴圈呼叫具有事務的方法

TechSynapse發表於2024-07-05
Java

在Java中，迴圈呼叫一個具有事務的方法時，需要特別注意事務的邊界和管理。通常，事務的邊界是由框架（如Spring）來控制的，確保方法執行時資料的完整性和一致性。然而，在迴圈中呼叫事務方法時，每個呼叫都可以被視為獨立的事務，除非特別配置以允許跨多個方法呼叫共享同一事務。

1. Java 方法中迴圈呼叫具有事務的具體方法示例

下面，我將提供一個使用Spring框架的示例，其中包含一個服務層方法，該方法在迴圈中呼叫另一個具有事務註解的方法。請注意，預設情況下，Spring的@Transactional註解在每個方法呼叫時都會開啟一個新的事務，除非配置為使用不同的傳播行為。

1.1 示例環境

（1）Spring Boot 2.x；

（2）Maven 專案。

1.2 Maven 依賴

首先，確保我們的pom.xml檔案中包含必要的Spring Boot和資料庫相關依賴。這裡只列出核心依賴：

<dependencies>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-data-jpa</artifactId>  
    </dependency>  
    <dependency>  
        <groupId>com.h2database</groupId>  
        <artifactId>h2</artifactId>  
        <scope>runtime</scope>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
</dependencies>

1.3 實體類

假設我們有一個簡單的User實體類：

import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.GenerationType;  
import javax.persistence.Id;  
  
@Entity  
public class User {  
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)  
    private Long id;  
    private String name;  
  
    // 省略構造方法、getter和setter  
}

1.4 倉庫介面

import org.springframework.data.jpa.repository.JpaRepository;  
  
public interface UserRepository extends JpaRepository<User, Long> {  
}

1.5 服務層

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Transactional;  
  
@Service  
public class UserService {  
  
    @Autowired  
    private UserRepository userRepository;  
  
    // 假設這個方法需要在迴圈中呼叫另一個事務方法  
    public void processUsers() {  
        for (int i = 0; i < 10; i++) {  
            // 每次迴圈呼叫一個事務方法  
            createUser("User" + i);  
        }  
    }  
  
    @Transactional  
    public void createUser(String name) {  
        User user = new User();  
        user.setName(name);  
        userRepository.save(user);  
        // 這裡可以模擬一些業務邏輯，如果丟擲異常，則當前事務會回滾  
        // throw new RuntimeException("Failed to create user");  
    }  
}

1.6 控制器

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class UserController {  
  
    @Autowired  
    private UserService userService;  
  
    @GetMapping("/process")  
    public String processUsers() {  
        userService.processUsers();  
        return "Users processed successfully!";  
    }  
}

1.7 注意

（1）在上面的例子中，createUser方法被@Transactional註解標記，意味著它將在自己的事務中執行。由於processUsers方法沒有@Transactional註解，所以迴圈中的每次createUser呼叫都將獨立開啟和關閉事務。

（2）如果需要所有createUser呼叫在同一個事務中執行（例如，要求所有使用者建立成功或全部失敗），我們需要將@Transactional註解移動到processUsers方法上，並可能調整傳播行為（儘管在這種情況下，預設的傳播行為REQUIRED應該就足夠了）。

1.8 結論

這個示例演示瞭如何在Java（特別是Spring框架中）迴圈呼叫具有事務的方法。根據我們的具體需求，我們可能需要調整事務的傳播行為或邊界。

2.其他方法示例

在Java中，特別是在使用Spring框架時，管理事務的方式不僅僅是透過@Transactional註解。雖然@Transactional是Spring中最常用和推薦的方式，但還有其他幾種方法可以實現類似的功能。以下是一些替代方案：

2.1 程式設計式事務管理

程式設計式事務管理允許我們透過程式碼直接控制事務的開始、結束以及異常時的回滾。Spring提供了TransactionTemplate和PlatformTransactionManager來幫助進行程式設計式事務管理。

示例：使用TransactionTemplate

@Autowired  
private TransactionTemplate transactionTemplate;  
  
@Autowired  
private UserRepository userRepository;  
  
public void processUsers() {  
    transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
        @Override  
        protected void doInTransactionWithoutResult(TransactionStatus status) {  
            for (int i = 0; i < 10; i++) {  
                try {  
                    createUser("User" + i);  
                } catch (RuntimeException ex) {  
                    // 可以在這裡決定是回滾整個事務還是隻處理當前異常  
                    status.setRollbackOnly();  
                    throw ex; // 可選，根據需要丟擲或處理異常  
                }  
            }  
        }  
  
        private void createUser(String name) {  
            User user = new User();  
            user.setName(name);  
            userRepository.save(user);  
        }  
    });  
}

注意：在這個例子中，整個迴圈被包裹在一個事務中，這意味著如果迴圈中的任何createUser呼叫失敗，整個事務將回滾。

2.2 宣告式事務管理（除了@Transactional）

雖然@Transactional是宣告式事務管理的典型方式，但Spring也支援透過XML配置來實現相同的功能。不過，在現代Spring應用中，這種方式已經不太常見了。

示例XML配置（簡化版）：

<beans ...>  
  
    <!-- 事務管理器配置 -->  
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource"/>  
    </bean>  
  
    <!-- 宣告事務代理 -->  
    <tx:advice id="txAdvice" transaction-manager="transactionManager">  
        <tx:attributes>  
            <tx:method name="*" propagation="REQUIRED"/>  
        </tx:attributes>  
    </tx:advice>  
  
    <!-- 定義切入點 -->  
    <aop:config>  
        <aop:pointcut id="serviceOperation" expression="execution(* com.example.service.*.*(..))"/>  
        <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation"/>  
    </aop:config>  
  
    <!-- 其他bean定義... -->  
  
</beans>

注意：這個XML配置需要與Spring的AOP名稱空間一起使用，並且dataSource bean 也需要被定義。

2.3 使用AOP（面向切面程式設計）手動建立事務

我們可以透過Spring的AOP框架手動攔截方法呼叫，並在呼叫前後新增事務管理邏輯。這通常比直接使用@Transactional或TransactionTemplate更復雜，因此不推薦除非有特殊需求。

使用AOP手動管理事務通常不是推薦的做法，因為它涉及到底層事務API的直接呼叫，這可能會使程式碼變得複雜且難以維護。不過，為了說明目的，我們可以想象一個切面，它在方法呼叫前後分別開啟和提交/回滾事務。

示例AOP切面（概念性）：

@Aspect  
@Component  
public class TransactionAspect {  
  
    @Autowired  
    private PlatformTransactionManager transactionManager;  
  
    @Around("execution(* com.example.service.*.*(..))")  
    public Object manageTransaction(ProceedingJoinPoint pjp) throws Throwable {  
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());  
        try {  
            Object result = pjp.proceed(); // 執行方法  
            transactionManager.commit(status);  
            return result;  
        } catch (RuntimeException e) {  
            transactionManager.rollback(status);  
            throw e;  
        }  
    }  
}

注意：這個示例非常簡化，並且沒有處理事務傳播行為、只讀事務等高階特性。此外，它也沒有考慮事務的同步和併發問題。

2.4 資料庫層面的事務

在某些情況下，我們也可以依賴資料庫本身的事務支援。例如，使用JDBC時，我們可以手動管理Connection物件的setAutoCommit(false)來開啟事務，並在完成所有資料庫操作後呼叫commit()或rollback()。然而，這種方法通常與Spring的事務管理整合不佳，並且容易出錯。

在資料庫層面管理事務通常涉及使用JDBC的Connection物件。這不是Spring特有的，但Spring提供了對JDBC的封裝（如JdbcTemplate），儘管它通常與Spring的事務管理一起使用。

JDBC示例（非Spring特有）：

Connection conn = dataSource.getConnection();  
try {  
    conn.setAutoCommit(false);  
    // 執行SQL語句...  
    conn.commit();  
} catch (SQLException e) {  
    if (conn != null) {  
        try {  
            conn.rollback();  
        } catch (SQLException ex) {  
            // 處理回滾異常  
        }  
    }  
    throw e; // 重新丟擲異常  
} finally {  
    if (conn != null) {  
        try {  
            conn.close();  
        } catch (SQLException e) {  
            // 處理關閉連線異常  
        }  
    }  
}

2.5 使用分散式事務

如果我們的應用需要跨多個資料庫或服務進行事務管理，那麼我們可能需要使用分散式事務解決方案，如JTA（Java Transaction API）、Atomikos、Bitronix或Spring Cloud的分散式事務支援（如透過Spring Cloud Data Flow）。

分散式事務涉及多個服務或資料庫之間的協調。Spring Cloud提供了對分散式事務的支援，但通常依賴於外部服務（如Atomikos、Bitronix或基於J他的實現）。

示例（概念性，使用Spring Cloud和Atomikos）：

這通常涉及在Spring Boot應用中配置Atomikos作為JTA事務管理器，並在需要分散式事務的服務中注入該事務管理器。然後，我們可以使用@Transactional註解來標記需要分散式事務支援的方法。但是，具體的配置將取決於我們使用的Spring Cloud版本和分散式事務解決方案。

2.6 結論

對於大多數Spring應用來說，@Transactional註解是管理事務的首選方法。然而，根據我們的具體需求和場景，我們可能需要考慮上述其他方法。在選擇時，請權衡每種方法的優缺點，並選擇最適合我們應用需求的方案。

由於篇幅和複雜性的限制，我將為每種方法提供一個簡化的程式碼示例框架或思路，而不是完整的可執行程式碼。這些示例旨在說明概念和方法，而不是直接用於生產環境。

相關文章