例子:消息驱动Bank

　　

　　为了阐述我们的观点,我们将开发和安装一个完整的样板应用程序:一个消息驱动的银行系统. 通过（幸亏有Spring）改进的基于POJOs的编程模型和保留相同的事务，我们可以不需要EJB或者一个应用服务器来实现这个系统。在下一个部分,我们将从消息驱动架构产生到另一个架构.就像基于WEB的架构一样.图1展示我们的样本应用程序的架构.

　　

　　Figure 1. Architecture of the message-driven bank

　　在我们的例子中,我们将处理来自Java消息服务队列的银行定单.一张定单的处理包括通过JDBC来更新当前帐户的数据库.为了避免信息的丢失和重复,我们将使用JTA和JTA/XA事务来配合更新:处理信息和更新数据库将发生在一个原子事务里.资源部分可得到JTA/XA的更多信息.

　　

　　编写应用程序代码

　　该应用程序将由两个JAVA类组成: Bank(一个DAO)和MessageDrivenBank.如图2.

　　

　　Figure 2. Classes for the message-driven bank

　　Bank是一个数据访问对象，这个对象封装数据库访问。MessageDrivenBank是一个消息驱动façade并且是DAO的委托.与典型的J2EE方法不同,这个应用程序不包括EJB类.

　　

　　第一步:编写Bank DAO

　　如下, Bank源代码是很直接和简单的JDBC操作.

　　

package jdbc;

　　import javax.sql.*;

　　import java.sql.*;

　　public class Bank

　　{

　　private DataSource dataSource;

　　public Bank() {}

　　public void setDataSource ( DataSource dataSource )

　　{

　　this.dataSource = dataSource;

　　}

　　private DataSource getDataSource()

　　{

　　return this.dataSource;

　　}

　　private Connection getConnection()

　　throws SQLException

　　{

　　Connection ret = null;

　　if ( getDataSource() != null ) {

　　ret = getDataSource().

　　getConnection();

　　}

　　return ret;

　　}

　　private void closeConnection ( Connection c )

　　throws SQLException

　　{

　　if ( c != null ) c.close();

　　}

　　public void checkTables()

　　throws SQLException

　　{

　　Connection conn = null;

　　try {

　　conn = getConnection();

　　Statement s = conn.createStatement();

　　try {

　　s.executeQuery (

　　"select * from Accounts" );

　　}

　　catch ( SQLException ex ) {

　　//table not there => create it

　　s.executeUpdate (

　　"create table Accounts ( " +

　　"account VARCHAR ( 20 ), " +

　　"owner VARCHAR(300), " +

　　"balance DECIMAL (19,0) )" );

　　for ( int i = 0; i < 100 ; i++ ){

　　s.executeUpdate (

　　"insert into Accounts values ( " +

　　"'account"+i +"' , 'owner"+i +"', 10000 )"

　　);

　　}

　　}

　　s.close();

　　}

　　finally {

　　closeConnection ( conn );

　　}

　　//That concludes setup

　　}

　　//

　　//Business methods are below

　　//

　　public long getBalance ( int account )

　　throws SQLException

　　{

　　long res = -1;

　　Connection conn = null;

　　try {

　　conn = getConnection();

　　Statement s = conn.createStatement();

　　String query =

　　"select balance from Accounts where account='"+

　　"account" + account +"'";

　　ResultSet rs = s.executeQuery ( query );

　　if ( rs == null || !rs.next() )

　　throw new SQLException (

　　"Account not found: " + account );

　　res = rs.getLong ( 1 );

　　s.close();

　　}

　　finally {

　　closeConnection ( conn );

　　}

　　return res;

　　}

　　public void withdraw ( int account , int amount )

　　throws Exception

　　{

　　Connection conn = null;

　　try {

　　conn = getConnection();

　　Statement s = conn.createStatement();

　　String sql =

　　"update Accounts set balance = balance - "+

　　amount + " where account ='account"+

　　account+"'";

　　s.executeUpdate ( sql );

　　s.close();

　　}

　　finally {

　　closeConnection ( conn );

　　}

　　}

　　}

