‘What?!’ I hear you say - how could this happen? The project in question was fairly simple - get information and store it in a database. The problem is , despite being mainstream for the last 6 years, there is no standard, easy ‘drag and drop’ method of doing these applications in Java. C# does it in Visual Studio. Oracle does it with Forms. With Java (and despite having doing 10 or so of these projects), there is still too much plumbing that the developer needs to know.

I’m expecting a deluge of ‘have you tried project X’ on this post. And yes, I expect that an Eclipse based tool will probably fill the gap. But for these simple applications , there is no standard way of doing this (standard being a solution that dominates the market in the way Struts did the Web App framework space, until recently). But we’ve been waiting 6 long years!

All of which brings me to Ruby. Ruby on Rails’ sweet spot is exactly these kind of simple, ajax enabled , no frills ‘get info from web and store it on database’ applications. Enterprise Java’s sweet spot is the heavy lifting workflow , Rules , Calculations, Integration with Legacy and other systems , web services and basically anything to do with Business logic. The two are a perfect complement to each other, which is why the news that JRuby now runs Ruby on Rails is especially interesting.

JRuby is a version of Ruby that runs in the Standard Java Virtual Machine (JVM). It means that (1) You don’t have to install Ruby, which might meet resistance in a corporate environment. It also means (2) that all the methods you have available in Java you have available in Ruby. The O’Reilly Ruby site and this Javaworld Article are good places to start learning more about Ruby and linking it into Java. Fellow O’Reilly Blogger Steve Anglin also has more information about the latest JRuby release.

More on Technology in plain English

参考：http://www.tusc.com.au/tutorial/html/index.html

一、Enterprise Beans

在EJB（Enterprise Java Beans）中定义了两种不同类别的Enterprise Bean ：

l         会话 Bean (Session Bean)

l         实体Bean (Entity Bean)

1.       会话 Bean (Session Bean)

请把Session Beans看作任务而非持久数据，只有这样，你才能清晰地理解使用它的场合和原因。比如说，Session Bean可能会对数据库内的用户进行检索操作，但并不把用户表示为持久的业务对象。Session Beans可以同其他类型的Java beans通信，这种能力已经超出了数据库事务概念之外。在这种方式下工作的分布式应用程序特别适合于采用Session Beans。

所有的Session Beans都派生于javax.ejb.SessionBean类。就像其名称那样， Session Beans只存在于单一客户会话中。这里的客户可能是Java Servlet、桌面应用程序、别的EJB乃至采用Java Bean的其他事务信息方式。Session Bean的生存期从客户程序发起接触开始，在客户通过调用EJB宿主接口的remove()方法显式破坏bean时终止。会话还会在预先设置的时间终止，而这种时间设置则由EJB容器内确定。考虑到服务器的资源，开发者往往会设法避免处理“超时”设置而在编写客户程序时做相应的延期处理。此外，开发者还应该在EJB容器重新启动的时候小心Session Bean的短暂寿命；客户程序可以重新获得同类bean的引用，但很有可能却不是同一bean。

Session Beans可以是无状态也可以是有状态的，因而两者会显示出不同的行为。Session Bean的状态概念类似于HTTP设置：客户程序和服务器之间的交互（在这种情况下就是bean自身）发生在定义的环境之内。有状态的Session Bean会在多个方法调用的情况下保存客户和bean的有关信息。有状态的Session Bean只能同一个客户程序通讯，而无状态Session bean的实例却可以同时和若干个客户程序通讯。

会话 Bean 是调用它的客户端代码要完成的工作。当客户端与服务器建立联系，那么一个会话 Bean 就建立起来了。根据会话 Bean 的状态不同有分为:

A. 状态会话 Bean (Stateful Session Bean)

B. 无状态会话 Bean (Stateless Session Bean)

1.1 状态会话 Bean (Stateful Session Bean)

