Atomikos 中文说明文档

Atomikos 翻译文档（英文文档来源：下载安装包中START_HERE.html）

                                 ----译者：周枫

请尊重劳动成果，转载请标明，英语水平有限，如有不准确地方请在评论中指出，谢谢

官网地址：http://www.atomikos.com/Main/WebHome

使用版本：AtomikosTransactionsEssentials-3.7.2

感谢您使用Atomikos，下面的说明文档可以让您正确使用，如果您有任何问题或者反馈，请访问我们的帮助网页http://www.atomikos.com/Main/SupportOverview，或者给我们发送邮件[e-mail]。

什么是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,只需要按以下步骤

1. 将idst和lib中的jar包全部放入的项目中
2. 创建或者自定义你应用的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

   

    

3. 在你的应用程序中，创建一个实例com.atomikos.icatch.jta.UserTransactionImp或者com.atomikos.icatch.jta.UserTransactionManager（使用默认的无参数构造函数）
   

   /** * Copyright (C) 2000-2010 Atomikos <[e-mail]> * * 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 <[e-mail]> * * 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;    }}

   

    

4. 对于JDBC，使用我们的一个实例com.atomikos.jdbc.AtomikosDataSourceBean或者，对于non-XA驱动，可以使用com.atomikos.jdbc.nonxa.AtomikosNonXADataSourceBean
   

   /** * Copyright (C) 2000-2010 Atomikos <[e-mail]> * * 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 <[e-mail]> * * 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;    }    }

   

    

5. 对于JMS，可以使用我们的实例com.atomikos.jms.AtomikosConnectionFactoryBean,com.atomikos.jms.extra.AbstractJmsSenderTemplate（发送信息时使用）com.atomikos.jms.extra.MessageDrivenContainer（接收时使用）
   

   /** * Copyright (C) 2000-2010 Atomikos <[e-mail]> * * 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 <[e-mail]> * * 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 <[e-mail]> * * 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;        }}

   

    

6. 请检查我们完整的用户指南

注意：虽然这个版本包含了特定的第三方产品，如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

 

转自: http://www.cnblogs.com/cczhoufeng/archive/2012/05/16/2502769.html