　　注意:代码并没有依赖EJB或任何专门的应用程序服务器.实际上,这是一个纯JAVA代码,这个JAVA代码是能在任何J2SE环境下运行的.

　　你同时应注意:我们使用了来自JDBC的DataSource接口.这意味着我们的类是独立于目前JDBC供应商提供的类. 你可能会疑惑,这怎么能与特定的数据管理系统(DBMS)提供商的JDBC实现紧密结合呢？ 这里就是Spring框架帮你实现的. 这个技术被称为依赖注入:在我们的应用程序的启动期间，通过调用setDataSource方法,Spring为我们提供了相应的datasource对象.在后面几部分我们会更多地提到Spring.如果我们在以前使用应用程序服务器,我们将不得不借助于JAVA命名绑定接口(JNDI)查询.

　　除了直接使用JDBC,我们也可以使用Hibernate或者一个JDO工具来实现我们的持久层.这同样不需要任何的EJB代码.

　　

　　第二步:配置BankDAO

　　我们会将便用Spring框架来配置我们的应用程序.Spring不是必需的,但是使用Spring的好处是我们将可以简单的添加服务,如:我们JAVA对象的事务和安全.这类似于应用服务器为EJB提供的东西,只是在我们的例子中Spring将变得更容易.

　　Spring也允许我们把我们的类从目前的JDBC驱动实现中分离出来:Spring能够配置Driver(基于我们的XML配置数据)并把它提供给BankDAO对象(依赖注入原理).这样可以保持我们的JAVA代码的清淅和集中.这步的Spring配置文件如下:

　　

<?xml version="1.0" encoding="UTF-8"?>

　　<beans>

　　<bean id="datasource"

　　class="com.atomikos.jdbc.nonxa.NonXADataSourceBean">

　　<property name="user">

　　<value>sa</value>

　　</property>

　　<property name="url">

　　<value>jdbc:hsqldb:SpringNonXADB

　　</value>

　　</property>

　　<property name="driverClassName">

　　<value>org.hsqldb.jdbcDriver</value>

　　</property>

　　<property name="poolSize">

　　<value>1</value>

　　</property>

　　<property name="connectionTimeout">

　　<value>60</value>

　　</property>

　　</bean>

　　<bean id="bank" class="jdbc.Bank">

　　<property name="dataSource">

　　<ref bean="datasource"/>

　　</property>

　　</bean>

　　</beans>

　　这个XML文件包括两个对象的配置:访问数据库的DataSource和使用这个DataSource的Bank对象.下面是由Spring维护的一些基本任务.

　　?创建应用程序(例: Bank和DataSource)需要的对象(“beans”).在XML文件中给出了这些对象的类名,并且在我们的例子中,这些对象需要有一个公共的无参数constructor (Spring也允许参数,但是配置语法上有所不同).这些对象都被命名(XML中的id属性),所以我们后面能够引用这些对象. id也允许我们的应用程序找回它需要的已配置对象.

　　?这些对象的初始化是通过在XML文件中的properties的值实现. 在XML文件中这些properties名 应与对应的类中的setXXX方法相对应.

　　?将对象连接在一起 :一个property可能是另一个对象(例如:在我们例子中的数据源)的引用,引用可以通过id创建.

　　注意:在我们下一步中, 我们将选择配置一个JTA-enabled的数据源(由Atomikos Transactions提供,可用于企业和J2SE的JTA产品,我们将应用于我们的应用程序). 简单起见,我们将使用HypersonicSQLDB,这个DBMS不需要专门的安装步骤―它是在.jar文件里,就像JTA和Spring.

　　但是,考虑到渐增的可靠性需求,强列推荐你使用XA-capable的DBMS和JDBC驱动.没有XA的支持, 在crash或重启之后你的应用程序将不能恢复原有数据. 资源部分有链接到关于事务和XA的信息和一些例子.