当客户机和服务器建立连接之后，状态会话 Bean (Stateful Session Bean) 将一直在客户机和服务器之间保持着用户的某个状态。例如：用户使用银行的ATM时，经过验证之后，用户可以连续执行多次操作，在这个过程当中，用户的合法状态将一直被保留，直到她将信用卡取出，结束这次操作。这时，状态会话 Bean (Stateful Session Bean) 也就被销毁。

1.2无状态会话 Bean (Stateless Session Bean)

当客户机和服务器建立连接之后，无状态会话 Bean (Stateless Session Bean)处理单一的用户请求或商务过程。无状态会话 Bean (Stateless Session Bean)不需要从以前的请求中提取任何状态。例如，用户的用户密码确认。用户输入密码后，发送请求。组件返回真或假来确认用户，一旦过程完成，无状态会话 Bean (Stateless Session Bean) 也宣告结束。

2. 实体Bean (Entity Bean)

实体Bean (Entity Bean)只是数据模型，它不包括商务逻辑。实体Bean (Entity Bean)可以将关系/对象数据库的数据映射到内存中供其它组件使用。实体Bean (Entity Bean)是一直存在的，而且具有很高的容错性能。实体Bean (Entity Bean)能供允许多用户同时访问。

二、会话 Bean (Session Bean)

Ejb的执行过程是被放在一个EJB容器中进行的，所以客户端不会直接调用我们写好的Enterprise Bean ，而是调用EJB容器生成的一个EJBObject (EJB对象)来实现。那么，我们在编写服务器端的Enterprise Bean 时，就要考虑这点。既然客户端不能直接访问，就由EJBObject来代劳，所以在编写服务器端时，就要编写服务器端的一个接口（Remote）用来与客户机联系，实力化EJBObject。要生成EJBObject 就要调有Home 接口，来建立这个实力。

以下是会话 Bean 的代码分析：

A.Enterprise Bean 类：sailorsy.class

1.setSessionContext(SessionContext ctx)方法

它是EJB容器和Enterprise Bean互相作用的关口。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

}//class sailorsy

2.ejbCreate(…)方法

它可以初始化Enterprise Bean ,可以定义不同的ejbCreate(…)方法，每个方法所带的参数不同。但是，必许要存在至少一种。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

public void ejbCreate() {

}//ejbCreate

}//class sailorsy

3.ejbPassivate()方法

如果初始化的Enterprise Bean 过多，EJB容器将其中的一些挂起（passivate）,释放他们所占用的空间。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

public void ejbCreate() {

}//ejbCreate

public void ejbPassivate() {

}//ejbPassivate

}//class sailorsy

4.ejbActivate()方法

和ejbPassivate正好相反，它将被挂起的Bean从新调回。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

Creating a Stateless Session Bean

This chapter covers how to create a stateless session EJB component. This bean will be responsible for authenticating the user by communicating with the database using Data Access Object (DAO) which encapsulates Java Database Connectivity (JDBC) code. A DAO has all attributes (fields) and behavior (methods) corresponding to the bean it is being used for.

All customers, supplier and manager of MyStore have been assigned a unique username and userid to access services of MyStore, but in order to access these services all these entities have to first login into the system (MyStore). The method for authentication is named loginUser, which takes two String parameters, username and password and returns the userID if authentication is successful.

Note : This method loginUser is a business method, normally business methods carry out operations or processing on values EJB components. From clients perspective, clients can see only business methods and invoke them on bean.

Tasks :

1. Create a J2EE project named MyStore.
2. Create a Stateless Session Bean named StoreAccess.
3. Add a business method in bean named loginUser with the following signature

public String loginUser (String username, String password)

4. Create a DAO named StoreAccessDAOImpl under package au.com.tusc.dao. Generate the DAO interface.
5. Implement the method named loginUser, generated in DAO interface, in StoreAccessDAOImpl. Method signature is

public String loginUser (String username, String password)

