Spring | 事务原理与实践 - 声明式事务及编程式事务

    @Autowired
    private TransactionTemplate transactionTemplate;

    @Autowired
    public MyService(PlatformTransactionManager transactionManager, MyRepository myRepository) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
        this.myRepository = myRepository;

        // 定制事务属性
        this.transactionTemplate.setPropagationBehavior(Propagation.REQUIRES_NEW.value());
        this.transactionTemplate.setIsolationLevel(Isolation.DEFAULT.value());
        this.transactionTemplate.setTimeout(30); // 设置超时时间，单位为秒
    }

    // 编程式事务管理实现
    public void createEntityByTemplate(MyEntity myEntity) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                myRepository.save(myEntity);
            }
        });
    }

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void createEntityByTransactionManager(MyEntity myEntity) {
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            myRepository.save(myEntity);
            transactionManager.commit(status);
        } catch (DataAccessException e) {
            transactionManager.rollback(status);
            throw e;
        }
    }

    @Transactional(transactionManager = "transactionManagerOne",propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 30)
    public void createEntity(MyEntity myEntity) {
        myRepository.save(myEntity);
    }

// 示例：使用Java Reflection API中的Proxy.newProxyInstance方法来创建代理对象
MyService proxy = (MyService) Proxy.newProxyInstance(
    MyServiceImpl.class.getClassLoader(),
    MyServiceImpl.class.getInterfaces(),
    new MyInvocationHandler(new MyServiceImpl()));

// 示例：使用CGLIB的Enhancer类来创建目标类的子类作为代理对象
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(MyServiceImpl.class);
enhancer.setCallback(new MethodInterceptorImpl());
MyServiceImpl proxy = (MyServiceImpl) enhancer.create();

// 示例：获取事务状态并执行事务
DefaultTransactionStatus status = (DefaultTransactionStatus) transactionManager.getTransaction(new DefaultTransactionDefinition());

try {
  // 执行业务逻辑
  // ...
  // 提交事务
  transactionManager.commit(status);
} catch (Exception ex) {
  // 发生异常，回滚事务
  transactionManager.rollback(status);
  throw ex;
}

// 示例：注册事务同步
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
  @Override
  public void afterCommit() {
    // 在事务提交后执行的逻辑
  }
});

// 示例：使用NESTED传播属性创建嵌套事务
@Transactional(propagation = Propagation.NESTED)
public void nestedTransactionMethod() {
  // 执行业务逻辑
}

// 示例：使用两阶段提交(2PC)来协调分布式事务
// Service 1
@Transactional
public void service1Method() {
  // 执行业务逻辑
  // ...
  // 第一阶段：预提交
  // 第二阶段：提交
}

// Service 2
@Transactional
public void service2Method() {
  // 执行业务逻辑
  // ...
  // 第一阶段：预提交
  // 第二阶段：提交
}

// 示例：处理长事务
@Transactional(isolation = Isolation.SERIALIZABLE, timeout = 1200)
public void longTransactionMethod() {
  // 执行业务逻辑
  // ...
}

// 示例：配置事务隔离级别
@Transactional(isolation = Isolation.REPEATABLE_READ)
public void transactionalMethod() {
  // 执行业务逻辑
}

// 示例：配置事务传播行为
@Transactional(propagation = Propagation.REQUIRED)
public void transactionalMethod() {
  // 执行业务逻辑
}

// 示例：配置只读事务
@Transactional(readOnly = true)
public void transactionalMethod() {
  // 执行业务逻辑
}

// 示例：配置事务超时时间
@Transactional(timeout = 300)
public void transactionalMethod() {
  // 执行业务逻辑
}

// 示例：配置适合高并发场景的事务属性
@Transactional(isolation = Isolation.READ_COMMITTED, timeout = 100)
public void highConcurrencyMethod() {
  // 执行业务逻辑
}

// 示例：配置适合数据一致性要求高场景的事务属性
@Transactional(isolation = Isolation.SERIALIZABLE)
public void highConsistencyMethod() {
  // 执行业务逻辑
}

// 示例：选择合适的事务边界
@Transactional
public void serviceMethod() {
  // 事务开始
  try {
    // 执行核心业务逻辑
    coreBusinessLogic();
  } catch (Exception e) {
    // 业务异常处理
    handleBusinessException(e);
  }
  // 事务结束
}

// 示例：合理配置事务属性
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED, timeout = 200)
public void serviceMethod() {
  // 执行业务逻辑
}

// 示例：2PC分布式事务实现
public class DistributedTransactionService {

  @Transactional
  public void prepare() {
    // 准备阶段的业务逻辑
  }

  @Transactional
  public void commit() {
    // 提交阶段的业务逻辑
  }
}

// 示例：Saga分布式事务实现
public class PaymentService {

  @Transactional
  public void debit() {
    // 扣款逻辑
  }

  @Transactional
  public void refund() {
    // 退款逻辑
  }
}

// 示例：状态机与延迟队列实现长事务和延迟确认
public class OrderService {

  @Transactional
  public void createOrder() {
    // 创建订单，并将订单状态设为待支付
  }

  @Transactional
  public void confirmPayment() {
    // 收到支付确认后，将订单状态设为已支付
  }
}

@Service
public class TransactionalService {
    
    @Autowired
    private MyRepository myRepository;
    
    // 正确：@Transactional注解在public方法上
    @Transactional
    public void correctTransactionalMethod() {
        myRepository.save(new MyEntity());
    }
    
    // 错误：@Transactional注解在protected方法上，事务将不会生效
    @Transactional
    protected void incorrectTransactionalMethod() {
        myRepository.save(new MyEntity());
    }
}

@Service
public class SelfInvocationService {

    @Autowired
    private TransactionalService transactionalService;

    public void method() {
        // 正确：非事务方法调用另一个Bean的事务方法
        transactionalService.correctTransactionalMethod();
    }
    
    // 这个方法为事务方法，如果被上面的非事务方法直接调用，事务会失效
    @Transactional
    public void anotherTransactionalMethod() {
        // ... your business logic ...
    }
}

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mydb?useSSL=false&useUnicode=yes&characterEncoding=UTF-8&serverTimezone=UTC
    username: myuser
    password: mypass

@Configuration
@EnableTransactionManagement
public class DatabaseConfig {

    @Bean
    public DataSource dataSource() {
        return new DriverManagerDataSource(
                "jdbc:mysql://localhost:3306/mydb",
                "myuser",
                "mypass"
        );
    }
    
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}