Spring @Transactional完全ガイド - トランザクション伝播と分離レベルの設定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final PaymentRepository paymentRepository;

    public OrderService(OrderRepository orderRepository, 
                       PaymentRepository paymentRepository) {
        this.orderRepository = orderRepository;
        this.paymentRepository = paymentRepository;
    }

    @Transactional
    public Order createOrder(OrderRequest request) {
        // 注文の作成
        Order order = new Order(request.getCustomerId(), request.getItems());
        orderRepository.save(order);
        
        // 支払い情報の作成
        Payment payment = new Payment(order.getId(), request.getPaymentMethod());
        paymentRepository.save(payment);
        
        // 例外が発生した場合、両方の操作がロールバックされる
        return order;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

@Service
@Transactional(readOnly = true) // クラスレベル：参照系はreadOnly
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // クラスレベルの設定（readOnly = true）が適用される
    public Product findById(Long id) {
        return productRepository.findById(id)
            .orElseThrow(() -> new ProductNotFoundException(id));
    }

    public List<Product> findAll() {
        return productRepository.findAll();
    }

    // メソッドレベルの設定が優先される（readOnly = false）
    @Transactional
    public Product updateProduct(Long id, ProductUpdateRequest request) {
        Product product = findById(id);
        product.updateName(request.getName());
        product.updatePrice(request.getPrice());
        return product; // ダーティチェックにより自動更新
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

@Service
public class OrderProcessingService {

    private final OrderService orderService;
    private final InventoryService inventoryService;

    @Transactional // REQUIRED（デフォルト）
    public void processOrder(OrderRequest request) {
        // 1. 注文作成（同一トランザクションに参加）
        Order order = orderService.createOrder(request);
        
        // 2. 在庫減少（同一トランザクションに参加）
        inventoryService.decreaseStock(request.getItems());
        
        // いずれかで例外が発生すると、全体がロールバック
    }
}

@Service
public class OrderService {
    
    @Transactional // 既存トランザクションに参加
    public Order createOrder(OrderRequest request) {
        // ...
    }
}

@Service
public class InventoryService {
    
    @Transactional // 既存トランザクションに参加
    public void decreaseStock(List<OrderItem> items) {
        // ...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

@Service
public class PaymentService {

    private final PaymentRepository paymentRepository;
    private final AuditLogService auditLogService;

    @Transactional
    public void processPayment(PaymentRequest request) {
        try {
            Payment payment = executePayment(request);
            paymentRepository.save(payment);
            
            // 監査ログは独立したトランザクションで記録
            // メイン処理が失敗しても監査ログは残る
            auditLogService.logPaymentAttempt(request, "SUCCESS");
            
        } catch (PaymentException e) {
            // 支払い失敗時も監査ログは記録される
            auditLogService.logPaymentAttempt(request, "FAILED");
            throw e; // メイントランザクションはロールバック
        }
    }
}

@Service
public class AuditLogService {

    private final AuditLogRepository auditLogRepository;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logPaymentAttempt(PaymentRequest request, String status) {
        AuditLog log = new AuditLog(
            "PAYMENT",
            request.getUserId(),
            status,
            LocalDateTime.now()
        );
        auditLogRepository.save(log);
        // この保存は独立してコミットされる
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

@Service
public class BatchOrderService {

    private final OrderRepository orderRepository;

    @Transactional
    public BatchResult processBatchOrders(List<OrderRequest> requests) {
        BatchResult result = new BatchResult();
        
        for (OrderRequest request : requests) {
            try {
                // 各注文処理はNESTEDトランザクション
                Order order = processingSingleOrder(request);
                result.addSuccess(order);
            } catch (OrderProcessingException e) {
                // この注文のみロールバック、他の注文処理は継続
                result.addFailure(request, e.getMessage());
            }
        }
        
        // 成功した注文のみコミットされる
        return result;
    }

    @Transactional(propagation = Propagation.NESTED)
    public Order processingSingleOrder(OrderRequest request) {
        // バリデーション
        validateOrder(request);
        
        Order order = new Order(request);
        orderRepository.save(order);
        
        // 何らかの問題で例外が発生した場合
        // このセーブポイント以降のみロールバック
        return order;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

@Service
public class ReportService {

    // SUPPORTS: トランザクションがあれば参加、なければ非トランザクション
    @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
    public Report generateReport(ReportCriteria criteria) {
        // トランザクション有無に関わらず動作
        return reportRepository.findByCriteria(criteria);
    }
}

@Service
public class ExternalApiService {

    // NOT_SUPPORTED: 常に非トランザクションで実行
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public ApiResponse callExternalApi(ApiRequest request) {
        // 外部API呼び出しはトランザクション外で実行
        // 長時間のDB接続保持を避ける
        return externalApiClient.call(request);
    }
}

@Service
public class InternalProcessingService {

    // MANDATORY: 既存トランザクション必須
    @Transactional(propagation = Propagation.MANDATORY)
    public void processInternal(ProcessingData data) {
        // 呼び出し元がトランザクションを開始していない場合は例外
        // IllegalTransactionStateException がスローされる
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// ダーティリード（Dirty Read）の例
// トランザクションAがコミット前のデータをトランザクションBが読み取る

// トランザクションA
@Transactional
public void updateBalance(Long accountId, BigDecimal amount) {
    Account account = accountRepository.findById(accountId).orElseThrow();
    account.setBalance(amount); // まだコミットされていない
    // この時点でトランザクションBがこの値を読み取る可能性（ダーティリード）
    
    validateBalance(account); // バリデーションで例外 → ロールバック
}

// トランザクションB（READ_UNCOMMITTEDの場合）
@Transactional(isolation = Isolation.READ_UNCOMMITTED)
public BigDecimal getBalance(Long accountId) {
    // トランザクションAのコミット前の値を読み取る可能性あり
    return accountRepository.findById(accountId)
        .map(Account::getBalance)
        .orElse(BigDecimal.ZERO);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

@Service
public class AccountService {

    private final AccountRepository accountRepository;

    // READ_COMMITTED: 一般的な参照処理
    @Transactional(isolation = Isolation.READ_COMMITTED, readOnly = true)
    public Account findAccount(Long id) {
        return accountRepository.findById(id)
            .orElseThrow(() -> new AccountNotFoundException(id));
    }

    // REPEATABLE_READ: 同一トランザクション内で一貫した読み取りが必要
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void transferWithConsistentRead(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountRepository.findById(fromId).orElseThrow();
        Account to = accountRepository.findById(toId).orElseThrow();
        
        // 複数回の読み取りでも同じ値が保証される
        BigDecimal fromBalance = from.getBalance();
        
        // 何らかの処理...
        
        // 再度読み取っても同じ値（非反復読み取りが防止される）
        BigDecimal fromBalanceAgain = accountRepository.findById(fromId)
            .map(Account::getBalance)
            .orElse(BigDecimal.ZERO);
        
        // fromBalance == fromBalanceAgain が保証される
        
        from.withdraw(amount);
        to.deposit(amount);
    }

    // SERIALIZABLE: 厳密な整合性が必要な金融処理
    @Transactional(isolation = Isolation.SERIALIZABLE)
    public void criticalFinancialOperation(Long accountId, BigDecimal amount) {
        // 完全な直列化が保証される
        // 他のトランザクションとの競合時はリトライが必要
        Account account = accountRepository.findByIdWithLock(accountId);
        account.adjustBalance(amount);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

@Service
@Transactional(readOnly = true) // クラスレベルで設定
public class ProductQueryService {

    private final ProductRepository productRepository;

    public ProductQueryService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // readOnly = true の効果:
    // 1. Hibernateのダーティチェックが無効化される
    // 2. FlushModeがMANUALに設定される（自動フラッシュなし）
    // 3. データベースが読み取り専用の最適化を適用できる
    public List<Product> findByCategory(String category) {
        return productRepository.findByCategory(category);
    }

    public Page<Product> searchProducts(ProductSearchCriteria criteria, 
                                        Pageable pageable) {
        return productRepository.findAll(
            ProductSpecifications.byCriteria(criteria),
            pageable
        );
    }

    // 大量データの読み取りで特に効果的
    public List<ProductSummary> findAllSummaries() {
        return productRepository.findAllSummaries();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

@Service
public class ReportService {

    private final OrderRepository orderRepository;
    private final EntityManager entityManager;

    public ReportService(OrderRepository orderRepository, 
                        EntityManager entityManager) {
        this.orderRepository = orderRepository;
        this.entityManager = entityManager;
    }

    // 大量データを扱うレポート生成
    @Transactional(readOnly = true)
    public SalesReport generateMonthlySalesReport(YearMonth month) {
        LocalDate startDate = month.atDay(1);
        LocalDate endDate = month.atEndOfMonth();
        
        // 大量のOrderを読み取り
        List<Order> orders = orderRepository
            .findByOrderDateBetween(startDate, endDate);
        
        // readOnly = true により:
        // - 各Orderのスナップショットが保持されない
        // - ダーティチェックのオーバーヘッドがない
        // - メモリ使用量が削減される
        
        return SalesReport.from(orders);
    }

    // ストリーミング処理との組み合わせ
    @Transactional(readOnly = true)
    public void exportAllOrders(OutputStream outputStream) {
        try (Stream<Order> orderStream = orderRepository.streamAll()) {
            orderStream.forEach(order -> {
                writeToStream(order, outputStream);
                // メモリ解放のため定期的にクリア
                entityManager.detach(order);
            });
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# application.yml
spring:
  datasource:
    primary:
      url: jdbc:postgresql://primary-db:5432/myapp
      username: app_user
      password: ${DB_PASSWORD}
    replica:
      url: jdbc:postgresql://replica-db:5432/myapp
      username: app_user
      password: ${DB_PASSWORD}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

@Configuration
public class DataSourceConfig {

    @Bean
    @Primary
    public DataSource routingDataSource(
            @Qualifier("primaryDataSource") DataSource primary,
            @Qualifier("replicaDataSource") DataSource replica) {
        
        ReadWriteRoutingDataSource routingDataSource = 
            new ReadWriteRoutingDataSource();
        
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.PRIMARY, primary);
        targetDataSources.put(DataSourceType.REPLICA, replica);
        
        routingDataSource.setTargetDataSources(targetDataSources);
        routingDataSource.setDefaultTargetDataSource(primary);
        
        return routingDataSource;
    }
}

public class ReadWriteRoutingDataSource extends AbstractRoutingDataSource {
    
    @Override
    protected Object determineCurrentLookupKey() {
        // readOnlyトランザクションはレプリカへ
        return TransactionSynchronizationManager.isCurrentTransactionReadOnly()
            ? DataSourceType.REPLICA
            : DataSourceType.PRIMARY;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 悪い例: 自己呼び出しでトランザクションが効かない
@Service
public class OrderService {

    @Transactional
    public void processOrders(List<OrderRequest> requests) {
        for (OrderRequest request : requests) {
            // 自己呼び出し - @Transactionalが無視される
            createOrder(request);
        }
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void createOrder(OrderRequest request) {
        // REQUIRES_NEWが適用されない
        // processOrdersと同一トランザクションで実行される
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 良い例1: 別のBeanに分離
@Service
public class OrderService {

    private final OrderCreationService orderCreationService;

    @Transactional
    public void processOrders(List<OrderRequest> requests) {
        for (OrderRequest request : requests) {
            // 別Beanの呼び出し - トランザクションが正しく適用される
            orderCreationService.createOrder(request);
        }
    }
}

@Service
public class OrderCreationService {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void createOrder(OrderRequest request) {
        // REQUIRES_NEWが正しく適用される
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 良い例2: 自己注入（Self-Injection）を使用
@Service
public class OrderService {

    private final OrderService self;

    public OrderService(@Lazy OrderService self) {
        this.self = self;
    }

    @Transactional
    public void processOrders(List<OrderRequest> requests) {
        for (OrderRequest request : requests) {
            // プロキシ経由の呼び出し
            self.createOrder(request);
        }
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void createOrder(OrderRequest request) {
        // REQUIRES_NEWが正しく適用される
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 悪い例: チェック例外でロールバックされない
@Service
public class PaymentService {

    @Transactional
    public void processPayment(PaymentRequest request) throws PaymentException {
        paymentRepository.save(new Payment(request));
        
        // PaymentExceptionはチェック例外
        // この例外が発生してもトランザクションはコミットされる
        if (!validatePayment(request)) {
            throw new PaymentException("Payment validation failed");
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 良い例: rollbackForを明示的に指定
@Service
public class PaymentService {

    @Transactional(rollbackFor = PaymentException.class)
    public void processPayment(PaymentRequest request) throws PaymentException {
        paymentRepository.save(new Payment(request));
        
        if (!validatePayment(request)) {
            throw new PaymentException("Payment validation failed");
            // PaymentExceptionでもロールバックされる
        }
    }
}

// または全ての例外でロールバック
@Service
public class PaymentService {

    @Transactional(rollbackFor = Exception.class)
    public void processPayment(PaymentRequest request) throws PaymentException {
        // ...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 悪い例: トランザクション内で外部API呼び出し
@Service
public class OrderService {

    @Transactional
    public Order createOrderWithNotification(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));
        
        // 外部API呼び出し - レスポンスを待つ間DBコネクション占有
        notificationService.sendEmail(order.getCustomerEmail());
        
        // 外部サービス障害時にトランザクションも失敗
        inventoryService.callExternalInventoryApi(order.getItems());
        
        return order;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 良い例: トランザクション外で外部処理を実行
@Service
public class OrderService {

    private final ApplicationEventPublisher eventPublisher;

    @Transactional
    public Order createOrder(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));
        
        // トランザクション完了後にイベント発行
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
        
        return order;
    }
}

@Component
public class OrderEventListener {

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreated(OrderCreatedEvent event) {
        // トランザクション外で非同期実行
        notificationService.sendEmail(event.getOrder().getCustomerEmail());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 悪い例: 全てにSERIALIZABLEを設定
@Service
@Transactional(isolation = Isolation.SERIALIZABLE)
public class ProductService {
    
    // 単純な参照にSERIALIZABLEは過剰
    public Product findById(Long id) {
        return productRepository.findById(id).orElseThrow();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 良い例: 用途に応じた分離レベル
@Service
public class ProductService {
    
    // 参照系はREAD_COMMITTEDで十分
    @Transactional(readOnly = true, 
                   isolation = Isolation.READ_COMMITTED)
    public Product findById(Long id) {
        return productRepository.findById(id).orElseThrow();
    }
    
    // 厳密な整合性が必要な処理のみSERIALIZABLE
    @Transactional(isolation = Isolation.SERIALIZABLE)
    public void updateInventoryCount(Long productId, int count) {
        // ...
    }
}