6. Add callback methods and implement them.
7. Deploy StoreAccess bean.
8. Create your test client named SessionClient under package au.com.tusc.client.
9. Run your client and test the bean.

Create J2EE Project :

Now, lets start to write our first component of this tutorial.

Go to File > New > LombozJ2EE Project, project creation wizard will pop up.

Insert Project Name MyStore > Next .

Under Java Settings Check source, should be MyStore/src , libraries pointing to $JAVA_HOME > Go Next as shown in fig below.

Note: This step is shown in chapter1, as there is a bug in eclipse 2.1, so its important that you check your library settings are right.

Under Create J2EE Module, select Web Modules tab > Add.., enter Module name as OnlineStore > OK as shown in figure below.

Under Create J2EE Module, select EJB Modules tab > Add.., enter Module name as MyStoreMgr > OK .

Under Create J2EE Module, select Targeted Servers tab > Select JBOSS 3.2.1 ALL > Add.. > Finish.

Create Stateless Bean :

Go To Package Explorer > Expand Mystore (project) node > select src, right click and menu will pop up.

On pop up menu > New > Lomboz EJB Creation Wizard.

Enter package name au.com.tusc.session, bean name StoreAccess and select bean type as stateless > Finish.

This will create a package named au.com.tusc.session under src and StoreAccessBean under that package as shown in the figure below.

As we can see from the figure below it has created a class level tag @ejb.bean, which has assigned the bean type, name and its JNDI name which will be generated in Home interface. This tag will also generate deployment descriptors in ejb-jar.xml and jboss.xml file as well once you generate your EJB classes, which is covered later on in this chapter.

Note: It will generate the bean name, jndi-name and type of bean in the file. Also, the name of file is appended with word 'Bean' as you gave the name of the bean as StoreAccess only. Again, be careful with naming conventions, specifying the bean name only in the wizard without adding the word 'Bean' to the name as the wizard appends that for you.

Expand MyStoreMgr/META-INF node under Package Explorer. You will find there are seven files which are generated by Lomboz using Xdoclet as shown in the figure below.

Now we are going to generate all the interfaces including Home, Remote, DAO and other helper classes. We will explain why later on, but for the time being just follow the steps.

But before we get too excited, there are a few concepts to cover here.

Go to MyStoreMgr/META-INF > select and open ejbGenerate.xml.

Note: Lomboz uses this file to generate required interfaces and helper classes, so in the event that you have special needs then you will have to customize this file. See ejbdoclet under the Xdoclet documentation.

'ejbGenerate.xml' file is generated only once when you create your EJB module. So any changes made in this file will be reflected even if you modify your bean class and generate your classes again and again.

The other two files which are of importance to us are ejb-jar.xml and jboss.xml. The file ejb-jar.xml has all the deployment descriptors for beans and jboss.xml has the JBOSS specific deployment descriptors required by JBOSS.

Note : ejb-jar.xml file is generated every time you generate interface and helper classes for your bean. For the first time, it is empty, and jboss.xml will be generated every time when you will generate your classes for your bean.

Setup DAO :

Now, let's customize ejbGenerate.xml for setting up a DAO.

We have included a <dao> tag specifying the destination directory for the generated DAO interface and what pattern to be used.

Note : For details, please refer ejbdoclet under Xdoclet documentation.

Note : The way Xdoclet works is bit different from some conventional styles of programming, as the Xdoclet tags will generate these (home and remote) interfaces along with necessary helper classes, which then will used in Bean and DAO Implementation class. However, until these are generated, we cannot write any business methods in Bean and JDBC wrappers in the DAO Implementation class. If this seems confusing then just follow the steps, and hopefully it will become more clear.

Create DAO Interface :

Since we are going to use a DAO to access the database for this Stateless Bean, we have to create a DAOImpl class which will implement that generated DAO interface.

Go to src > add package named au.com.tusc.dao > Add a class StoreAccessDAOImpl in that package.

