Atomikos 中文说明文档（周枫翻译）
Atomikos 翻译文档（英文文档来源：下载安装包中START_HERE.html）
----译者：周枫
请尊重劳动成果，转载请标明，英语水平有限，如有不准确地方请在评论中指出，谢谢
官网地址：http://www.atomikos.com/Main/WebHome
使用版本：AtomikosTransactionsEssentials-3.7.2
感谢您使用Atomikos，下面的说明文档可以让您正确使用，如果您有任何问题或者反馈，请访问我们的帮助网页http://www.atomikos.com/Main/SupportOverview，或者给我们发送邮件[email protected]。
什么是Atomikos TransactionsEssentials
Atomikos TransactionsEssentials 是一个为Java平台提供增值服务的并且开源类事务管理器，以下是包括在这个开源版本中的一些功能：
l 全面崩溃 / 重启恢复
l 兼容标准的SUN公司JTA API
l 嵌套事务
l 为XA和非XA提供内置的JDBC适配器
注释：XA：XA协议由Tuxedo首先提出的，并交给X/Open组织，作为资源管理器（数据库）与事务管理器的接口标准。目前，Oracle、Informix、DB2和Sybase等各大数据库厂家都提供对XA的支持。XA协议采用两阶段提交方式来管理分布式事务。XA接口提供资源管理器与事务管理器之间进行通信的标准接口。XA协议包括两套函数，以xa_开头的及以ax_开头的。
以下的函数使事务管理器可以对资源管理器进行的操作：
1）xa_open,xa_close：建立和关闭与资源管理器的连接。
2）xa_start,xa_end：开始和结束一个本地事务。
3）xa_prepare,xa_commit,xa_rollback：预提交、提交和回滚一个本地事务。
4）xa_recover：回滚一个已进行预提交的事务。
5）ax_开头的函数使资源管理器可以动态地在事务管理器中进行注册，并可以对XID(TRANSACTION IDS)进行操作。
6）ax_reg,ax_unreg；允许一个资源管理器在一个TMS(TRANSACTION MANAGER SERVER)中动态注册或撤消注册。
l 内置的JMS适配器XA-capable JMS队列连接器
注释：JMS:jms即Java消息服务（Java Message Service）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。
l 通过XA API兼容第三方适配器
l 更好的整合您的项目
l 集成Hibernate
如何使用Atomikos TransactionsEssentials
Atomikos TransactionsEssentials 是一个可靠的库，可以加入到您的Java应用程序，也就是说为了使用这个产品，您必须添加一些jar文件（包括在dist和lib文件夹下）到您的应用程序或者应用程序服务器。
请注意：Atomikos TransactionsEssentials是一个非常快速的嵌入式事务管理器，这就意味着，您不需要另外启动一个单独的事务管理器进程（不要查找任何的bin文件夹）。相反，您的应用服务器将有它自己的intra-VM事务管理器。
配置需求：至少Java1.5 jdk，并且最少128M的内存
性能优化：尽管这个软件有着很大的优势，但是想要更好的发挥其作用，可以按以下的方法优化：
l 更高的内存，意味着更高的吞吐量（每秒的事务数目）
l 使连接池尽可能的大
l 一旦你不需要的连接请马上关闭它们。不要把你的应用程序放在缓存里，让内部连接池为你做这些，这将促使更高效的连接使用
l 不要让活动的事务闲置：终止所有情况下的事务，尤其是在异常报错情况下的事务。这将减少数据库的锁定时间，并且最大效率的处理启用的使用。
如果想获取这些细节的更多信息，也要参阅文档说明部分。
值得注意的是，在我们所有的压力测试中，Atomikos TransactionsEssentials比J2EE的web容器更高效的吞吐量。这些测量值包括日志记录的高效的事务状态，同样，在我们所有的测量中，包括XA和non-XA，高效的效率是一样的。
在J2SE中使用Atomikos Transactions Essentials,只需要按以下步骤
- 将idst和lib中的jar包全部放入的项目中
- 创建或者自定义你应用的transactions.properties（或者jta.properties）文件（事务管理器的配置），然后将它放入到classpath中，安装文件夹中包涵一个实例文件；在properties文件中注释(#)后面的是默认值，取消一行并且改变默认值。
# SAMPLE PROPERTIES FILE FOR THE TRANSACTION SERVICE # THIS FILE ILLUSTRATES THE DIFFERENT SETTINGS FOR THE TRANSACTION MANAGER # UNCOMMENT THE ASSIGNMENTS TO OVERRIDE DEFAULT VALUES; # Required: factory implementation class of the transaction core. # NOTE: there is no default for this, so it MUST be specified! # com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory # Set base name of file where messages are output # (also known as the 'console file'). # # com.atomikos.icatch.console_file_name = tm.out # Size limit (in bytes) for the console file; # negative means unlimited. # # com.atomikos.icatch.console_file_limit=-1 # For size-limited console files, this option # specifies a number of rotating files to # maintain. # # com.atomikos.icatch.console_file_count=1 # Set the number of log writes between checkpoints # # com.atomikos.icatch.checkpoint_interval=500 # Set output directory where console file and other files are to be put # make sure this directory exists! # # com.atomikos.icatch.output_dir = ./ # Set directory of log files; make sure this directory exists! # # com.atomikos.icatch.log_base_dir = ./ # Set base name of log file # this name will be used as the first part of # the system-generated log file name # # com.atomikos.icatch.log_base_name = tmlog # Set the max number of active local transactions # or -1 for unlimited. # # com.atomikos.icatch.max_actives = 50 # Set the default timeout (in milliseconds) for local transactions # # com.atomikos.icatch.default_jta_timeout = 10000 # Set the max timeout (in milliseconds) for local transactions # # com.atomikos.icatch.max_timeout = 300000 # The globally unique name of this transaction manager process # override this value with a globally unique name # # com.atomikos.icatch.tm_unique_name = tm # Do we want to use parallel subtransactions? JTA's default # is NO for J2EE compatibility # # com.atomikos.icatch.serial_jta_transactions=true # If you want to do explicit resource registration then # you need to set this value to false. # # com.atomikos.icatch.automatic_resource_registration=true # Set this to WARN, INFO or DEBUG to control the granularity # of output to the console file. # # com.atomikos.icatch.console_log_level=WARN # Do you want transaction logging to be enabled or not? # If set to false, then no logging overhead will be done # at the risk of losing data after restart or crash. # # com.atomikos.icatch.enable_logging=true # Should two-phase commit be done in (multi-)threaded mode or not? # Set this to false if you want commits to be ordered according # to the order in which resources are added to the transaction. # # NOTE: threads are reused on JDK 1.5 or higher. # For JDK 1.4, thread reuse is enabled as soon as the # concurrent backport is in the classpath - see # http://mirrors.ibiblio.org/pub/mirrors/maven2/backport-util-concurrent/backport-util-concurrent/ # # com.atomikos.icatch.threaded_2pc=false # Should shutdown of the VM trigger shutdown of the transaction core too? # # com.atomikos.icatch.force_shutdown_on_vm_exit=false - 在你的应用程序中，创建一个实例com.atomikos.icatch.jta.UserTransactionImp或者com.atomikos.icatch.jta.UserTransactionManager（使用默认的无参数构造函数）
/** * Copyright (C) 2000-2010 Atomikos <[email protected]> * * This code ("Atomikos TransactionsEssentials"), by itself, * is being distributed under the * Apache License, Version 2.0 ("License"), a copy of which may be found at * http://www.atomikos.com/licenses/apache-license-2.0.txt . * You may not use this file except in compliance with the License. * * While the License grants certain patent license rights, * those patent license rights only extend to the use of * Atomikos TransactionsEssentials by itself. * * This code (Atomikos TransactionsEssentials) contains certain interfaces * in package (namespace) com.atomikos.icatch * (including com.atomikos.icatch.Participant) which, if implemented, may * infringe one or more patents held by Atomikos. * It should be appreciated that you may NOT implement such interfaces; * licensing to implement these interfaces must be obtained separately from Atomikos. * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ package com.atomikos.icatch.jta; import java.io.Serializable; import javax.naming.NamingException; import javax.naming.Reference; import javax.naming.Referenceable; import javax.transaction.NotSupportedException; import javax.transaction.SystemException; import javax.transaction.TransactionManager; import javax.transaction.UserTransaction; import com.atomikos.icatch.admin.imp.SimpleLogAdministrator; import com.atomikos.icatch.config.TSInitInfo; import com.atomikos.icatch.config.UserTransactionService; import com.atomikos.icatch.config.UserTransactionServiceImp; import com.atomikos.util.SerializableObjectFactory; /** * * * Our UserTransaction implementation for J2SE transactions. This class is * special in that it automatically starts up and recover the transaction * service on first use. <b>Note: don't use this class in J2EE applications in * order to avoid starting different transaction engines in the same application * server! J2EE applications should use J2eeUserTransaction instead.</b> */ public class UserTransactionImp implements UserTransaction, Serializable, Referenceable { private transient TransactionManager txmgr_; /** * No-argument constructor. */ public UserTransactionImp () { } /** * Referenceable mechanism requires later setup of txmgr_, otherwise binding * into JNDI already requires that TM is running. */ private void checkSetup () { // REMOVED FOLLOWING IF CHECK: DON'T CACHE THE TXMGR TO MAKE INSTANCES // RESILIENT TO RESTART IN TOMCAT. OTHERWISE, CLIENT APPS SEE THEIR // USERTX REFERENCES INVALIDATED AND THIS IS INTOLERABLE // if ( txmgr_ == null ) { // txmgr_ = TransactionManagerImp.getTransactionManager(); synchronized ( TransactionManagerImp.class ) { txmgr_ = TransactionManagerImp.getTransactionManager (); // FOLLOWING COMMENTED OUT: NEW RECOVERY IN 2.0 ALLOWS US TO START // THE TM // IF NOT ALREADY RUNNING!!! // if ( txmgr_ == null ) // throw new RuntimeException ( "No transaction monitor installed?" // ); // NEW FROM 2.0: if TM is not running, just start it. Any resources // can be registered later. if ( txmgr_ == null ) { UserTransactionService uts = new UserTransactionServiceImp (); TSInitInfo info = uts.createTSInitInfo (); uts.registerLogAdministrator ( SimpleLogAdministrator .getInstance () ); uts.init ( info ); txmgr_ = TransactionManagerImp.getTransactionManager (); } } // } } /** * @see javax.transaction.UserTransaction */ public void begin () throws NotSupportedException, SystemException { checkSetup (); txmgr_.begin (); } /** * @see javax.transaction.UserTransaction */ public void commit () throws javax.transaction.RollbackException, javax.transaction.HeuristicMixedException, javax.transaction.HeuristicRollbackException, javax.transaction.SystemException, java.lang.IllegalStateException, java.lang.SecurityException { checkSetup (); txmgr_.commit (); } /** * @see javax.transaction.UserTransaction */ public void rollback () throws IllegalStateException, SystemException, SecurityException { checkSetup (); txmgr_.rollback (); } /** * @see javax.transaction.UserTransaction */ public void setRollbackOnly () throws IllegalStateException, SystemException { checkSetup (); txmgr_.setRollbackOnly (); } /** * @see javax.transaction.UserTransaction */ public int getStatus () throws SystemException { checkSetup (); return txmgr_.getStatus (); } /** * @see javax.transaction.UserTransaction */ public void setTransactionTimeout ( int seconds ) throws SystemException { checkSetup (); txmgr_.setTransactionTimeout ( seconds ); } // // // IMPLEMENTATION OF REFERENCEABLE // // public Reference getReference () throws NamingException { return SerializableObjectFactory.createReference ( this ); } }
/** * Copyright (C) 2000-2010 Atomikos <[email protected]> * * This code ("Atomikos TransactionsEssentials"), by itself, * is being distributed under the * Apache License, Version 2.0 ("License"), a copy of which may be found at * http://www.atomikos.com/licenses/apache-license-2.0.txt . * You may not use this file except in compliance with the License. * * While the License grants certain patent license rights, * those patent license rights only extend to the use of * Atomikos TransactionsEssentials by itself. * * This code (Atomikos TransactionsEssentials) contains certain interfaces * in package (namespace) com.atomikos.icatch * (including com.atomikos.icatch.Participant) which, if implemented, may * infringe one or more patents held by Atomikos. * It should be appreciated that you may NOT implement such interfaces; * licensing to implement these interfaces must be obtained separately from Atomikos. * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ package com.atomikos.icatch.jta; import java.io.Serializable; import javax.naming.NamingException; import javax.naming.Reference; import javax.naming.Referenceable; import javax.transaction.HeuristicMixedException; import javax.transaction.HeuristicRollbackException; import javax.transaction.InvalidTransactionException; import javax.transaction.NotSupportedException; import javax.transaction.RollbackException; import javax.transaction.SystemException; import javax.transaction.Transaction; import javax.transaction.TransactionManager; import javax.transaction.UserTransaction; import com.atomikos.icatch.config.TSInitInfo; import com.atomikos.icatch.config.UserTransactionService; import com.atomikos.icatch.config.UserTransactionServiceImp; import com.atomikos.util.SerializableObjectFactory; /** * * * * * * A straightforward, zero-setup implementation of a transaction manager. J2SE * applications can use an instance of this class to get a handle to the * transaction manager, and automatically startup or recover the transaction * service on first use. <b>J2EE applications should NOT use this class in order * to avoid the concurrent use of different transaction services. For J2EE * applications, we have the class J2eeTransactionManager instead.</b> */ public class UserTransactionManager implements TransactionManager, Serializable, Referenceable, UserTransaction { private static final long serialVersionUID = -655789038710288096L; private transient TransactionManagerImp tm; private UserTransactionService uts; private boolean forceShutdown; private boolean startupTransactionService; private boolean closed; private void checkSetup () throws SystemException { if ( closed ) throw new SystemException ( "This UserTransactionManager instance was closed already. Call init() to reuse if desired." ); synchronized ( TransactionManagerImp.class ) { tm = (TransactionManagerImp) TransactionManagerImp .getTransactionManager (); if ( tm == null ) { // not initialized -> startup TM // System.out.println ( "STARTING UP TM!!!!!!"); if ( getStartupTransactionService() ) { uts = new UserTransactionServiceImp (); TSInitInfo info = uts.createTSInitInfo (); uts.init ( info ); tm = (TransactionManagerImp) TransactionManagerImp .getTransactionManager (); } else { throw new SystemException ( "Transaction service not running" ); } } } } public UserTransactionManager() { //startup by default, to have backward compatibility this.startupTransactionService = true; this.closed = false; } /** * Sets whether the transaction service should be * started if not already running. * @param startup */ public void setStartupTransactionService ( boolean startup ) { this.startupTransactionService = startup; } /** * Returns true if the transaction service will * be started if not already running. * @return */ public boolean getStartupTransactionService() { return this.startupTransactionService; } /** * Performs initialization if necessary. * This will startup the TM (if not running) * and perform recovery, unless <b>getStartupTransactionService</b> * returns false. * * @throws SystemException */ public void init() throws SystemException { closed = false; checkSetup(); } /** * @see javax.transaction.TransactionManager#begin() */ public void begin () throws NotSupportedException, SystemException { checkSetup (); tm.begin (); } public boolean getForceShutdown() { return forceShutdown; } /** * Sets the force shutdown mode to use during close. * @param value */ public void setForceShutdown ( boolean value ) { this.forceShutdown = value; } /** * @see javax.transaction.TransactionManager#commit() */ public void commit () throws RollbackException, HeuristicMixedException, HeuristicRollbackException, SecurityException, IllegalStateException, SystemException { checkSetup (); tm.commit (); } /** * @see javax.transaction.TransactionManager#getStatus() */ public int getStatus () throws SystemException { checkSetup (); return tm.getStatus (); } /** * @see javax.transaction.TransactionManager#getTransaction() */ public Transaction getTransaction () throws SystemException { checkSetup (); return tm.getTransaction (); } /** * @see javax.transaction.TransactionManager#resume(javax.transaction.Transaction) */ public void resume ( Transaction tx ) throws InvalidTransactionException, IllegalStateException, SystemException { checkSetup (); tm.resume ( tx ); } /** * @see javax.transaction.TransactionManager#rollback() */ public void rollback () throws IllegalStateException, SecurityException, SystemException { checkSetup (); tm.rollback (); } /** * @see javax.transaction.TransactionManager#setRollbackOnly() */ public void setRollbackOnly () throws IllegalStateException, SystemException { checkSetup (); tm.setRollbackOnly (); } /** * @see javax.transaction.TransactionManager#setTransactionTimeout(int) */ public void setTransactionTimeout ( int secs ) throws SystemException { checkSetup (); tm.setTransactionTimeout ( secs ); } /** * @see javax.transaction.TransactionManager#suspend() */ public Transaction suspend () throws SystemException { checkSetup (); return tm.suspend (); } /** * @see javax.naming.Referenceable#getReference() */ public Reference getReference () throws NamingException { return SerializableObjectFactory.createReference ( this ); } /** * Closes the transaction service, but only if it was * implicitly started via this instance. * In other words, if the transaction service was started * in another way then this method will not do anything. * */ public void close() { if ( uts != null ) { uts.shutdown ( forceShutdown ); uts = null; } closed = true; } }
- 对于JDBC，使用我们的一个实例com.atomikos.jdbc.AtomikosDataSourceBean或者，对于non-XA驱动，可以使用com.atomikos.jdbc.nonxa.AtomikosNonXADataSourceBean
/** * Copyright (C) 2000-2010 Atomikos <[email protected]> * * This code ("Atomikos TransactionsEssentials"), by itself, * is being distributed under the * Apache License, Version 2.0 ("License"), a copy of which may be found at * http://www.atomikos.com/licenses/apache-license-2.0.txt . * You may not use this file except in compliance with the License. * * While the License grants certain patent license rights, * those patent license rights only extend to the use of * Atomikos TransactionsEssentials by itself. * * This code (Atomikos TransactionsEssentials) contains certain interfaces * in package (namespace) com.atomikos.icatch * (including com.atomikos.icatch.Participant) which, if implemented, may * infringe one or more patents held by Atomikos. * It should be appreciated that you may NOT implement such interfaces; * licensing to implement these interfaces must be obtained separately from Atomikos. * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ package com.atomikos.jdbc; import java.util.Enumeration; import java.util.Properties; import javax.sql.XADataSource; import com.atomikos.beans.PropertyUtils; import com.atomikos.datasource.RecoverableResource; import com.atomikos.datasource.xa.jdbc.JdbcTransactionalResource; import com.atomikos.icatch.system.Configuration; import com.atomikos.jdbc.AbstractDataSourceBean; import com.atomikos.util.ClassLoadingHelper; /** * The preferred class for using Atomikos connection pooling. Use an instance of * this class if you want to use Atomikos JTA-enabled connection pooling. All * you need to do is construct an instance and set the required properties as * outlined below. The resulting bean will automatically register with the * transaction service (for recovery) and take part in active transactions. * All SQL done over connections (gotten from this class) will participate in JTA transactions. */ public class AtomikosDataSourceBean extends AbstractDataSourceBean { private static final long serialVersionUID = 1L; private Properties xaProperties = null; private String xaDataSourceClassName; private transient XADataSource xaDataSource; public AtomikosDataSourceBean() { this.xaProperties = new Properties(); } protected String printXaProperties() { StringBuffer ret = new StringBuffer(); if ( xaProperties != null ) { Enumeration it = xaProperties.propertyNames(); ret.append ( "[" ); boolean first = true; while ( it.hasMoreElements() ) { if ( ! first ) ret.append ( "," ); String name = ( String ) it.nextElement(); String value = xaProperties.getProperty( name); ret.append ( name ); ret.append ( "=" ); ret.append ( value ); first = false; } ret.append ( "]" ); } return ret.toString(); } /** * Gets the properties used to * configure the XADataSource. */ public Properties getXaProperties() { return xaProperties; } /** * Sets the properties (name,value pairs) used to * configure the XADataSource. Required, unless you call setXaDataSource directly. * * @param xaProperties * * */ public void setXaProperties ( Properties xaProperties ) { this.xaProperties = xaProperties; } /** * Get the XADataSource class name. */ public String getXaDataSourceClassName() { return xaDataSourceClassName; } /** * Sets the fully qualified underlying XADataSource class name. Required, unless you * call setXaDataSource directly. * * @param xaDataSourceClassName */ public void setXaDataSourceClassName ( String xaDataSourceClassName ) { this.xaDataSourceClassName = xaDataSourceClassName; } /** * Gets the configured XADataSource (if any). * @return The instance, or null if none. */ public XADataSource getXaDataSource() { return xaDataSource; } /** * Sets the XADataSource directly - instead of providing the xaDataSourceClassName and xaProperties. * @param xaDataSource */ public void setXaDataSource(XADataSource xaDataSource) { this.xaDataSource = xaDataSource; } protected com.atomikos.datasource.pool.ConnectionFactory doInit() throws Exception { if (xaDataSource == null) { if (xaDataSourceClassName == null) throwAtomikosSQLException("Property 'xaDataSourceClassName' cannot be null"); if (xaProperties == null) throwAtomikosSQLException("Property 'xaProperties' cannot be null"); } if ( Configuration.isInfoLoggingEnabled() ) Configuration.logInfo( this + ": initializing with [" + " xaDataSourceClassName=" + xaDataSourceClassName + "," + " uniqueResourceName=" + getUniqueResourceName() + "," + " maxPoolSize=" + getMaxPoolSize() + "," + " minPoolSize=" + getMinPoolSize() + "," + " borrowConnectionTimeout=" + getBorrowConnectionTimeout() + "," + " maxIdleTime=" + getMaxIdleTime() + "," + " reapTimeout=" + getReapTimeout() + "," + " maintenanceInterval=" + getMaintenanceInterval() + "," + " testQuery=" + getTestQuery() + "," + " xaProperties=" + printXaProperties() + " loginTimeout=" + getLoginTimeout() + "]" ); if (xaDataSource == null) { Class xadsClass = null; try { xadsClass = ClassLoadingHelper.loadClass ( getXaDataSourceClassName() ); } catch ( ClassNotFoundException nf ) { AtomikosSQLException.throwAtomikosSQLException ( "The class '" + getXaDataSourceClassName() + "' specified by property 'xaDataSourceClassName' could not be found in the classpath. Please make sure the spelling is correct, and that the required jar(s) are in the classpath." , nf ); } Object driver = xadsClass.newInstance(); if ( ! ( driver instanceof XADataSource ) ) { AtomikosSQLException.throwAtomikosSQLException ( "The class '" + getXaDataSourceClassName() + "' specified by property 'xaDataSourceClassName' does not implement the required interface javax.jdbc.XADataSource. Please make sure the spelling is correct, and check your JDBC driver vendor's documentation." ); } xaDataSource = (XADataSource) driver; xaDataSource.setLoginTimeout ( getLoginTimeout() ); xaDataSource.setLogWriter ( getLogWriter() ); PropertyUtils.setProperties(xaDataSource, xaProperties ); } JdbcTransactionalResource tr = new JdbcTransactionalResource(getUniqueResourceName() , xaDataSource); com.atomikos.datasource.pool.ConnectionFactory cf = new com.atomikos.jdbc.AtomikosXAConnectionFactory(xaDataSource, tr, this); Configuration.addResource ( tr ); return cf; } protected void doClose() { RecoverableResource res = Configuration.getResource ( getUniqueResourceName() ); if ( res != null ) { Configuration.removeResource ( getUniqueResourceName() ); //fix for case 26005 res.close(); } } public String toString() { String ret = "AtomikosDataSoureBean"; String name = getUniqueResourceName(); if ( name != null ) { ret = ret + " '" + name + "'"; } return ret; } }
/** * Copyright (C) 2000-2010 Atomikos <[email protected]> * * This code ("Atomikos TransactionsEssentials"), by itself, * is being distributed under the * Apache License, Version 2.0 ("License"), a copy of which may be found at * http://www.atomikos.com/licenses/apache-license-2.0.txt . * You may not use this file except in compliance with the License. * * While the License grants certain patent license rights, * those patent license rights only extend to the use of * Atomikos TransactionsEssentials by itself. * * This code (Atomikos TransactionsEssentials) contains certain interfaces * in package (namespace) com.atomikos.icatch * (including com.atomikos.icatch.Participant) which, if implemented, may * infringe one or more patents held by Atomikos. * It should be appreciated that you may NOT implement such interfaces; * licensing to implement these interfaces must be obtained separately from Atomikos. * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ package com.atomikos.jdbc.nonxa; import java.sql.Connection; import java.sql.SQLException; import com.atomikos.datasource.pool.ConnectionFactory; import com.atomikos.icatch.HeuristicMessage; import com.atomikos.icatch.system.Configuration; import com.atomikos.jdbc.AbstractDataSourceBean; import com.atomikos.util.DynamicProxy; /** * * A Bean class for DataSource access to non-XA JDBC implementations. * Instances are JTA transaction-aware and can rollback the work done * over multiple connections (provided that all work was done in one and the same thread). * * */ public class AtomikosNonXADataSourceBean extends AbstractDataSourceBean { private static final long serialVersionUID = 1L; private String url; private String user; private String password; private String driverClassName; private boolean readOnly; /** * Sets the URL to use for getting connections. Required. * * @param url */ public void setUrl ( String url ) { this.url = url; } /** * Gets the URL to connect. */ public String getUrl() { return url; } /** * Marks this datasource as being used for read-only work. Optional. * * Setting this to true will avoid warnings/errors upon recovery. ReadOnly mode * is intended to avoid XA configuration of databases where no updates are * being done. * * @param readOnly Defaults to false. */ public void setReadOnly ( boolean readOnly ) { this.readOnly = readOnly; } /** * @return Whether or not this datasource is marked as readOnly. */ public boolean getReadOnly() { return readOnly; } /** * @return The password. */ public String getPassword () { return password; } /** * Sets the password to use. * * @param string */ public void setPassword ( String string ) { password = string; } /** * Set the user name to get connections with. * * @param string */ public void setUser ( String string ) { user = string; } /** * @return The URL to connect with. */ public String getUser () { return user; } /** * * @return The DriverManager class name. */ public String getDriverClassName () { return driverClassName; } /** * Sets the driver class name to be used by the DriverManager. Required. * * @param string */ public void setDriverClassName ( String string ) { driverClassName = string; } protected void doClose() { //nothing to do } protected ConnectionFactory doInit() throws Exception { AtomikosNonXAConnectionFactory ret = null; if ( Configuration.isInfoLoggingEnabled() ) Configuration.logInfo( this + ": initializing with [" + " uniqueResourceName=" + getUniqueResourceName() + "," + " maxPoolSize=" + getMaxPoolSize() + "," + " minPoolSize=" + getMinPoolSize() + "," + " borrowConnectionTimeout=" + getBorrowConnectionTimeout() + "," + " maxIdleTime=" + getMaxIdleTime() + "," + " reapTimeout=" + getReapTimeout() + "," + " maintenanceInterval=" + getMaintenanceInterval() + "," + " testQuery=" + getTestQuery() + "," + " driverClassName=" + getDriverClassName() + "," + " user=" + getUser() + "," + " url=" + getUrl() + " loginTimeout=" + getLoginTimeout() + "]" ); ret = new com.atomikos.jdbc.nonxa.AtomikosNonXAConnectionFactory ( this , url , driverClassName , user , password , getLoginTimeout() , readOnly ) ; ret.init(); return ret; } public synchronized Connection getConnection ( HeuristicMessage hmsg ) throws SQLException { if ( Configuration.isInfoLoggingEnabled() ) Configuration.logInfo ( this + ": getConnection ( " + hmsg + " )..." ); init(); //let pool take care of reusing an existing handle Connection proxy = super.getConnection ( hmsg ); // here we are certain that proxy is not null -> increase the use count DynamicProxy dproxy = ( DynamicProxy ) proxy; com.atomikos.jdbc.nonxa.AtomikosThreadLocalConnection previous = (AtomikosThreadLocalConnection) dproxy.getInvocationHandler(); previous.incUseCount(); previous.addHeuristicMessage ( hmsg ); if ( Configuration.isDebugLoggingEnabled() ) Configuration.logDebug ( this + ": returning " + proxy ); return proxy; } public String toString() { String ret = "AtomikosNonXADataSourceBean"; String name = getUniqueResourceName(); if ( name != null ) { ret = ret + " '" + name + "'"; } return ret; } }
- 对于JMS，可以使用我们的实例com.atomikos.jms.AtomikosConnectionFactoryBean, com.atomikos.jms.extra.AbstractJmsSenderTemplate（发送信息时使用）com.atomikos.jms.extra.MessageDrivenContainer（接收时使用）
/** * Copyright (C) 2000-2010 Atomikos <[email protected]> * * This code ("Atomikos TransactionsEssentials"), by itself, * is being distributed under the * Apache License, Version 2.0 ("License"), a copy of which may be found at * http://www.atomikos.com/licenses/apache-license-2.0.txt . * You may not use this file except in compliance with the License. * * While the License grants certain patent license rights, * those patent license rights only extend to the use of * Atomikos TransactionsEssentials by itself. * * This code (Atomikos TransactionsEssentials) contains certain interfaces * in package (namespace) com.atomikos.icatch * (including com.atomikos.icatch.Participant) which, if implemented, may * infringe one or more patents held by Atomikos. * It should be appreciated that you may NOT implement such interfaces; * licensing to implement these interfaces must be obtained separately from Atomikos. * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ package com.atomikos.jms; import java.io.Serializable; import javax.jms.ConnectionFactory; import javax.jms.JMSException; import javax.naming.NamingException; import javax.naming.Reference; import javax.naming.Referenceable; import com.atomikos.util.SerializableObjectFactory; /** * * * Common logic for the connection factory beans. * */ public abstract class AbstractConnectionFactoryBean implements Serializable, Referenceable, ConnectionFactory { protected String resourceName_; protected String xaFactoryJndiName_; protected AbstractConnectionFactoryBean ( ) { this.xaFactoryJndiName_ = ""; this.resourceName_ = "someUniqueName"; } /** * Sets the JNDI name of the underlying XAConnectionFactory (optional). This is * optional and an alternative to directly supplying the required factory * through setXaConnectionFactory(). * * @param name * The JNDI name where the XAConnectionFactory can be found. * It is up to the client to make sure that the name exists and * points to an existing XAConnectionFactory. */ public void setXaFactoryJndiName ( String name ) { xaFactoryJndiName_ = name; } /** * Retrieve the JNDI name where the XAConnectionFactory is expected. * * @return String the name or an empty String if not set. */ public String getXaFactoryJndiName() { return xaFactoryJndiName_; } /** * Set the unique resource name for this factory (required). A unique * resource name is needed by the transaction service in order to register * and recover the underlying XA transactions. * Note: the value you set here should not exceed 45 bytes in length. * * <p><b>MQSeries NOTE:</b> For * IBM MQSeries, the name should include MQSeries_XA_RMI or the XA routines * will not work properly! * * @param name * The unique resource name. */ public void setResourceName ( String name ) { resourceName_ = name; } /** * Get the resource name. * * @return String the unique resource name as previously set. */ public String getResourceName() { return resourceName_; } public Reference getReference() throws NamingException { return SerializableObjectFactory.createReference ( this ); } /** * Initialization method to register the underlying resource for recovery * and other init code. * * @throws JMSException */ public void init() throws JMSException { checkSetup(); } protected abstract void checkSetup() throws JMSException; }
/** * Copyright (C) 2000-2010 Atomikos <[email protected]> * * This code ("Atomikos TransactionsEssentials"), by itself, * is being distributed under the * Apache License, Version 2.0 ("License"), a copy of which may be found at * http://www.atomikos.com/licenses/apache-license-2.0.txt . * You may not use this file except in compliance with the License. * * While the License grants certain patent license rights, * those patent license rights only extend to the use of * Atomikos TransactionsEssentials by itself. * * This code (Atomikos TransactionsEssentials) contains certain interfaces * in package (namespace) com.atomikos.icatch * (including com.atomikos.icatch.Participant) which, if implemented, may * infringe one or more patents held by Atomikos. * It should be appreciated that you may NOT implement such interfaces; * licensing to implement these interfaces must be obtained separately from Atomikos. * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ package com.atomikos.jms.extra; import java.io.Serializable; import java.util.Map; import javax.jms.Connection; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.Queue; import javax.jms.Session; import javax.jms.Topic; import javax.transaction.Status; import javax.transaction.SystemException; import com.atomikos.icatch.jta.UserTransactionManager; import com.atomikos.icatch.system.Configuration; import com.atomikos.jms.AtomikosConnectionFactoryBean; import com.atomikos.jms.AtomikosJMSException; import com.atomikos.jms.AtomikosTransactionRequiredJMSException; /** * Common functionality for the sender templates. * */ public abstract class AbstractJmsSenderTemplate { protected AtomikosConnectionFactoryBean connectionFactoryBean; private String user; protected String password; protected Destination destination; private String destinationName; private Destination replyToDestination; private String replyToDestinationName; private int deliveryMode; private int priority; private long timeToLive; protected boolean inited; protected AbstractJmsSenderTemplate() { // set default values according to Sun's JMS javadocs setTimeToLive ( 0 ); setDeliveryMode ( javax.jms.DeliveryMode.PERSISTENT ); setPriority ( 4 ); } protected abstract Session getOrRefreshSession ( Connection c ) throws JMSException; protected abstract Connection getOrReuseConnection() throws JMSException; protected abstract void afterUseWithoutErrors ( Connection c , Session s ) throws JMSException; protected void destroy ( Connection c , Session s) throws JMSException { try { if ( s != null ) s.close(); } catch ( JMSException warn ) { Configuration.logWarning ( this + ": error closing session" , warn); } try { if ( c != null ) c.close(); } catch ( JMSException warn ) { Configuration.logWarning ( this + ": error closing connection" , warn); } } protected synchronized Connection refreshConnection() throws JMSException { Connection connection = null; if ( getDestinationName() == null ) throw new JMSException ( "Please call setDestination or setDestinationName first!" ); if ( user != null ) { connection = connectionFactoryBean.createConnection ( user, password ); } else { connection = connectionFactoryBean.createConnection (); } connection.start (); return connection; } /** * Initializes the session for sending. * Call this method first. */ public void init() throws JMSException { if ( ! inited ) { if ( connectionFactoryBean == null ) throw new IllegalStateException ( "Property 'atomikosConnectionFactoryBean' must be set first!" ); if ( getDestinationName() == null ) { throw new IllegalStateException ( "Property 'destination' or 'destinationName' must be set first!" ); } StringBuffer msg = new StringBuffer(); msg.append ( this + ":configured with [" ); msg.append ( "user=" ).append ( getUser() ).append ( ", " ); msg.append ( "password=" ).append ( password ).append ( ", " ); msg.append ( "deliveryMode=" ).append ( getDeliveryMode() ).append ( ", " ); msg.append ( "timeToLive=" ).append ( getTimeToLive() ).append ( ", " ); msg.append ( "priority=" ).append ( getPriority() ).append ( ", " ); msg.append ( "destination=" ).append( getDestinationName() ).append ( ", " ); msg.append ( "replyToDestination=" ).append ( getReplyToDestinationName() ); msg.append ( "]" ); if ( Configuration.isDebugLoggingEnabled() ) Configuration.logDebug ( msg.toString() ); inited = true; } } private void retrieveDestinationIfNecessary() throws JMSException { if ( getDestination() == null ) { String dName = getDestinationName(); RetrieveDestinationCallback cb = new RetrieveDestinationCallback ( dName ); executeCallbackInternal ( cb ); setDestination ( cb.getDestination() ); } } private void retrieveReplyToDestinationIfNecessary() throws JMSException { if ( getReplyToDestination() == null ) { String dName = getReplyToDestinationName(); if ( dName != null ) { RetrieveDestinationCallback cb = new RetrieveDestinationCallback ( dName ); executeCallbackInternal ( cb ); setReplyToDestination ( cb.getDestination() ); } } } /** * Sets the connection factory to use. Required. * @param connectionFactory */ public void setAtomikosConnectionFactoryBean(AtomikosConnectionFactoryBean connectionFactory) { this.connectionFactoryBean = connectionFactory; } public AtomikosConnectionFactoryBean getAtomikosConnectionFactoryBean() { return connectionFactoryBean; } public Destination getDestination() { return destination; } /** * Sets the (provider-specific) destination name in order * to lookup the destination (rather than providing one directly). * * Required, unless you set the destination directly. * * @param destinationName */ public void setDestinationName ( String destinationName ) { this.destinationName = destinationName; } /** * Sets the destination to send to. Required, unless * you set the destinationName instead. * * @param destination */ public void setDestination(Destination destination) { this.destination = destination; } private String getName(Destination d, String destinationName ) { String ret = destinationName; if ( ret == null ) { if ( d instanceof Queue ) { Queue q = ( Queue ) d; try { ret = q.getQueueName(); } catch ( JMSException e ) { if ( Configuration.isDebugLoggingEnabled() ) Configuration.logDebug ( this + ": error retrieving queue name" , e ); } } else if ( d instanceof Topic ) { Topic t = ( Topic ) d; try { ret = t.getTopicName(); } catch ( JMSException e ) { if ( Configuration.isDebugLoggingEnabled() ) Configuration.logDebug ( this + ": error retrieving topic name" , e ); } } } return ret; } protected String getDestinationName() { return getName ( getDestination() , destinationName ); } protected String getReplyToDestinationName() { return getName ( getReplyToDestination() , replyToDestinationName ); } /** * @return The user to connect with, or null if no explicit authentication * is to be used. */ public String getUser() { return user; } /** * If this session is used for sending request/reply messages, then this * property indicates the destination where the replies are to be sent (optional). The * session uses this to set the JMSReplyTo header accordingly. This property * can be omitted if no reply is needed. * * <p> * The replyToDestination should be in the same JMS vendor domain as the send * queue. To cross domains, configure a bridge for both the request and the * reply channels. */ public void setReplyToDestination(Destination destination) { this.replyToDestination = destination; } /** * Sets the provider-specific replyToDestinationName. Optional. * * @param replyToDestinationName */ public void setReplyToDestinationName ( String replyToDestinationName ) { this.replyToDestinationName = replyToDestinationName; } /** * Gets the replyToDestination. * * @return */ public Destination getReplyToDestination() { return replyToDestination; } /** * Set the password for explicit authentication (optional). * This is only required if * the user has also been set. * * @param password * The password. */ public void setPassword(String password) { this.password = password; } /** * Set the user to use for explicit authentication (optional). If no explicit * authentication is required then this method should not be called. * * @param user */ public void setUser(String user) { this.user = user; } protected void executeCallbackInternal ( JmsSenderTemplateCallback callback ) throws JMSException { init(); Session session = null; Connection conn = null; try { conn = getOrReuseConnection(); session = getOrRefreshSession ( conn ); if ( Configuration.isDebugLoggingEnabled() ) Configuration.logDebug ( "Calling callback..." ); callback.doInJmsSession ( session ); if ( Configuration.isDebugLoggingEnabled() ) Configuration.logDebug ( "Callback done!" ); afterUseWithoutErrors ( conn , session ); } catch ( AtomikosTransactionRequiredJMSException notx ) { destroy ( conn , session ); String msg = "The JMS session you are using requires a JTA transaction context for the calling thread and none was found." + "\n" + "Please correct your code to do one of the following: " + "\n" + "1. start a JTA transaction before sending any message, or" + "\n" + "2. increase the maxPoolSize of the AtomikosConnectionFactoryBean to avoid transaction timeout while waiting for a connection."; Configuration.logWarning ( msg ); AtomikosTransactionRequiredJMSException.throwAtomikosTransactionRequiredJMSException ( msg ); } catch ( JMSException e ) { e.printStackTrace(); destroy ( conn , session ); String msg = this + ": error in sending JMS message"; AtomikosJMSException.throwAtomikosJMSException( msg , e ); } } /** * Executes an application-level call-back within the managed session. * * @param callback * @throws JMSException */ public void executeCallback(JmsSenderTemplateCallback callback) throws JMSException { init(); retrieveDestinationIfNecessary(); retrieveReplyToDestinationIfNecessary(); UserTransactionManager tm = new UserTransactionManager (); try { if ( tm.getStatus () != Status.STATUS_ACTIVE ) throw new JMSException ( "This method requires an active transaction!" ); } catch ( SystemException e ) { Configuration .logWarning ( this +": error in getting transaction status", e ); throw new RuntimeException ( e.getMessage () ); } executeCallbackInternal ( callback ); } /** * @return The deliverymode for messages sent in this session. */ public int getDeliveryMode() { return deliveryMode; } /** * @return The priority for messages sent in this session. */ public int getPriority() { return priority; } /** * @return The timeToLive for messages sent in this session. */ public long getTimeToLive() { return timeToLive; } /** * * Set the deliverymode for messages sent in this session (optional). Defaults to * persistent. * * @param */ public void setDeliveryMode(int i) { deliveryMode = i; } /** * Set the priority for messages sent in this session (optional). Defaults to 4. * * @param */ public void setPriority(int i) { priority = i; } /** * Set the time to live for messages sent in this session (optional). Defaults to 0. * * @param */ public void setTimeToLive(long l) { timeToLive = l; } /** * Sends a TextMessage. * * @param content The text as a string. * @throws JMSException */ public void sendTextMessage(String content) throws JMSException { retrieveDestinationIfNecessary(); retrieveReplyToDestinationIfNecessary(); SendTextMessageCallback cb = new SendTextMessageCallback ( content , getDestination() , getReplyToDestination() , getDeliveryMode() , getPriority() , getTimeToLive() ); executeCallback ( cb ); } /** * Sends a MapMessage. * * @param content The Map to get the content from. * * @throws JMSException */ public void sendMapMessage(Map content) throws JMSException { retrieveDestinationIfNecessary(); retrieveReplyToDestinationIfNecessary(); SendMapMessageCallback cb = new SendMapMessageCallback ( content , getDestination() , getReplyToDestination() , getDeliveryMode() , getPriority() , getTimeToLive() ); executeCallback ( cb ); } /** * Sends an ObjectMessage. * * @param content The serializable object content. * @throws JMSException */ public void sendObjectMessage(Serializable content) throws JMSException { retrieveDestinationIfNecessary(); retrieveReplyToDestinationIfNecessary(); SendObjectMessageCallback cb = new SendObjectMessageCallback ( content , getDestination() , getReplyToDestination() , getDeliveryMode() , getPriority() , getTimeToLive() ); executeCallback ( cb ); } /** * Sends a ByteMessage. * * @param content The content as a byte array. * @throws JMSException */ public void sendBytesMessage(byte[] content) throws JMSException { retrieveDestinationIfNecessary(); retrieveReplyToDestinationIfNecessary(); SendBytesMessageCallback cb = new SendBytesMessageCallback ( content , getDestination() , getReplyToDestination() , getDeliveryMode() , getPriority() , getTimeToLive() ); executeCallback ( cb ); } /** * Closes all resources. */ public void close() { try { Connection c = getOrReuseConnection(); Session s = getOrRefreshSession(c); destroy(c, s); } catch (JMSException e) { Configuration.logWarning ( this + ": error closing" , e ); } connectionFactoryBean.close(); } }
/** * Copyright (C) 2000-2010 Atomikos <[email protected]> * * This code ("Atomikos TransactionsEssentials"), by itself, * is being distributed under the * Apache License, Version 2.0 ("License"), a copy of which may be found at * http://www.atomikos.com/licenses/apache-license-2.0.txt . * You may not use this file except in compliance with the License. * * While the License grants certain patent license rights, * those patent license rights only extend to the use of * Atomikos TransactionsEssentials by itself. * * This code (Atomikos TransactionsEssentials) contains certain interfaces * in package (namespace) com.atomikos.icatch * (including com.atomikos.icatch.Participant) which, if implemented, may * infringe one or more patents held by Atomikos. * It should be appreciated that you may NOT implement such interfaces; * licensing to implement these interfaces must be obtained separately from Atomikos. * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ package com.atomikos.jms.extra; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import javax.jms.Destination; import javax.jms.ExceptionListener; import javax.jms.JMSException; import javax.jms.MessageListener; import com.atomikos.icatch.system.Configuration; import com.atomikos.jms.AtomikosConnectionFactoryBean; /** * * A message-driven container for asynchronously receiving JMS messages * from a topic or queue, within a managed JTA transaction context. * * Upon start, an instance of this class will create a number of * concurrent sessions that listen for incoming messages on the same destination. * MessageListener instances should be thread-safe if the pool size is larger * than one. Note: in general, after start() any changed properties are only * effective on the next start() event. * * <p> * <b>IMPORTANT:</b> the transactional behaviour guarantees redelivery after failures. * As a side-effect, this can lead to so-called <em>poison messages</em>: messages * whose processing repeatedly fails due to some recurring error (for instance, a primary * key violation in the database, a NullPointerException, ...). Poison messages are problematic * because they can prevent other messages from being processed, and block the system. * * To avoid poison messages, make sure that your MessageListener implementation * only throws a <b>RuntimeException</b> when the problem is <em>transient</em>. In that * case, the system will perform rollback and the message will be redelivered * facing a clean system state. All non-transient errors (i.e., those that happen * each time a message is delivered) indicate problems at the application level * and should be dealt with by writing better application code. */ public class MessageDrivenContainer implements MessageConsumerSessionProperties { private static final int DEFAULT_TIMEOUT = 30; private AtomikosConnectionFactoryBean connectionFactoryBean; private MessageListener messageListener; private String user; private String password; private Destination destination; private String destinationName; private int transactionTimeout; private int poolSize; private List sessions; private boolean daemonThreads; private boolean notifyListenerOnClose; private String messageSelector; private ExceptionListener exceptionListener; private String subscriberName; private boolean noLocal; private boolean unsubscribeOnClose; private String clientID; private int receiveTimeout; public MessageDrivenContainer() { sessions = new ArrayList (); notifyListenerOnClose = false; setPoolSize ( 1 ); setTransactionTimeout ( DEFAULT_TIMEOUT ); } private MessageConsumerSession createSession() { return new MessageConsumerSession ( this ); } /** * Sets the clientID for durable subscriptions. Optional. * * @param clientID */ public void setClientID ( String clientID ) { this.clientID = clientID; } /** * Sets the connection factory to use. Required. * @param bean */ public void setAtomikosConnectionFactoryBean ( AtomikosConnectionFactoryBean bean ) { this.connectionFactoryBean = bean; } public AtomikosConnectionFactoryBean getAtomikosConnectionFactoryBean() { return connectionFactoryBean; } /** * Gets the destination. * * @return The destination, or null if not set. */ public Destination getDestination() { return destination; } /** * Sets the JMS destination to listen on (required unless the destinationName is set instead). * * @param dest */ public void setDestination ( Destination dest ) { this.destination = dest; } /** * Gets the destination name. * * @return The name, or null if not set. */ public String getDestinationName() { return destinationName; } /** * Sets the JMS provider-specific destination name * (required unless the destination is set directly). * * @param destinationName */ public void setDestinationName ( String destinationName ) { this.destinationName = destinationName; } /** * Sets whether threads should be daemon threads or not (optional). * Default is false. * @param value If true then threads will be daemon threads. */ public void setDaemonThreads ( boolean value ) { this.daemonThreads = value; } /** * Tests whether threads are daemon threads. * @return True if threads are deamons. */ public boolean getDaemonThreads() { return daemonThreads; } /** * * Get the message listener if any. * * @return */ public MessageListener getMessageListener() { return messageListener; } /** * Get the transaction timeout. * * @return */ public int getTransactionTimeout() { return transactionTimeout; } /** * Get the user for connecting, or null if the default user should be used. * * @return */ public String getUser() { return user; } /** * Set the message listener to use (required). * The same instance will be used for each * session in the pool, meaning that instances need to be thread-safe. Only * one listener is allowed at a time. Call this method with a null argument * to unset the listener. * * @param listener */ public void setMessageListener ( MessageListener listener ) { messageListener = listener; Iterator it = sessions.iterator (); while ( it.hasNext () ) { MessageConsumerSession s = (MessageConsumerSession) it.next (); s.setMessageListener ( listener ); } } /** * Set the password if explicit authentication is needed (optional). * You need to set this if the user is also set. * * @param string */ public void setPassword ( String string ) { password = string; } /** * Set the transaction timeout in seconds (optional). * * @param seconds */ public void setTransactionTimeout ( int seconds ) { transactionTimeout = seconds; } /** * Set the user to use for explicit authentication (optional). * Don't set this property * if you want to use the default authentication. * * @param string */ public void setUser ( String string ) { user = string; } /** * Get the message selector (if any) * * @return The selector, or null if none. */ public String getMessageSelector() { return this.messageSelector; } /** * Set the message selector to use (optional). * * @param selector */ public void setMessageSelector ( String selector ) { this.messageSelector = selector; } /** * Get the size of the pool. * * @return */ public int getPoolSize() { return poolSize; } /** * Sets the size of the session pool (optional). * Default is 1. * * @param size */ public void setPoolSize ( int size ) { poolSize = size; } /** * Gets the exception listener (if any). * @return Null if no ExceptionListener was set. */ public ExceptionListener getExceptionListener() { return exceptionListener; } /** * Sets the exception listener (optional). The listener will be * notified of connection-level JMS errors. * * @param exceptionListener */ public void setExceptionListener ( ExceptionListener exceptionListener ) { this.exceptionListener = exceptionListener; } /** * Test if this instance will receive sends from the same connection. * * @return */ public boolean isNoLocal() { return noLocal; } /** * Sets whether or not this topic should receive sends from the * same connection (optional). * * @param noLocal */ public void setNoLocal(boolean noLocal) { this.noLocal = noLocal; } /** * Gets the subscriber name (for durable subscribers). * @return The name, or null if not set (no durable subscriber). */ public String getSubscriberName() { return subscriberName; } /** * Sets the name to use for durable subscriptions (optional). * <br> * <b>Note: this name will be appended with a suffix to ensure uniqueness * among instances in the pool. Otherwise, the JMS back-end would see * multiple instances subscribing with the same name - an error.</b> * * @param subscriberName */ public void setSubscriberName(String subscriberName) { this.subscriberName = subscriberName; } protected boolean getNoLocal() { return isNoLocal(); } /** * Start listening for messages. * * @throws JMSException */ public void start() throws JMSException { if ( destination == null && destinationName == null ) throw new JMSException ( "MessageDrivenContainer: destination not specified" ); if ( connectionFactoryBean == null ) throw new JMSException ( "MessageDrivenContainer: factory not set" ); if ( messageListener == null ) throw new JMSException ( "MessageDrivenContainer: messageListener not set" ); for ( int i = 0; i < poolSize; i++ ) { MessageConsumerSession s = createSession(); s.setMessageListener ( messageListener ); s.setPassword ( password ); s.setUser ( user ); s.setDestination ( destination ); s.setDestinationName ( destinationName ); s.setAtomikosConnectionFactoryBean ( connectionFactoryBean ); s.setDaemonThreads ( daemonThreads ); s.setNotifyListenerOnClose ( notifyListenerOnClose ); s.setMessageSelector ( getMessageSelector () ); s.setExceptionListener ( exceptionListener ); s.setNoLocal( noLocal ); s.setSubscriberName( subscriberName ); //set subscriber name with suffix to ensure unique names if ( getSubscriberName() != null ) s.setSubscriberName ( getSubscriberName() + "-" + i ); s.setNoLocal ( getNoLocal() ); s.setClientID(clientID); try { s.startListening (); // System.out.println ( "MessageDrivenContainer: started // session"); } catch ( Exception e ) { Configuration.logWarning ( "Error starting pool", e ); } sessions.add ( s ); } // set listener again to trigger listening setMessageListener ( messageListener ); } /** * Stop listening for messages. If <b>notifyListenerOnClose</b> is set then * calling this method will notify the listener by calling its onMessage * method with a null argument (and also without transaction context). * * This method will wait for all active receive operations to unblock, which may take * up to <b>receiveTimeout</b> seconds per active thread. */ public void stop() { Iterator it = sessions.iterator (); while ( it.hasNext () ) { MessageConsumerSession s = (MessageConsumerSession) it.next (); s.stopListening (); } } /** * Getter to check whether the listener is notified on close. * * @return */ public boolean getNotifyListenerOnClose() { return notifyListenerOnClose; } /** * Set whether the listener should be notified of close events on the pool * (optional). Default is false. * * @param b * If true, then the listener will receive a null message if the * pool is closed. */ public void setNotifyListenerOnClose ( boolean b ) { notifyListenerOnClose = b; Iterator it = sessions.iterator (); while ( it.hasNext () ) { MessageConsumerSession s = (MessageConsumerSession) it.next (); s.setNotifyListenerOnClose ( b ); } } /** * Sets whether unsubscribe should be done at closing time (optional). Default is false. * * @param b If true, then unsubscribe will be done at closing time. This only applies to * durable subscribers (i.e., cases where subscriberName is set). */ public void setUnsubscribeOnClose ( boolean b ) { this.unsubscribeOnClose = b; } /** * Getter to test if unsubscribe should be called on close. */ public boolean getUnsubscribeOnClose() { return unsubscribeOnClose; } /** * Gets the receive timeout in seconds. * * @return */ public int getReceiveTimeout() { int ret = receiveTimeout; if ( ret <=0 ) ret = getTransactionTimeout()/2; return ret; } /** * Sets the receive timeout in seconds, * i.e. the number of seconds to wait for incoming messages in the message listener thread's event loop. * * This property is optional and defaults to half the transactionTimeout, but typically this should be lower * because the time required to shutdown (stop) this container will be bound by this value multiplied by * the number of threads (as indicated by <b>poolSize</b>). * * @param seconds */ public void setReceiveTimeout(int seconds) { this.receiveTimeout = seconds; } }
- 请检查我们完整的用户指南
注意：虽然这个版本包含了特定的第三方产品，如RDBMS软件和JMS代理软件，请注意，AtomikosTransactionsEssentials绝不是仅限制在这些特定的产品，除了RDBMS软件和JMS代理软件大多数的其他软件依然兼容。
J2SE实例：examples/jse这个文件夹包含带有源代码的各种各样的例子。可以执行这个脚本来运行这个程序（示例程序只有文本输出，而没有图形化界面输出）
运行示例前最好安装Ant，然后打开命令窗口在 examples/jse 文件夹并且输入“ant”。
Linux/Unix/Mac OSX Note：在这些系统，你必须在终端输入'chmod u+x *.sh'命令，否则，示例将无法运行。
解决问题：偶尔，一些示例可能不能再继续启动使用（尽管在开始阶段可以正常运行），这个通常是由于进程原因引起的（比如JMS代理后台环境），关闭这期间的所有进程便会解决这个问题，或者，重新启动计算机，也可以解决这个问题。
在Spring中使用：Atomikos TransactionEssentials可以很方便的于Spring相结合，运行您程序使用企业级的J2EE应用程序，而不需要EJB甚至EJB容器。另外，我们额外提供了一个强大的功能，JMS消息驱动添加到Spring的内置特性。
查看examples/spring文件夹，将展示Atomikos TransactionEssentials如何配置基于Spring的应用程序。
在J2EE的web容器中使用：在您的J2EE应用程序环境中使用Atomikos TransactionsEssentials最简单的方法是通过Spring作为pico-container（组件容器），如果想获取更多信息，请到Spring处查看。
Javadoc：
http://www.atomikos.com/downloads/transactions-essentials/com/atomikos/AtomikosTransactionsEssentials/javadoc/3.7/index.html