　　作为一个练习,你可以试试从HypersonicSQLDB转换到FirstSQL,一个易安装XA-compliant的DBMS.换句话说,任何其他为企业准备的和XA-capable的DBMS也会做得很好.

　　

　　第三步:测试BankDAO

　　让我们来测试我们的代码,(使用极限编程的程序员会首先写测试,但因开始不是很清淅,所以我们直到现在才开始写测试.)下面是一个简单的单元测试.这个测试可在你的的应用程序里运行:它通过Spring获得一个BANK对象来进行测试(这在setUp方法中实现).注意:这个测试使用清楚的事务划分:每一个测试开始之前开始一个事务,每个测试结束时强制进行事务回滚.这是通过手工的方式来减少测试对数据库数据的影响.

　　

package jdbc;

　　import com.atomikos.icatch.jta.UserTransactionImp;

　　import junit.framework.TestCase;

　　import java.io.FileInputStream;

　　import java.io.InputStream;

　　import org.springframework.beans.factory.xml.XmlBeanFactory;

　　public class BankTest extends TestCase

　　{

　　private UserTransactionImp utx;

　　private Bank bank;

　　public BankTest ( String name )

　　{

　　super ( name );

　　utx = new UserTransactionImp();

　　}

　　protected void setUp()

　　throws Exception

　　{

　　//start a new transaction

　　//so we can rollback the

　　//effects of each test

　　//in teardown!

　　utx.begin();

　　//open bean XML file

　　InputStream is =

　　new FileInputStream("config.xml");

　　//the factory is Spring's entry point

　　//for retrieving the configured

　　//objects from the XML file

　　XmlBeanFactory factory =

　　new XmlBeanFactory(is);

　　bank = ( Bank ) factory.getBean ( "bank" );

　　bank.checkTables();

　　}

　　protected void tearDown()

　　throws Exception

　　{

　　//rollback all DBMS effects

　　//of testing

　　utx.rollback();

　　}

　　public void testBank()

　　throws Exception

　　{

　　int accNo = 10;

　　long initialBalance = bank.getBalance ( accNo );

　　bank.withdraw ( accNo , 100 );

　　long newBalance = bank.getBalance ( accNo );

　　if ( ( initialBalance - newBalance ) != 100 )

　　fail ( "Wrong balance after withdraw: " +

　　 newBalance );

　　}

　　}

　　我们将需要JTA事务来确保JMS和JDBC都是原子操作.一般来说,当经常都是两个或多个连接的时候，你应考虑一下JTA/XA。例如,在我们例子中的JMS和JDBC. Spring本身不提供JTA事务;它需要一个JTA实现或者委派一个应用服务器来处理这个事务.在这里,我们使用了一个JTA实现,这个实现可以在任何J2SE平台上工作.

　　最终架构如下面图3.白色方框代表我们的应用程序代码.

　　

　　Figure 3. Architecture for the test

　　如你所看到的,当我们执行我们的测试，将会发生下面的情况:

　　1.BankTest开始一个新事务.

　　2.然后,这个test在Spring运行期间获得一个BANK对象.这步触发Sping的创建和初始化过程.

　　3.这个test调用BANK的方法.

　　4.BANK调用datasource对象,通过它自己的setDataSource 方法从Spring 获取这个对像.

　　5.这个数据源是JTA-enabled,并且与JTA实现交互来注册当前事务.

　　6.JDBC statements和帐户数据库交互.

　　7.当方法返回时, test调用事务回滚.

　　8.JTA记得住datasource对象，会命令它进行回滚.

　　

　　第四步:添加声明式事务管理

　　Spring允许添加声明式事务管理来管理java对象.假设我们想确认bank总是和一个有效的事务上下文一起被调用.我们通过在实际对象的上部配置一个proxy对象. Proxy和实际对象有相同接口,所以客户通过完全相同的方式使用它. 配置Proxy wrap每个BankDAO方法到事务中.结果配置文件如下. 不要被XML的庞大吓倒―大多数内容能通过复制和粘贴到你自己的工程中再使用.

　　