Now go to your Bean class and declare this tag at the class level (that is at the top) as shown below to generate the DAO interface.

   @ejb.dao class="au.com.tusc.session.StoreAccessDAO"

    impl-class="au.com.tusc.dao.StoreAccessDAOImpl"

Expand StoreAccessBean node under Package Explorer. Right click and a pop up menu will appear.

On that menu go to Lomboz J2EE > Add EJB to module. Select EJB '[MyStoreMgr]' > OK.

Expand MyStoreMgr node under MyStore Project in Package Explorer. Right click and a menu will pop up.

Go to Lomboz J2EE > Generate EJB Classes as shown in the figure below.

This tag also generates the following descriptors in jboss.xml as shown in the code snippet below.

So now we know which tags are responsible for generating classes, interfaces and descriptors.

Add Business Method :

Next step is to add a business method in the bean.

Go to StoreAccesBean > Right click > Select New on pop up menu > Select Lomboz Ejb Method Wizard.

Add a business method with the following signature: public String loginUser (String username, String password).

Select Method Type as Business and Interface as Remote as shown in the figure below..

This wizard generates a loginUser method in our bean class, with the method level tag '@ejb.interface' shown below.

This tag is responsible for generating this method in the Remote Interface (in this case it is StoreAccess which will be created once you generate your classes). This tag is covered later on in this chapter.

After generating the classes, we look at first the generated DAO interface and then the generated Session Class.

In StoreAcessDAO two methods are generated.

1. init() by default.

2. loginUser(), generated by tag shown below.

@dao.call name="loginUser"

Note: Please do not edit any class generated by Xdoclect.

In StoreAcessSession two methods of our interest are

1. getDAO() creates instance of DAOImpl calss.

2. loginUser(), calls loginUser method in DAOImpl class, which we have to implement.

Code snippet from 'StoreAccessSession'.

Implement DAO Interface :

Now, we will implement methods in the StoreAccessDAOImpl class.

In StoreAcessBean class under the loginUser method just add some debug statements, as shown below in this code snippet.

Note : We don't have to call the loginUser method in StoreAccessDAOImpl, as it being invoked by the loginUser method in StoreAccessSession class which inherits StoreAccessBean class, that is the StoreAccessSession class has overridden this method.

Code snippet from StoreAccessSession shown below.

Add Callback Methods :

Now, add callback methods to complete this bean as shown below.

1. setSessionContext.
2. UnsetSessionContext.

Note : These callback methods are invoked by the EJB container.

Add a field to store sessionContext.

protected SessionContext ctx;

Add method setSessionContext with sessionContext as parameter and assign that to the sessionContext variable as shown below in the code snippet.

Similarly add method unsetSessionContext, assign context variable to null as shown above.

Note : StoreAccessSession class inherits the StoreAccessBean abstract class and implements SessionBean, which will override all methods of interface SessionBean. So after finishing the methods in the bean class, generate your EJB classes again. SessionContext methods will be overridden as shown in figure below. Code snippet from StoreAccessSession shown below.

Now let's look at the generated Home and Remote interfaces.

In the case of the Remote interface all business methods declared in the bean are also generated with the same signature. This is due to the class level tag declared in the StoreAccess Bean as discussed above after adding business methods. Code snippet for tag is shown below.

So, loginUser is generated in a Remote Interface called StoreAccess as shown below because of this tag.

In the case of the Home Interface only one method is created named 'create', which is generated by default because of the <homeinterface/> tag in ejbGenerate.xml as shown below.

Also, other then that, it has JNDI_NAME and COMP_NAME (which is the logical name to lookup the component) is also generated, these are generated because of this tag declared at class level in 'StoreAccessBean' class shown below in figure.

Note : For further options associated with these tags please refer to the 'ejbdoclet' documentation in Xdoclet.

Now, all the aspects are pretty much covered, and our bean's functionality is complete. Now for the deployment descriptors..

Deploy Bean :

In order to deploy our bean we have to declare a few tags in the StoreAccessBean class as shown below in the code snippet.

