Java分布式事务javax.activity异常处理完整指南

import javax.activity.ActivityCompletedException;
import javax.activity.ActivityRequiredException;
import javax.activity.InvalidActivityException;
import javax.transaction.*;

public class TransactionService {
    
    private UserTransaction userTransaction;
    
    public TransactionService() {
        // 在实际应用中，这通常通过依赖注入获取
        // userTransaction = ... 
    }
    
    /**
     * 执行业务操作，处理事务相关的异常
     */
    public void performBusinessOperation() {
        try {
            // 开始事务
            userTransaction.begin();
            
            // 执行业务逻辑
            executeBusinessLogic();
            
            // 提交事务
            userTransaction.commit();
            
        } catch (ActivityRequiredException e) {
            System.err.println("错误: 操作需要活动上下文: " + e.getMessage());
            rollbackTransaction();
            
        } catch (ActivityCompletedException e) {
            System.err.println("错误: 尝试在已完成的活动中操作: " + e.getMessage());
            rollbackTransaction();
            
        } catch (InvalidActivityException e) {
            System.err.println("错误: 无效的活动: " + e.getMessage());
            rollbackTransaction();
            
        } catch (Exception e) {
            System.err.println("其他错误: " + e.getMessage());
            rollbackTransaction();
        }
    }
    
    private void executeBusinessLogic() throws ActivityCompletedException {
        // 模拟业务逻辑
        boolean operationSuccessful = true;
        
        if (!operationSuccessful) {
            // 如果业务逻辑失败，可能抛出活动相关异常
            throw new ActivityCompletedException(
                "业务操作失败 - 活动已完成");
        }
        
        System.out.println("业务逻辑执行成功");
    }
    
    private void rollbackTransaction() {
        try {
            if (userTransaction != null) {
                userTransaction.rollback();
                System.out.println("事务已回滚");
            }
        } catch (SystemException e) {
            System.err.println("回滚事务时出错: " + e.getMessage());
        }
    }
    
    /**
     * 演示在需要活动上下文但没有活动时的情况
     */
    public void demonstrateActivityRequired() {
        try {
            // 模拟在没有活动上下文的情况下执行需要活动的操作
            throw new ActivityRequiredException(
                "此操作需要活动事务上下文");
            
        } catch (ActivityRequiredException e) {
            System.err.println("捕获 ActivityRequiredException: " + e.getMessage());
            // 在实际应用中，这里可能会开始一个新的事务
        }
    }
}

// 测试类
public class ActivityPackageDemo {
    public static void main(String[] args) {
        TransactionService service = new TransactionService();
        
        System.out.println("=== 演示 ActivityRequiredException ===");
        service.demonstrateActivityRequired();
        
        System.out.println("\n=== 执行业务操作 ===");
        service.performBusinessOperation();
    }
}

import javax.activity.*;
import javax.ejb.*;
import javax.persistence.*;
import javax.transaction.UserTransaction;

@Stateless
public class BankServiceBean {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    @Resource
    private UserTransaction userTransaction;
    
    /**
     * 转账业务方法
     */
    public void transferFunds(String fromAccount, String toAccount, double amount) 
            throws BankingException {
        
        try {
            // 检查事务状态
            if (userTransaction.getStatus() != Status.STATUS_ACTIVE) {
                throw new ActivityRequiredException("转账操作需要活动事务");
            }
            
            // 执行转账逻辑
            Account from = entityManager.find(Account.class, fromAccount);
            Account to = entityManager.find(Account.class, toAccount);
            
            if (from == null || to == null) {
                throw new InvalidActivityException("无效的账户信息");
            }
            
            if (from.getBalance() < amount) {
                throw new ActivityCompletedException("余额不足，交易无法完成");
            }
            
            // 更新余额
            from.setBalance(from.getBalance() - amount);
            to.setBalance(to.getBalance() + amount);
            
            entityManager.merge(from);
            entityManager.merge(to);
            
        } catch (ActivityRequiredException | ActivityCompletedException | 
                 InvalidActivityException e) {
            throw new BankingException("转账失败: " + e.getMessage(), e);
        } catch (Exception e) {
            throw new BankingException("系统错误: " + e.getMessage(), e);
        }
    }
}

// 自定义业务异常
class BankingException extends Exception {
    public BankingException(String message) {
        super(message);
    }
    
    public BankingException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 实体类
@Entity
class Account {
    @Id
    private String accountNumber;
    private double balance;
    
    // getters and setters
    public String getAccountNumber() { return accountNumber; }
    public void setAccountNumber(String accountNumber) { this.accountNumber = accountNumber; }
    public double getBalance() { return balance; }
    public void setBalance(double balance) { this.balance = balance; }
}