<?xml version="1.0" encoding="UTF-8"?>

　　<beans>

　　<!--

　　Use a JTA-aware DataSource

　　to access the DB transactionally

　　-->

　　<bean id="datasource"

　　class="com.atomikos.jdbc.nonxa.NonXADataSourceBean">

　　<property name="user">

　　<value>sa</value>

　　</property>

　　<property name="url">

　　<value>jdbc:hsqldb:SpringNonXADB</value>

　　</property>

　　<property name="driverClassName">

　　<value>org.hsqldb.jdbcDriver</value>

　　</property>

　　<property name="poolSize">

　　<value>1</value>

　　</property>

　　<property name="connectionTimeout">

　　<value>60</value>

　　</property>

　　</bean>

　　<!--

　　Construct a TransactionManager,

　　needed to configure Spring

　　-->

　　<bean id="jtaTransactionManager"

　　class="com.atomikos.icatch.jta.UserTransactionManager"/>

　　<!--

　　Also configure a UserTransaction,

　　needed to configure Spring

　　-->

　　<bean id="jtaUserTransaction"

　　class="com.atomikos.icatch.jta.UserTransactionImp"/>

　　<!--

　　Configure the Spring framework to use

　　JTA transactions from the JTA provider

　　-->

　　<bean id="springTransactionManager"

　　class="org.springframework.transaction.jta.JtaTransactionManager">

　　<property name="transactionManager">

　　<ref bean="jtaTransactionManager"/>

　　</property>

　　<property name="userTransaction">

　　<ref bean="jtaUserTransaction"/>

　　</property>

　　</bean>

　　<!-- Configure the bank to use our datasource -->

　　<bean id="bankTarget" class="jdbc.Bank">

　　<property name="dataSource">

　　<ref bean="datasource"/>

　　</property>

　　</bean>

　　<!--

　　Configure Spring to insert

　　JTA transaction logic for all methods

　　-->

　　<bean id="bank"

　　class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

　　<property name="transactionManager">

　　<ref bean="springTransactionManager"/>

　　</property>

　　<property name="target">

　　<ref bean="bankTarget"/>

　　</property>

　　<property name="transactionAttributes">

　　<props>

　　<prop key="*">

　　PROPAGATION_REQUIRED, -Exception

　　</prop>

　　</props>

　　</property>

　　</bean>

　　</beans>

　　这个XML文件告诉Spring去配置下面的对象:

　　1.需要通过JDBC连接的datasource.

　　2. 添加jtaTransactionManager和jtaUserTransaction用于为JTA事务的Spring配置作准备.

　　3.springTransactionManager用于告诉Spring需要使用JTA.

　　4. BankDAO被重命名为bankTarget (因如下解释的原因).

　　5.bank对象被添加用于包装事务和bankTarget的所有方法.我们通过配置bank对象来使用

　　springTransactionManager,这意味着所有事务将是JTA事务. 每个事务都被设置为PROPAGATION_REQUIRED,这将在任何异常下出现强制回滚.

　　对这些对象包含的内容,你都可以很容易的复制和粘贴jtaTransactionManager, jtaUserTransaction, springTransactionManager到其他工程.其他的是应用程序相关的对象：datasource, bankTarget, bank. Bank对象很有趣:事实上对于bankTarget它是一个proxy;他们拥有相同的接口. Trick如下:当我们的应用程序请求Spring去配置和返回bank对象,Spring实际上将返回proxy(看起来和我们的应用程序完全相同)，随后这个proxy将为我们开始/结束事务.这样,应用程序和Bank类本身都不需要知道JTA!图4阐述了在这步我们所得到的.

　　

　　Figure 4. Architecture with declarative JTA transactions in Spring

　　现在的工作如下:

　　1.应用程序调用bank对象.这将触发Spring的初始化处理和返回proxy对象. 对应用程序而言,这个proxy行为和我们的Bank是一样的.

　　2.当bank的一个方法被调用, 这个调用将会通过proxy进行.

　　3.proxy使用springTransactionManager创建一个新事务.

　　4.springTransactionManager被配置为使用JTA,因些它委派到JTA.

　　5.调用被forward到Bank的实际对象,bankTarget.

　　6.bankTarget使用从Spring中得到的datasource.

　　7.datasource对事务进行注册.

　　8.通过规则的JDBC访问数据库.

　　9.在返回时, proxy终止事务:如果在先前的序列中没有发生异常,那么将会提交终止指令.否则,它将会被回滚.

　　10.transaction 管理器与数据库配合进行提交和回滚.

　　在这步中的测试怎样进行?我们可重用BankTest 和它清晰的事务划分:因为PROPAGATION_REQUIRED, proxy将和在BankTest中创建的事务上下文一起执行.

　　

　　第五步:编写PROPAGATION_REQUIRED

　　在这步,我们将添加JMS处理逻辑.为了做到这样,我们主要需要实现JMS MessageListener接口.我们也会添加公共的setBank方法使Spring的依赖注入起作用.源代码如下:

　　

package jms;

　　import jdbc.Bank;

　　import javax.jms.Message;

　　import javax.jms.MapMessage;

　　import javax.jms.MessageListener;

　　public class MessageDrivenBank

　　implements MessageListener

　　{

　　private Bank bank;

　　public void setBank ( Bank bank )

　　{

　　this.bank = bank;

　　}

　　//this method can be private

　　//since it is only needed within

　　//this class

　　private Bank getBank()

　　{

　　return this.bank;

　　}

　　public void onMessage ( Message msg )

　　{

　　try {

　　MapMessage m = ( MapMessage ) msg;

　　int account = m.getIntProperty ( "account" );

　　int amount = m.getIntProperty ( "amount" );

　　bank.withdraw ( account , amount );

　　System.out.println ( "Withdraw of " +

　　amount + " from account " + account );

　　}

　　catch ( Exception e ) {

　　e.printStackTrace();

　　//force rollback

　　throw new RuntimeException (

　　e.getMessage() );

　　}

　　}

　　}

　　

　　第六步:配置MessageDrivenBank

　　这里我们配置MessageDrivenBank去监听事务的QueueReceiverSessionPool.这样给我们可以实现和EJB(没有丢失信息和冗余信息)类似的消息机制,但在这里我们是用简单的POJO对象实现.当向pool中插入一个MessageListener,这个会话池将确保用JTA/XA事务接收到消息.结合JTA/XA-capable 的JDBC数据源,我们可以实现可靠的消息机制.Spring的配置如下:

　　

<?xml version="1.0" encoding="UTF-8"?>

　　<!--

　　NOTE: no explicit transaction manager bean

　　is necessary

　　because the QueueReceiverSessionPool will

　　start transactions by itself.

　　-->

　　<beans>

　　<bean id="datasource"

　　class="com.atomikos.jdbc.nonxa.NonXADataSourceBean">

　　<property name="user">

　　<value>sa</value>

　　</property>

　　<property name="url">

　　<value>jdbc:hsqldb:SpringNonXADB</value>

　　</property>

　　<property name="driverClassName">

　　<value>org.hsqldb.jdbcDriver</value>

　　</property>

　　<property name="poolSize">

　　<value>1</value>

　　</property>

　　<property name="connectionTimeout">

　　<value>60</value>

　　</property>

　　</bean>

　　<bean id="xaFactory"

　　class="org.activemq.ActiveMQXAConnectionFactory">

　　<property name="brokerURL">

　　<value>tcp://localhost:61616</value>

　　</property>

　　</bean>

　　<bean id="queue"

　　class="org.activemq.message.ActiveMQQueue">

　　<property name="physicalName">

　　<value>BANK_QUEUE</value>

　　</property>