Add the tag shown below in at the class level (at the top).

@ejb.resource-ref res-ref-name="jdbc/DefaultDS"

res-type="javax.sql.Datasource"

res-auth="Container"

This tag will generate deployment descriptors in ejb-jar.xml, as the bean has to know which datasource you are going to connect to, what is its type, etc. This will generate these descriptors as shown in code snippet below.

Add the tag shown below in StoreAccessBean at the class level (at the top).

@jboss.resource-ref res-ref-name="jdbc/DefaultDS" jndi-name="java:/DefaultDS"

This tag will generate deployment descriptors in jboss.xml, as the application server has to know with what jndi-name datasource it has been registered with. This will generate these descriptors as shown in the code snippet below.

Now, everything is complete, and it's time to deploy the bean.

First, regenerate your EJB classes as shown in the steps above for the final time.

Note : We have regenerated the classes again and again, in order to explain every step and its result. Once you are familiar with these steps you will need much fewer of these iterations. Either way, it doesn't matter, as your implementation always remains untouched by this process.

Go to Lomboz J2EE View > expand node MyStore > expand MyStoreMgr > select 'Jboss 3.2.1 ALL' .

Right click > select Debug Sever on the pop up menu as shown in figure below.

Go to MyStoreMgr node in LombozJ2EE view > right click > select Deploy on the pop up menu as shown in the figure below.

And now wait for your deployment result.

If everything goes fine, you will have this message under your console as shown in the figure below.

So, now our bean is deployed successfully, let's create our test client, which will invoke the loginUser method on 'StoreAccessBean'.

Create your Test Client :

Go to Project MytStore node > select src node > right click.

Select New on pop up menu > select Lomboz EJB Test Client Wizard as shown in the figure below.

Select package name au.com.tusc.client, name as SessionClient and select Ejb Home as au.com.tusc.session.StoreAccessHome and Ejb Interface as au.com.tusc.session.StoreAccess as shown in the figure below.

This will generate the required methods for you in your SessionClient class and you have to just invoke the loginUser method on the bean as shown below.

Now the last step is to write code in your client.

So add these lines under the testBean method as shown in figure below.

System.out.println("Request from client : ");

System.out.println("Reply from Server: Your userid is " +

myBean.loginUser("ANDY","PASSWD"));

Test your Client :

Now, in order to test your client, Select SessionClient node > Go at top level menu and select the icon with the 'Running Man'.

On that select 'Run as' > select 'Java Application', as shown below.

Now under your console, if you get your reply for 'ANDY' as 'U2', then your call is successful as shown below.

Note : So our Stateless Session Bean is deployed and tested successfully and from now onwards you should be comfortable using Lomboz. In future we will not go into the detail of the steps for using Lomboz and will concentrate more on other aspects of beans.

小结

通过表示J2EE应用程序中的任务或者行动。Session Beans可以因此而处理大量的状态。尤其是在同其他EJB合用的情况下。理解Session Beans的瞬时现象对开发者的工作会带来莫大的帮助。有状态和无状态Beans的细微差别就如同充分利用其行为一样重要。在掌握以上的概念之后，正确的设计和实现Session Beans必然会显著改进EJB应用程序的功能和效率。

流程文档是一个zip文件. 文档的中心流程是 processdefinition.xml . 文件中主要信息是流程图.  processdefinition.xml也包含关于动作和任务的信息 . 流程文档也包含其他流程相关文档比如类,任务ui-form  ...

发布文档文档可以通过3种方式来做: 用流程设计器工具, 用ant任务或编程实现.

发布任务通过设计器工具依然在开发阶段.

发布任务文档通过ant任务如下:

<target name="deploy.par">
  <taskdef name="deploypar" classname="org.jbpm.jpdl.par.ProcessArchiveDeployerTask">
    <classpath --make sure the jbpm-[version].jar is in this classpath--/>  
  </taskdef>  
  <deploypar par="build/myprocess.par" /> 
