atomikos 使用说明_com.atomikos.icatch.default_jta_timeout

作者：盐析白兔 | 2024-04-01 01:56:16

踩

com.atomikos.icatch.default_jta_timeout

atomikos 使用说明

atomikos使用两阶段协议实现事务操作，常用于单机多库事务

**********************

引入jar包


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jta-atomikos</artifactId>
    <version>2.2.2.RELEASE</version>
</dependency>

**********************

自动配置类

JtaAutoConfiguration：jta自动配置类


@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({Transaction.class})
@ConditionalOnProperty(
    prefix = "spring.jta",
    value = {"enabled"},
    matchIfMissing = true
)
@AutoConfigureBefore({XADataSourceAutoConfiguration.class, ActiveMQAutoConfiguration.class, ArtemisAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
@Import({JndiJtaConfiguration.class, BitronixJtaConfiguration.class, AtomikosJtaConfiguration.class})
public class JtaAutoConfiguration {
    public JtaAutoConfiguration() {
    }
}

AtomikosJtaConfiguration：atomikos自动配置类


@Configuration(
    proxyBeanMethods = false
)
@EnableConfigurationProperties({AtomikosProperties.class, JtaProperties.class})
@ConditionalOnClass({JtaTransactionManager.class, UserTransactionManager.class})
@ConditionalOnMissingBean({PlatformTransactionManager.class})
class AtomikosJtaConfiguration {
    AtomikosJtaConfiguration() {
    }
 
    @Bean(
        initMethod = "init",
        destroyMethod = "close"
    )
    @ConditionalOnMissingBean({TransactionManager.class})
    UserTransactionManager atomikosTransactionManager(UserTransactionService userTransactionService) throws Exception {
        UserTransactionManager manager = new UserTransactionManager();
        manager.setStartupTransactionService(false);
        manager.setForceShutdown(true);
        return manager;
    }//transactionmanager不存在则创建userTransactionManager实例
 
    @Bean
    JtaTransactionManager transactionManager(UserTransaction userTransaction, TransactionManager transactionManager, ObjectProvider<TransactionManagerCustomizers> transactionManagerCustomizers) {
        JtaTransactionManager jtaTransactionManager = new JtaTransactionManager(userTransaction, transactionManager);
        transactionManagerCustomizers.ifAvailable((customizers) -> {
            customizers.customize(jtaTransactionManager);
        });
        return jtaTransactionManager;
    }//platformTransactionManager实例不存在则创建jtaTransactionManager实例
 
    。。。。
}

**********************

配置类

AtomikosProperties：atomikos属性配置参数


@ConfigurationProperties(
    prefix = "spring.jta.atomikos.properties"
)
public class AtomikosProperties {
    private String service;
    private Duration maxTimeout = Duration.ofMillis(300000L);
    private Duration defaultJtaTimeout = Duration.ofMillis(10000L);
    private int maxActives = 50;
    private boolean enableLogging = true;
    private String transactionManagerUniqueName;
    private boolean serialJtaTransactions = true;
    private boolean allowSubTransactions = true;
    private boolean forceShutdownOnVmExit;
    private long defaultMaxWaitTimeOnShutdown = 9223372036854775807L;
    private String logBaseName = "tmlog";
    private String logBaseDir;
    private long checkpointInterval = 500L;
    private boolean threadedTwoPhaseCommit;
    private final AtomikosProperties.Recovery recovery = new AtomikosProperties.Recovery();
 
    public AtomikosProperties() {
    }

AtomikosDataSourceBean ：数据源配置参数


@ConfigurationProperties(
    prefix = "spring.jta.atomikos.datasource"
)
public class AtomikosDataSourceBean extends com.atomikos.jdbc.AtomikosDataSourceBean implements BeanNameAware, InitializingBean, DisposableBean {
 
 
public class AtomikosDataSourceBean extends AbstractDataSourceBean {
 
 
***********************************
基础类AbstractDataSourceBean
 
public abstract class AbstractDataSourceBean implements DataSource, ConnectionPoolProperties, Referenceable, Serializable {
    private static final Logger LOGGER = LoggerFactory.createLogger(AbstractDataSourceBean.class);
    static final int DEFAULT_ISOLATION_LEVEL_UNSET = -1;
    private static final int DEFAULT_POOL_SIZE = 1;
    private int minPoolSize = 1;
    private int maxPoolSize = 1;
    private int borrowConnectionTimeout = 30;
    private int reapTimeout = 0;
    private int maxIdleTime = 60;
    private String testQuery;
    private int maintenanceInterval = 60;
    private int loginTimeout;
    private transient ConnectionPool connectionPool;
    private transient PrintWriter logWriter;
    private String resourceName;
    private int defaultIsolationLevel = -1;
    private int maxLifetime;
    private boolean enableConcurrentConnectionValidation = true;

AtomikosConnectionFactoryBean：连接工厂配置参数


@ConfigurationProperties(
    prefix = "spring.jta.atomikos.connectionfactory"
)
public class AtomikosConnectionFactoryBean extends com.atomikos.jms.AtomikosConnectionFactoryBean implements BeanNameAware, InitializingBean, DisposableBean {
    private String beanName;
 
    public AtomikosConnectionFactoryBean() {
    }
 
****************************************
AtomikosConnectionFactoryBean：基础类
 
public class AtomikosConnectionFactoryBean implements ConnectionFactory, ConnectionPoolProperties, Referenceable, Serializable {
    private static final Logger LOGGER = LoggerFactory.createLogger(AtomikosConnectionFactoryBean.class);
    private static final long serialVersionUID = 1L;
    private String uniqueResourceName;
    private int maxPoolSize = 1;
    private int minPoolSize = 1;
    private String xaConnectionFactoryClassName;
    private int borrowConnectionTimeout = 30;
    private Properties xaProperties = null;
    private transient ConnectionPool connectionPool;
    private transient XAConnectionFactory xaConnectionFactory;
    private int maintenanceInterval = 60;
    private int maxIdleTime = 60;
    private int reapTimeout = 0;
    private boolean localTransactionMode;
    private int maxLifetime;
    private boolean ignoreSessionTransactedFlag = true;
 
    public AtomikosConnectionFactoryBean() {
        this.xaProperties = new Properties();
    }

transactions-default.properties：atomikos全局默认配置


com.atomikos.icatch.enable_logging=true               //是否启动日志记录
com.atomikos.icatch.log_base_dir=./                     //日记记录位置
com.atomikos.icatch.log_base_name=tmlog                 //事务日志前缀
com.atomikos.icatch.checkpoint_interval=500             //刷盘的时间间隔
com.atomikos.icatch.forget_orphaned_log_entries_delay=86400000
                                                        //事务日志的保存时间
 
com.atomikos.icatch.force_shutdown_on_vm_exit=false   //虚拟机关闭是是否强制关闭
com.atomikos.icatch.automatic_resource_registration=true //说否自动注册资源管理器
com.atomikos.icatch.serial_jta_transactions=true        //序列化jta事务管理器
com.atomikos.icatch.default_jta_timeout=10000           //默认超时时间
com.atomikos.icatch.max_timeout=300000                  //最大超时时间
com.atomikos.icatch.threaded_2pc=false                  //2阶段提交事务时是否使用多线程
com.atomikos.icatch.max_actives=50                      //同时使用的事务数量
java.naming.factory.initial=com.sun.jndi.rmi.registry.RegistryContextFactory
com.atomikos.icatch.client_demarcation=false
java.naming.provider.url=rmi://localhost:1099
com.atomikos.icatch.rmi_export_class=none
com.atomikos.icatch.trust_client_tm=false
com.atomikos.icatch.recovery_delay=${com.atomikos.icatch.default_jta_timeout}
                                                          //事务恢复之间的时间间隔
com.atomikos.icatch.oltp_max_retries=5                    //事务失败重试次数
com.atomikos.icatch.oltp_retry_interval=10000             //事务重试间隔
com.atomikos.icatch.allow_subtransactions=true            //是否支持子事务
com.atomikos.icatch.default_max_wait_time_on_shutdown=9223372036854775807
                                                          //虚拟机正常关闭事务等待时间

说明：可在多个位置设置配置文件transactions-default.properties 、 transactions.properties、jta.properties、命令行指定文件路径（java -Dcom.atomikos.icatch.file），越往后优先级最高

**********************

相关类

DruidXADataSource：druid数据源


public class DruidXADataSource extends DruidDataSource implements XADataSource {
    private static final Log LOG = LogFactory.getLog(DruidXADataSource.class);
    private static final long serialVersionUID = 1L;
    private Object h2Factory = null;
 
    public DruidXADataSource() {
    }

AtomikosDataSourceBean：atomikos数据源


@ConfigurationProperties(
    prefix = "spring.jta.atomikos.datasource"
)
public class AtomikosDataSourceBean extends com.atomikos.jdbc.AtomikosDataSourceBean implements BeanNameAware, InitializingBean, DisposableBean {
    private String beanName;
 
    public AtomikosDataSourceBean() {
    }
 
    public void setBeanName(String name) {
        this.beanName = name;
    }
 
    public void afterPropertiesSet() throws Exception {
        if (!StringUtils.hasLength(this.getUniqueResourceName())) {
            this.setUniqueResourceName(this.beanName);
        }
 
        this.init();
    }
 
    public void destroy() throws Exception {
        this.close();
    }
}
 
**********************************
AtomikosDataSourceBean
 
public class AtomikosDataSourceBean extends AbstractDataSourceBean {
    private static final Logger LOGGER = LoggerFactory.createLogger(AtomikosDataSourceBean.class);
    private static final long serialVersionUID = 1L;
    private Properties xaProperties = null;
    private String xaDataSourceClassName;
    private transient XADataSource xaDataSource;
 
    public AtomikosDataSourceBean() {
        this.xaProperties = new Properties();
    }
 
    public void setXaDataSource(XADataSource xaDataSource) {
        this.xaDataSource = xaDataSource;
    }//设置xa事务源
 
   。。。。
}

UserTransaction：用户事务操作


public interface UserTransaction {
    void begin() throws NotSupportedException, SystemException;
 
    void commit() throws RollbackException, HeuristicMixedException, HeuristicRollbackException, SecurityException, IllegalStateException, SystemException;
 
    void rollback() throws IllegalStateException, SecurityException, SystemException;
 
    void setRollbackOnly() throws IllegalStateException, SystemException;
 
    int getStatus() throws SystemException;
 
    void setTransactionTimeout(int var1) throws SystemException;
}

UserTransactionManager：用户事务管理器


public class UserTransactionManager implements TransactionManager, Serializable, Referenceable, UserTransaction {
    private static final long serialVersionUID = -655789038710288096L;
    private transient TransactionManagerImp tm;
    private boolean forceShutdown;
    private boolean startupTransactionService = true;
    private boolean closed = false;
    private boolean coreStartedHere;
 
    public UserTransactionManager() {
    }

JtaTransactionManager：全局事务管理器


public class JtaTransactionManager extends AbstractPlatformTransactionManager implements TransactionFactory, InitializingBean, Serializable {
    public static final String DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction";
    public static final String[] FALLBACK_TRANSACTION_MANAGER_NAMES = new String[]{"java:comp/TransactionManager", "java:appserver/TransactionManager", "java:pm/TransactionManager", "java:/TransactionManager"};
    public static final String DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry";
    private transient JndiTemplate jndiTemplate;
    @Nullable
    private transient UserTransaction userTransaction;
    @Nullable
    private String userTransactionName;            //用户事务名称
    private boolean autodetectUserTransaction;
    private boolean cacheUserTransaction;          //是否缓存用户事务
    private boolean userTransactionObtainedFromJndi;
    @Nullable
    private transient TransactionManager transactionManager; //用户事务管理器
    @Nullable
    private String transactionManagerName;         //用户事务管理器名称
    private boolean autodetectTransactionManager;
    @Nullable
    private transient TransactionSynchronizationRegistry transactionSynchronizationRegistry;
    @Nullable
    private String transactionSynchronizationRegistryName;
    private boolean autodetectTransactionSynchronizationRegistry;
    private boolean allowCustomIsolationLevels;
 
    public JtaTransactionManager() {
        this.jndiTemplate = new JndiTemplate();
        this.autodetectUserTransaction = true;
        this.cacheUserTransaction = true;
        this.userTransactionObtainedFromJndi = false;
        this.autodetectTransactionManager = true;
        this.autodetectTransactionSynchronizationRegistry = true;
        this.allowCustomIsolationLevels = false;
        this.setNestedTransactionAllowed(true);
    }
 
    public JtaTransactionManager(UserTransaction userTransaction) {
    public JtaTransactionManager(UserTransaction userTransaction, TransactionManager transactionManager) {
    public JtaTransactionManager(TransactionManager transactionManager) {

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】