　　</bean>

　　<bean id="bank" class="jdbc.Bank">

　　<property name="dataSource">

　　<ref bean="datasource"/>

　　</property>

　　</bean>

　　<bean id="messageDrivenBank"

　　class="jms.MessageDrivenBank">

　　<property name="bank">

　　<ref bean="bank"/>

　　</property>

　　</bean>

　　<bean id="queueConnectionFactoryBean"

　　class="com.atomikos.jms.QueueConnectionFactoryBean">

　　<property name="resourceName">

　　<value>QUEUE_BROKER</value>

　　</property>

　　<property name="xaQueueConnectionFactory">

　　<ref bean="xaFactory"/>

　　</property>

　　</bean>

　　<bean id="queueReceiverSessionPool"

　　class="com.atomikos.jms.QueueReceiverSessionPool"

　　init-method="start">

　　<property name="queueConnectionFactoryBean">

　　<ref bean="queueConnectionFactoryBean"/>

　　</property>

　　<property name="transactionTimeout">

　　<value>120</value>

　　</property>

　　<!--

　　default license allows only limited

　　concurrency so keep pool small

　　-->

　　<property name="poolSize">

　　<value>1</value>

　　</property>

　　<property name="queue">

　　<ref bean="queue"/>

　　</property>

　　<property name="messageListener">

　　<ref bean="messageDrivenBank"/>

　　</property>

　　</bean>

　　</beans>

　　因为这篇文章需要一个便于安装的JMS服务,所以这里我们使用ActiveMQ.如果你正在使用另一个JMS实现,那么你将仍然能使用这部分提出的技术.接下来除了datasource和bank对象,我们将增加下面的对象定义:

　　?xaFactory: 为建立JMS连接的connection工厂.

　　?queue: queue代表我们将使用的JMS队列, 这个队列被配置成ActiveMQ要求的形式.

　　?queueConnectionFactoryBean:一个JTA-aware的JMS连接器.

　　?A queueReceiverSessionPool for JTA-enabled message consumption：注意:我们同时指定了用来调用的初始化方法(例:start);这是Spring的另一个特性. Start方法在session pool类里定义,它是在Spring配置文件中进行配置的.

　　?messageDrivenBank：负责处理消息.

　　你可以问问自己事务管理是在哪里进行的.事实上, 在先前部分被添加的对象已消失.为什么呢?因为我们现在使用QueueReceiverSessionPool来接收来自JMS的消息,并且这个类也为每次接收启动一个JTA事务.我们也可以保留JTA配置，另外添加JMS配置, 但是这样可能会使XML文件更长. 现在session pool类将担当事务管理角色.它和proxy方法的工作相似; 只是这个类需要JMSMessageListener 为之添加事务. 通过这样配置,在每个消息收接之前程序将启动一个新事务 无论何时, 当我们的消息实例正常返回时, 这个事务将提交. 如果出现RuntimeException, 那么这个事务将回滚. 结构如下面图5(可以清淅地看到一些JMS对象).

　　

　　Figure 5. Architecture for message-driven applications in Spring

　　现在该架构工作如下:

　　1.应用程序调用bank对象和初始化数据库表.

　　2.应用程序queueReceiverSessionPool, 因此触发一个start方法的调用去监听到达的消息.

　　3.queueReceiverSessionPool在队列中侦察一个新消息.

　　4.queueReceiverSessionPool开始一个新事务,并且注册这个事务.

　　5.queueReceiverSessionPool调用已注册的MessageListener (messageDrivenBank).

　　6.这将触发对bank 对象的调用.

　　7.bank 对象通过datasource访问数据库.

　　8.datasource注册事务.

　　9.通过JDBC访问数据库.

　　10.当处理完成时, queueReceiverSessionPool会终止这个事务。然后进行commint(除非发生RuntimeException).

　　11.transaction manager开始消息队列的两阶段提交.

　　12.transaction manager开始数据库的两阶段提交.

　　