</target>

一次发布多个流程文件, 用嵌套的fileset元素. file属性是可选的. 其他ant 任务属性是:

流程文档也可通过编程来发使用类 org.jbpm.jpdl.par.ProcessArchiveDeployer

流程定义基本不会改变,因为预测所有流程定义变化是非常困难的.

围绕这个问题, jBPM 有一个久经考验的流程版本机制.版本机制允许多个同名的流程定义在数据库中同时存在. 流程实例使用最后的可用版本并且并且在同一个流程里持续执行知道生命周期结束.当较新的版本被发布, 较新的建立实例将用最新的版本,同时老的流程实例用老的流程定义保持执行.

流程定义是组合声明指定图和一组相关的java classes. Java classes  能被jBPM运行时间环境以2种方式使用: 让这些class被jBPM classloader看到. 这是把你的委托 类放到.jar文件然后到 jbpm-[version].jar . java classes 也能被包括进流程文档. 当你包括你的委托类到流程文档(它们对jbpm classloader是不可见的), jBPM 将使用这些class版本. 关于流程载入的信息参考 13.2章节, “委托”

当流程档案被发布时, 它在jBPM数据库中生成一个流程定义. 流程定义可以被版本化基于基本的流程定义名字.当命名的流程档案被发布时,发布者将分配给它一个版本数字. 为了分配数字,发布者将查询同名的流程最高版本数字加1.没有名字的流程定义版本数字为-1.

JBI的主要目的是提供一个基于服务的平台作为对现有Java/J2EE平台功能的扩展。由于Web services已经实际应用于J2EE中，而且ESB和SOA等术语与其说是技术推动力倒不如说更是市场概念，所以让我们一起来深究一下到底什么是Java/J2EE中所谓的“基于服务的平台”。

当前的J2EE部署都运行在一个基础上，那就是应用服务器。应用服务器本身由两个独立的部分组成——Servlet容器和EJB容器，它们分别用于部署JSP/Servlets和EJB构件。在它们中的任何一个，你都能使用Web services。但是，在任何环境中以分散的方式使用services是很困难的工作，而JBI的目的就是为完成这个任务提供一个专门的环境。

JBI的最底层是一个容器，它与J2EE中的容器一样定义了自身的部署构件。在我们深入之前，让我们先详细了解一下JBI的主要构想。

首先，它关注了Web services的核心部分:在终端之间传输的SOAP 消息/信封。这种数据段或标记能够包含被服务于很多应用的信息。不仅如此，根据发送端或接受端的不同，它还能协助把某个业务逻辑与数据适配。

现在，回过头来看看今天的Web services。在Web services出现之前，对于很多企业应用来说，使用面向消息的中间件系统或者MOM实现异构系统之间的通信已经足够了。Web services的出现同样是处于这个目的。用MOM的基于消息的架构和Web services很类似，被服务的数据也能在应用之间进行无缝操作。

这种场景可以被应用到典型的J2EE环境中，并通过JMS或JAX-RPC等技术进行服务。这种做法对简单部署是可行的，但正如前面提到的，当进行很复杂的设计时，现有的容器则显得很难用。于是JBI试图解决这个问题。

JBI提供了一种正规消息路由器(Normalized Message Router,NMR)，说白了，就是一个地点。在这个地点，所有基于消息的数据片段——SOAP片段、MOM消息、HTTP数据或其它信息——被聚合、集中、应用到业务逻辑、传输，如果有必要则被转换成其它格式并随后被分派到最终目的地。

先前的描述说明了为什么JBI被称为ESB。它很适合企业级应用，因为它通过一种总线型架构的基于消息的手段到达了适应大范围的消费者和提供者的目的。现在，让我们看看除了NMR还有什么构成了JBI。

