Spring Boot 3集成Atomikos：JMS与JPA事务配置指导请求

一、依赖配置 #

首先引入适配Spring Boot 3的Atomikos starter，同时确保项目已引入JPA、JMS相关基础依赖：

<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-spring-boot3-starter</artifactId>
    <version>6.0.109</version>
</dependency>

二、核心配置类编写 #

1. JPA 分布式事务数据源配置 #

import com.atomikos.jdbc.AtomikosDataSourceBean;
import jakarta.persistence.EntityManagerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
public class JpaAtomikosConfig {

    @Bean
    public DataSource jpaDataSource() {
        AtomikosDataSourceBean dataSource = new AtomikosDataSourceBean();
        dataSource.setUniqueResourceName("jpa-db-resource");
        dataSource.setXaDataSourceClassName("com.mysql.cj.jdbc.MysqlXADataSource");
        
        Properties xaProps = new Properties();
        xaProps.put("url", "jdbc:mysql://localhost:3306/test_db?useSSL=false");
        xaProps.put("user", "root");
        xaProps.put("password", "password");
        dataSource.setXaProperties(xaProps);
        
        dataSource.setMaxPoolSize(10);
        dataSource.setMinPoolSize(2);
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource jpaDataSource) {
        LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
        emf.setDataSource(jpaDataSource);
        emf.setPackagesToScan("com.yourpackage.entity");
        emf.setPersistenceUnitName("jpa-persistence-unit");
        emf.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        
        Properties jpaProps = new Properties();
        jpaProps.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        jpaProps.put("hibernate.show_sql", "true");
        jpaProps.put("hibernate.transaction.jta.platform", "com.atomikos.hibernate4.AtomikosPlatform");
        jpaProps.put("javax.persistence.transactionType", "JTA");
        emf.setJpaProperties(jpaProps);
        
        return emf;
    }
}

2. JMS 分布式事务连接工厂配置 #

import com.atomikos.jms.AtomikosConnectionFactoryBean;
import jakarta.jms.ConnectionFactory;
import org.apache.activemq.artemis.jms.client.ActiveMQXAConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.core.JmsTemplate;

@Configuration
public class JmsAtomikosConfig {

    @Bean
    public ConnectionFactory jmsConnectionFactory() {
        ActiveMQXAConnectionFactory xaConnectionFactory = new ActiveMQXAConnectionFactory();
        xaConnectionFactory.setBrokerURL("tcp://localhost:61616");
        xaConnectionFactory.setUser("admin");
        xaConnectionFactory.setPassword("admin");

        AtomikosConnectionFactoryBean atomikosConnFactory = new AtomikosConnectionFactoryBean();
        atomikosConnFactory.setUniqueResourceName("jms-resource");
        atomikosConnFactory.setXaConnectionFactory(xaConnectionFactory);
        atomikosConnFactory.setMaxPoolSize(10);
        return atomikosConnFactory;
    }

    @Bean
    public JmsTemplate jmsTemplate(ConnectionFactory jmsConnectionFactory) {
        JmsTemplate jmsTemplate = new JmsTemplate();
        jmsTemplate.setConnectionFactory(jmsConnectionFactory);
        jmsTemplate.setSessionTransacted(true);
        return jmsTemplate;
    }
}

3. 分布式事务管理器配置 #

import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import jakarta.transaction.UserTransaction;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.jta.JtaTransactionManager;

@Configuration
public class AtomikosTransactionConfig {

    @Bean
    public UserTransaction userTransaction() throws SystemException {
        UserTransactionImp userTransaction = new UserTransactionImp();
        userTransaction.setTransactionTimeout(300);
        return userTransaction;
    }

    @Bean
    public UserTransactionManager atomikosTransactionManager() {
        UserTransactionManager transactionManager = new UserTransactionManager();
        transactionManager.setForceShutdown(false);
        return transactionManager;
    }

    @Bean
    public PlatformTransactionManager transactionManager(UserTransaction userTransaction, UserTransactionManager atomikosTransactionManager) {
        return new JtaTransactionManager(userTransaction, atomikosTransactionManager);
    }
}

三、事务启用与业务使用 #

1. 在Spring Boot启动类添加@EnableTransactionManagement注解开启事务支持。
2. 在业务方法上添加@Transactional注解，确保JPA和JMS操作纳入同一分布式事务：

import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BizService {

    private final YourJpaRepository jpaRepository;
    private final JmsTemplate jmsTemplate;

    public BizService(YourJpaRepository jpaRepository, JmsTemplate jmsTemplate) {
        this.jpaRepository = jpaRepository;
        this.jmsTemplate = jmsTemplate;
    }

    @Transactional
    public void doBizOperation(YourEntity entity, String message) {
        jpaRepository.save(entity);
        jmsTemplate.convertAndSend("your-queue", message);
        // 任意一步失败，整个事务回滚
    }
}

四、注意事项 #

• 确保数据库支持XA事务（如MySQL需开启XA特性）。
• JMS Broker必须提供XA连接工厂（如ActiveMQ Artemis）。
• 所有分布式事务资源需配置唯一uniqueResourceName，供Atomikos识别区分。

内容的提问来源于stack exchange，提问作者simyaci