　　第七步:编写应用程序

　　因为我们没有使用容器,我们仅仅提供一个Java应用程序就可以启动整个银行系统.我们的Java应用程序是非常简单: 它有能力找回配置的对象(Spring通过XML文件将他们放到一起). 这个应用程序能在任何兼容的JDK(Java Development Kit)上运行,并且不需要应用服务器.

　　

package jms;

　　import java.io.FileInputStream;

　　import java.io.InputStream;

　　import org.springframework.beans.factory.xml.XmlBeanFactory;

　　import com.atomikos.jms.QueueReceiverSessionPool;

　　import jdbc.Bank;

　　public class StartBank

　　{

　　public static void main ( String[] args )

　　throws Exception

　　{

　　//open bean XML file

　　InputStream is =

　　new FileInputStream(args[0]);

　　//the factory is Spring's entry point

　　//for retrieving the configured

　　//objects from the XML file

　　XmlBeanFactory factory =

　　new XmlBeanFactory(is);

　　//retrieve the bank to initialize

　　//alternatively, this could be done

　　//in the XML configuration too

　　Bank bank =

　　( Bank ) factory.getBean ( "bank" );

　　//initialize the bank if needed

　　bank.checkTables();

　　//retrieve the pool;

　　//this will also start the pool

　　//as specified in the beans XML file

　　//by the init-method attribute!

　　QueueReceiverSessionPool pool=

　　( QueueReceiverSessionPool )

　　factory.getBean (

　　"queueReceiverSessionPool" );

　　//Alternatively, start pool here

　　//(if not done in XML)

　　//pool.start();

　　System.out.println (

　　"Bank is listening for messages..." );

　　}

　　}

　　这就是J2EE!是不是认为J2EE也很容易呢?

　　

　　对通用性的考虑

　　这部分里我们看看更多的概念,这些概念在许多J2EE应用程序中是很重要的.我们同样将看到对这些概念来说，一个应用服务器并不是必须的.

　　

　　集群和可扩展性

　　健壮的企业应用程序需要集群来分流负担. 在消息驱动应用程序的例子中,这很容易:我们自动地从JMS应用程序继承得来处理能力.如果我们需要更强大的处理能力,那么我们只需增加更多连接相同JMS服务器的进程.一个对服务性能有效的衡量标准是在队列中停留的消息的数量. 在其他情况下,如基于web的 架构(如下)我们能很容易地使用web环境下的集群能力.

　　

　　方法级别的安全

　　一个典型的观点是认为EJB能增加方法级的安全性.虽然并没有在这篇文章中提到,但是在Sping中配置方法级别的安全是可能的.这种配置类似于我们增加方法级的事务划分的方式.

　　

　　对非消息驱动的应用程序的通用性

　　在不改变源代码的情况下(除了主应用程序类),我们使用的平台能很容易地被整合到任何J2EE web 应用服务器. 换句话说 , 通过JMS进行后台处理;这使得web服务器在面对后台处理的延迟问题上更可靠和更独立.在任何情况下, 为了实现容器管理的事务或容器管理的安全性,我们都不再需要依靠EJB容器来实现.

　　

　　关于容器管理持久化?

　　存在并被很多开发者检验过的技术例如:JDO或者Hibernate 都不一定需要一个应用服务器. 另外,这些工具已经占据了持久化市场.

　　

　　结论

　　今天,不需要应用服务器的J2EE已经成为可能，也很容易. 有人或许会说,没有应用程序服务器,有一些应用程序仍不能实现:例如,如果你需要一般的JCA(Java Connectivity API) 功能性, 那么我们上面提供的平台是不够的. 但是,这可能会发生改变，因为不用使用一个应用程序服务器进行开发,测式和部署的好处实在是太大. 人们越来越相信: 将来得J2EE是一个模块化的”选择你所需要”架构. 这与我们之前的完全基于应用服务器的方法相反. 在这样的情况下,J2EE开发者将从应用服务器和EJB中解放出来.