和JBI环境直接交互的是两个部分，JBI machine和JBI binding。JBI machine定义了部署构件以及在环境中管理它们的方式。本质上，它是提供商设计的黑盒，用于在JBI中支持他们自己的模型。另一方面，JBI binding则被环境通过专门的业务协议与外部世界进行通信。
 
现在，再让我们把这些概念放到真实的JBI实现ServiceMix中。ServiceMix是完全用JBI的思想开发的一个开源项目。它可以支持多种绑定，包括HTTP、JMS、平面文件以及RSS，还提供了一系列类似BPEL、Schema Validation、JCA 和缓存等服务。

与ServiceMix协作的还有基于JMX的管理接口以及用来与JBI构件通信的对本地客户端API。尽管本文不对ServiceMix功能做进一步说明，但你可以很容易地下载该软件然后继续学习。下面，让我们来看看一个可部署在ServiceMix上的真实的JBI构件，这样你会对它有点感性认识。

Listing for JBI Components - File Sender & File Receiver.　　

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

<beans xmlns:my="http://servicemix.org/demo/">

  <!-- the JBI container -->

  <container id="jbi">

  <property name="useMBeanServer" value="true"/>

  <property name="createMBeanServer" value="true"/>

  <property name="dumpStats" value="true"/>

  <property name="statsInterval" value="10"/>

     <components>

     <!-- Write files to the outbox directory -->

      <component id="fileSender"   service="foo:fileSender"     class="org.servicemix.components.file.FileWriter">

      <property name="directory" value="outbox"/>

      <property name="marshaler">

      <bean  class="org.servicemix.components.util.DefaultFileMarshaler">

      <property name="fileName">

      <bean class="org.servicemix.expression.JaxenStringXPathExpression">

      <constructor-arg value="concat('sample_', /sample/@id, '.xml')"/>

      </bean>

      </property>

       </bean>

      </property>

   </component>

   <!-- Look for files in the inbox directory -->

    <component id="filePoller" service="foo:filePoller"  class="org.servicemix.components.file.FilePoller"   destinationService="foo:fileSender">

      <property name="workManager"  ref="workManager"/>

      <property name="file" value="inbox"/>

      <property name="period" value="1000"/>

    </component>  

   </components>   

 </container>

  <!-- the work manager (thread pool)  for this container -->

  <bean id="workManager"  class="org.jencks.factory.WorkManagerFactoryBean">

      <property name="threadPoolSize"  value="30"/>

  </bean>

</beans>
 

JBI规格说明书本身并没有定义构件应该如何编码。请注意，ServiceMix用XML风格的语法定义了两个核心构件，关联到特定的类和属性。在把这种结构部署到ServiceMix以后，环境就会创建一种查询构件，负责从系统和其它构件中读取存档信息，然后把读取的值返回到文件系统。

该文件系统是JBI中非常基本的场景，因为信息就是从JBI环境(NMR)原样集中的，然后被返回到同样类型的绑定(文件系统)。但是很明显，一旦JBI环境有能力把任何业务逻辑适配成数据，例如BPEL或schema validation，然后重定向到其它类型的绑定，例如HTTP或RSS，那么就不只是返回到文件系统了。

正如你意识到的一样，当一用到JBI，操纵及分发数据的可能性就很大，但即使JBI用Java的方法实现了SOA，JSR-208规格说明书还是受到了批评。IBM和BEA是Java/J2EE领域的两个主要推动者，他们就不支持这个新项目。尽管如此，还是有像ServiceMix这样的小项目开发者和一些闭源开发组织打赌，一个培育良好的JBI市场将和J2EE的情况差不多。

假如你正在Java中使用Web services或者为了复杂的集成任务使用基于消息的设计，你应该对JBI的进展特别关心，因为它能为执行这样的任务提供更健壮的平台。就算你对JBI/ESB是否能加入J2EE协议栈还存有怀疑，继续关注还是有帮助的，因为它可能会成为应用服务器领域像Spring那样的事实上的“第三容器”或轻量级的容器扩展，为Java提供SOA能力。