SpringBoot中Flowable多数据源配置及事务冲突的两种方案

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DbContextHolder.getCurrentDataSource();
    }
}

@Aspect
@Component
public class DataSourceAspect {
    @Before("execution(* org.flowable..*.*(..))")
    public void setFlowableDataSource() {
        DbContextHolder.setDataSource("flowable");
    }
    
    @Before("execution(* com.yourpackage.business..*.*(..))")
    public void setBusinessDataSource() {
        DbContextHolder.setDataSource("business");
    }
}

@Service
public class WorkflowService {
    @Autowired
    private TaskService taskService; // Flowable服务
    
    @Autowired
    private BusinessService businessService; // 业务服务
    
    @Transactional
    public void processWorkflow() {
        // 预期使用flowable数据源
        List<Task> tasks = taskService.createTaskQuery().list();
        
        // 预期使用business数据源
        List<BusinessEntity> entities = businessService.findAll();
    }
}

@Service
public class WorkflowService {
    @Transactional
    public void mainProcess() {
        // 使用主数据源
        flowableOperation();
        
        // 开启新事务，使用业务数据源
        businessOperationInNewTx();
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void businessOperationInNewTx() {
        // 业务数据操作
    }
}

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public List<BusinessEntity> getBusinessData() {
    // 此方法执行时不支持当前事务，会暂停现有事务
    return businessRepository.findAll();
}

public class MultiDataSourceTransaction implements Transaction {
    private final DataSource dataSource;
    private Connection mainConnection;
    private Map<String, Connection> otherConnections = new ConcurrentHashMap<>();
    
    public MultiDataSourceTransaction(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    @Override
    public Connection getConnection() throws SQLException {
        String currentDataSource = DbContextHolder.getCurrentDataSource();
        if (currentDataSource.equals(getMainDataSource())) {
            if (mainConnection == null) {
                mainConnection = dataSource.getConnection();
            }
            return mainConnection;
        } else {
            return otherConnections.computeIfAbsent(currentDataSource, 
                key -> fetchConnectionForDataSource(key));
        }
    }
    
    // 其他必要方法实现...
}

public class MultiDataSourceTransactionFactory extends SpringManagedTransactionFactory {
    @Override
    public Transaction newTransaction(DataSource dataSource, 
            TransactionIsolationLevel level, boolean autoCommit) {
        return new MultiDataSourceTransaction(dataSource);
    }
}

@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setTransactionFactory(new MultiDataSourceTransactionFactory());
    return factory;
}

public class OrderWorkflowService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private RuntimeService runtimeService;
    
    @Transactional
    public void createOrder(Order order) {
        // 保存订单到业务数据库
        orderRepository.save(order);
        
        // 启动工作流
        startWorkflow(order);
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    private void startWorkflow(Order order) {
        Map<String, Object> variables = new HashMap<>();
        variables.put("orderId", order.getId());
        runtimeService.startProcessInstanceByKey("orderApproval", variables);
    }
}