]]>
既然需要将实体Bean映射到存储源中，应用肯定需要提供操作RDBMS的代码?br /> Bean理持久化实体Bean,是手工完成持久化行ؓ的EJBcd。换句话所Q组件开发者必d发代码，以将内存中的持久化域存储到底层存储源中。这U方式成为BMP?br /> EJB规范q提供了BMP的替代组件类型：借助于EJB容器完成数据的持久化。这是容器理持久?CMP)。此Ӟ通常都要持久化逻辑从CMP中剥d来。然后借助于容器提供的工具完成数据的自动持久化。最?EJB容器生成访问数据库的代码。注意，CMP是独立于MO/RMapping技术的数据对象Q因此可以在各种企业环境中重用CMPlg?br /> CMP极大减少了实体Bean的代码量Q因Z用直接编写JDBC代码了。EJB容器会处理所有的持久化操作，q是EJB势能应用的优势之一?br /> 在执行ejbCreate()Ҏ期间Q即在初始化内存中的实体BeanӞ会在底层RDBMS中插入新的记录，q将q些记录同实体Bean实例建立h关pR当调用BMP实体Bean的ejbCreate()Ӟ它将负责生成RDBMS中的数据。类似的Q当调用BMP实体Bean的ejbRemo()Ӟ它将负责RDBMS中数据的删除?/p>
在EJB领域中，客户q没有直接调用EJB实例Q它们仅仅调用了EJB对象代理。借助于Home对象能够生成EJB对象。因此，对于定义在EJB BeancM的各个ejbCreate()ҎQ在Home接口中也存在对象的create()Ҏ。当客户调用Home对象的create()ҎӞ容器把调用h委派lejbCreate()Ҏ?br /> 开发者可以通过多种方式查找实体Bean.需要在实体Bean的Home接口中列丑ևq些查找Ҏ。我们称q些Ҏ?finder"Ҏ。除了暴露创建、销毁实体Bean实例的方法外QHome接口q需暴露finderҎ。这是实体Bean的Home接口同其他EJBcd中的Home接口的最明显区别?/p>
实体上下文，所有的EJBlg都存在上下文对象供组件访问到容器环境使用。这些上下文对象含有EJB容器讄的环境信息。因此EJBlg能够讉KC下文Q从而获取各U信息，比如事务Q安全性信息。对于实体Bean而言Q存在javax.ejb.EntityContext上下文接口。它l承自EJBContext
public interface javax.ejb.EntityContext extends javax.ejb.EJBContext{
public javax.ejb.EJBLocalObject getEJBLocalObject();
public javax.ejb.EJBObject getEJBObject();
public java.lang.Object getPrimarykey();
}
通过调用getEJBObject()ҎQ当前客戯够获得某实体Bean实例对应的EJB对象。客戯用的是EJB对象Q而不是实体Bean实例本n。因此，客户能够在应用中引用q回的EJB对象?br />
实体Bean实例对应的主键可以通过getPrimaryKey()Ҏ获得。主键唯一标识某实体Bean实例。当实体Bean实例存储到存储源中时Q可以用主键获得单个实体Bean实例。由于在RDBMS中也存在主键Q因此主键能够唯一标识某个实体Bean实例?/p>
对于M成熟的、基于OO多层部v的企业应用而言Qd以划分出2U截然不同的lgcd?、应用逻辑lgQ?、持久化数据lg。会话Bean和实体Bean的最大区别在于实体Bean是实体，客户是可以看的到的。因此实体Bean能够独立于客户应用的生命周期。对于实体Bean而言Q通过比较它们各自含有的数据便能够区分不同的实体Bean.q意味着客户能够引用单个的实体Bean实例q将它传入到其他应用中，不同的客户可以共享同L实体Bean实例Q这对于会话Bean是办不到的。会话Bean建模q程或者工作流。实体Bean本n是客户Q它是持久化状态对象?br /> 实体Bean实例存在几方面的含义Q?br /> 1、持久化数据的Java表示Q即它能够从持久化存储源装蝲数据到内存中。同Ӟ实体Bean实例能够装载到的数据存储到实例的成员变量中?br /> 2、通过修改内存中的Java对象可以改变数据的取倹{?br /> 3、还可以修改后的数据保存到存储源汇中，从而更新RDBMS中的物理数据?br /> 实体Bean是持久化对象Q它能够长期存在。即使出C不可恢复的失败，比如应用服务器瘫痪、数据库瘫痪Q实体Beanq是能够存活的。原因在于实体Bean只是对底层具有容错行为的持久化存储源中数据的映射Q因此，即极其瘫痪Q内存中的实体Bean实例q可以重新构建。在极其重启后，实体Bean实例需要从底层存储源装载数据，q用获得的数据对实体Bean实例中的各个域进行setter操作。实体Bean比客户会话的生命周期要长。可以认为，数据库中记录存活的时间决定了实体Bean实例的生命周期?br /> 相同数据往往存在多分物理拯Q比如内存中的实体Bean实例、实体Bean数据本nQ他们都是对RDBMS中数据的拯。因此，EJB容器需要提供某U机制实现数据在Java对象和RDBMS间的自动传输。实体Bean的BeancMؓ此提供了2个特D方法：
ejbLoad():它能够从持久化存储源中读取数据，q存储到实体Bean实例的域中?br /> ejbStore():它能够将当前实体Bean实例的域g存到底层RDBMS中?br /> 那么何时需要完成内存中实体Bean实例和RDBMS中数据的传递和转换Q开发者需要知道是谁调用了ejbLoad()和ejbStore(),{案是EJB容器。它们是回调ҎQ供EJB容器调用。EJB规范要求所有的实体Beanlg必须提供它们。至于读取或存储数据的时机，由EJB容器军_。依据实体Bean实例当前的事务状态，EJB容器会自动计出需要调用实体Bean实例中的ejbLoad()QejbStore()Ҏ的时机，q也是用实体Beanlg的优势之一Q开发者不用考虑java对象同步底层RDBMS的问题?/p>
Z满大量q发客户讉K同一数据的要求，架构师需要借助于实体Bean设计出高性能的访问系l。如下给ZU解x案：允许多个客户׃n同一实体Bean实例。因此，实体Bean实例能够同时服务多个客户。尽表面上看是可行的，但是对于EJB而言Q这是行不通的。原因有亮点Q其一Qؓ实现实体Bean实例服务多个q发客户Q必M证实体Bean实例是线E安全的Q开发线E安全的代码q不是一件容易的工作Q而且l常会出C堆错我。其二，底层事务pȝ几乎不可能控制多个线E的q发执行Q事务往往同具体的U程l定在一赗因此，Z上述理由Q单个实体Bean实例只能够在单线E环境中q行。对于所有的EJBlg而言Q包括会话Bean、消息驱动Bean、实体BeanQ它们都是以单线E方式运行的?br />
当然Q强制要求各个实体Bean实例只能同时服务单个客户Q将引入性能瓉。由于实例以单线E方式运行，客户需要排队等候实体Bean实例Q从而获得对实体Bean实例的调用，q对于大型企业应用而言Q是不允许出现的
Z提供pȝ性能QEJB容器会实例化同一实体Bean的多个实例。这使得多个客户能够q发同不同实体Bean实例q行交互Q而这些实体Bean实例代表了同一RDBMS数据。事实上Q这是EJB容器的运行行为。因此，客户再也不用排队{候实体Bean实例Q因为存在多个实体Bean实例了?br />
一旦多个实体Bean实例代表了同一RDBMS数据Q则引入了另外一个问题：数据瘫痪。如果多个实体Bean实例代表的数据是通过~存理的，则需要在内存中拷贝多分缓存中的数据。显Ӟ某些~存中的数据变得陈旧，因此会出现很多过期的数据?br />
Z实现实体Bean实例的缓存一致性，各个实体Bean实例必须同底层存储元q行同步。EJB容器通过调用ejbLoad(),ejbStore()Ҏ同步q些实体Bean实例?br />
至于实体Bean实例同底层RDBMS数据的同步频率，则取决于事务。事务将各个客户h隔离h。借助于事务实现数据同步?/p>
EJB容器提供的实例池是很有意义的。当Ӟq不是只有实体Bean才存在实例池。在实体Bean实例重新分配l不同EJB对象Ӟ会存在一些问题，q要求容器去解决。比如当实体Bean实例被指定给EJB对象Ӟ它可能还持有资源(比如Socketq接)。如果将实体Bean实例攄在实例池中，Socketq接不在需要。因此ؓ实现资源的获取和释放Q实体Bean的Beanc需要实现如?个回调方法：
1、ejbActivate().在将实体Bean实例从实例池中取出来ӞEJB容器会自动调用它。该q程UC为激zR进而，EJB容器会将实体Bean实例分配l某EJB对象Qƈ同时获得主键对象。在执行ejbActivate()Ҏ期间Q实例需要获得所需的资源，比如Socke,否则Q在实体Bean实例分配l某EJB对象Ӟ无法对资源进行操作?br />
2、ejbPassivate().在将实体Bean实例攄到实例池中时QEJB容器会调用它。注意，它也是回调方法。这一q程UC为挂赗进而，EJB容器需要从某EJB对象中取回分配于它的实体Bean实例Qƈ实例的主键对象也收回。在执行ejbPassivate()Ҏ期间Q需要释放ejbActivate()执行期间获得的相兌源，比如QSocket.
一旦实体Bean实例被挂P不但要释攑֮持有的资源，q将实例的状态信息保存v来。因此，实体Bean实例最新的状态信息可以从RDBMS中找C。ؓ了保存实体Bean实例的域信息到RDBMS中，容器要在挂v实例前调用ejbStore()Ҏ。类似的Q一旦实体Bean被激z，不但要获得所需的资源，q要从RDBMS装蝲最新的数据Qؓ了完成数据的dQEJB容器在Ȁzd体Bean实例后调用ejbLoad()Ҏ?/p>
]]>
W一U方法称之ؓ静态存根，此时需要在客户端预先生成SOAP客户存根Q这同RMI存根cM。第二种ҎUC为动态代理。它在q行时获得WSDL描述Q然后创建动态代理。无论采用哪U方式访问WEB服务Q客户都需要获得服务Endpoint地址URLQ否则单凭JNDI名是很难讉K到WEB服务的?br />
package com.testproject.ejb.web;import java.net.URL;import javax.xml.namespace.QName;import javax.xml.rpc.Service;import javax.xml.rpc.ServiceFactory;
/**
* 单独JAX-RPC客户代码实例?br />
* 它用了动态代理方法，以获得对q程WEB服务的引用?br />
*
*/public class HelloClient { static String host = "localhost"; //web服务的名?/span> static String serviceURL = "HelloBean"; //名称I间 static String nameSpaceUri = "urn:examples"; static String serviceName = "HelloWorldWS"; //web服务调用的地址 static String serviceEndpointAddress = "http://"+host+":8000"+serviceURL;
public static void main(String[] args)throws Exception{
HelloInterface hello = null; //动态代理方?br />
//1、指定WSDL文g的位|?/span> URL url = new URL(serviceEndpointAddress+"?WSDL"); //2、创建服务工厂实?/span> ServiceFactory serviceFactory = ServiceFactory.newInstance(); //3、创建服务对象，以作Z理工?/span> Service HelloService = serviceFactory.createService(url,new QName(nameSpaceUri,serviceName)); //4、获得port引用 hello = (HelloInterface)HelloService.getPort(HelloInterface.class); //调用hello()Ҏ System.out.println("Dynamic Proxy:"+hello.hello());
}}]]>
Set J2EE_HOME=J2EE安装目录Set CLASSPATH =%CLASSPATH%;%J2EE_HOME%\\lib\\j2ee.jar;.Set Path =%Path%;%J2EE_HOME%\\bin;.2、创建初始目?br />
+HelloBeanService +META-INF(application.xmlQsun-j2ee-ri.xml ) +ejb +META-INFQejb-jar.xmlQ?nbsp;webservices.xmlQmapping.xmlQ?br />
-*.java文gQEJB相关的类Q?br />
-config.xmlpackage com.testproject.ejb.web;/* * Hello服务Endpoint接口 * 需要注意的是，q里使用的是EJB2.1无状态会话Bean,它作为WEB服务端点时可以不提供Home接口和Remote * Locale接口Q它提供的是web服务端点接口Q这个接口扩展了Remote接口?br />
*/public interface HelloInterface extends java.rmi.Remote { public String hello()throws java.rmi.RemoteException;}4、实现服务端Ҏ?br />
package com.testproject.ejb.web;import java.rmi.RemoteException;import javax.ejb.EJBException;import javax.ejb.SessionBean;import javax.ejb.SessionContext;/* * 定义了服务端Ҏ口，接下来的d是开发无状态会话Bean。无状态会话Bean同样需要实现SessionBean接口Q?br />
* 服务端点接口定义的方法在会话Bean中实现?br />
*/public class HelloBean implements SessionBean { public void ejbCreate(){ /* * q里不能接收M参数 */ } public void ejbActivate() throws EJBException, RemoteException { } public void ejbPassivate() throws EJBException, RemoteException { } public void ejbRemove() throws EJBException, RemoteException { } public void setSessionContext(SessionContext arg0) throws EJBException, RemoteException { } /* * 业务ҎQ输出hello */ public String hello(){ return "Hello wyq"; }}5、创建EJB描述
用于部v成Web服务的无状态会话Bean的描q符和普通的无状态会话Bean不同ejb-jar.xml
<?xml version="1.0" encoding="UTF-8"?><ejb-jar version="2.1"xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd"> <display-name>HelloBean</display-name> <enterprise-beans> <session> <display-name>HelloBean</display-name> <ejb-name>HelloBean</ejb-name> <service-endpoint>com.testproject.ejb.web.HelloInterface</service-endpoint> <ejb-class>com.testproject.ejb.web.HelloBean</ejb-class> <session-type>Stateless</session-type> <transaction-type>Container</transaction-type> </session> </enterprise-beans></ejb-jar>在这个新的部|描q符中，使用<service-endpoint>指定了服务端点，同时Q必L定EJB为无状态会话Bean
6、生成WEB服务描述
下面的Q务就是生成一个Web服务描述Q我们通常使用工具来生成这个描q符。在q里使用J2EE提供的wscompile工具来生成。在使用wscompile工具生成web服务描述前，首先手工~写一个简单的XML描述config.xml
<?xml version="1.0" encoding="UTF-8"?><configuration xmlns="http://java.sun.com/xml/ns/jax-rpc/ri/config"> <service name="MyHelloBeanService" targetNamespace="urn:HelloBean" typeNamespace="urn:HelloBean" packageName="helloBeanService"> <interface name="com.testproject.ejb.web.HelloInterface"/> </service></configuration>在这个描qCQ指定了目标的名U空间、包的名字和Web服务端点接口QHelloInterface。如下命令就可以生成一个web服务描述
c:\\ HelloBeanService\\ejb \\>wscompile -define -d . -nd . -classpath . config.xml
自动生成MyHelloBeanService.wsdl文g?/pre>7、编写一个web服务映射文gQ?br /> 在ejb\\META-INF目录下新Z个mapping.xml文gQ然后编辑这个描q符
8、编写webservices.xml文g
另外Q还需要提供webservices.xml文gQƈ存放到Ejb-jar存档的META-INF目录中。各个J2EE产品可能提供相应的部|工h创徏q个文g?/pre>9、EJB打包
另外Qweb服务部v描述W在EJB-JAR文g中的位置是META-INF/webservices.xml.把生成的HelloBeanService.wsdl拯到ejb\\META-INF目录?br /> c:\\HelloBeanService\\ejb\\jar cvf ejb.jar com META-INF
10、Application打包
HelloBeanService\\MEAT-INF目录下创?个文Ӟapplication.xml和sun-j2ee-ri.xml
application.xml
最后归?/pre>c:\\ HelloBeanService\\ejb\\>copy ejb.jar ../
c:\\ HelloBeanService\\ejb\\>cd..
c:\\ HelloBeanService\\\\>jar cvf encryptservice.ear ejb.jar META-INF
]]>
l成WEB服务的事实标准可以通过如下{式表达Q?br /> Web服务 = WSDL+SOAP+UDDI
1、WSDL语言比Java更抽象、广度更大。HelloWorldWSDL中存?lt;service>标签Q它能够在具体地址提供若干<port>.<port>代表了服务接口及对具体协议的l定?br /> 2、服务描q包含了Endpoint地址。WSDL是由Java接口和对象引用构成的。换句话_Web服务不存在真正的实体Q它们不是对象，因此必须它们按照模块化对待?br /> 3、根据输入、输出定义操作。开发者需要将输入、输出消息表CZؓXML元素?br /> 4、采用的l定是SOAPl定。到目前为止Q只能采用SOAPl定。也h意，<soap:binding>标签q存在style="rpc"属性，因此可以看出styleq存在其他取|目前Q用于交换SOAP消息的另一U风格是文档风格(document-style)。文档风格意味着在SOAP消息体中不在包含对具体操作的描述?/p>
SOAP协议为Web服务和它们的客户定义了XML消息格式。SOAP消息格式非常单。它实际包含两部分内容：其一QHTTP POSTh头信息。其二，XML文档Q这是SOAP信封(Envelope)。另外，通过上述两分SOAP消息Q我们还惌达Web服务中的另一个重要概c从SOAP协议的用过E来看，它非常轻量，因ؓ它对处于交互中的客户和服务没有Q何限制。但是，从SOAP协议的大、性能角度考虑Q它q不轻量。如果不压羃SOAP消息Q则需要在|络上传递大量的SOAP数据消息。因此，采用二进制更为明智，比如CORAB的IIOP协议。对于含有大量的SOAP数据消息q行压包和解包操作将耗费大量的CPU旉。请不要忘记QWEB服务的诞生背景，它只是ؓ集成应用而来的，而不是替换现有的高性能中间件^台技术。否则，׃需要用web服务了?/p>
XML文档和^台无x，借助于标准化的XML文档QWEB服务能够帮助集成异构的分布式pȝ。在实际应用开发过E中Q它h许多优势Q比如松耦合、^台无x、遵循XML斚w的标准、能够合q不同的XML技术等。借助于XML能够实现应用和中间gq_的松耦合Q这是很重要的优ѝ?br />
比如在开发EJBlgӞ客户和服务器端同事需要用组件接口。一旦组件接口发生变动，比如需要往Ҏ{中新增参敎ͼ则EJBlg本n需要重新构建、集成、部|Ӏ当Ӟ客户也逃脱不了重新~译的命q。因此，它们之间q没有实现松耦合Q开发者不能独立的开发应用组件。否则，一旦某些组件发生变动，应用的其他部分也需要变动。我们都希望应用h良好的扩展性。对ZIIOP的请求消息而言Q所有的参与者必M用相同的cd信息Q否则不能够正确Ҏ息进行解包操作。而且Q在IIOP技术领域中Q应用必能够理解消息的所有内宏V如果基于XML和XML消息开发应用，则这些限制将不复存在?br />
J2EEq_技术对WEB服务提供了一的支持能力。无论WEB服务实现Q还是WEB服务客户Q都可以使用JAVA语言开发完成。在J2EE中，使用WEB服务同RMI、RMI-IIOPq没有多大区别。他们都具体传输层屏蔽掉，使得开发者能够专注于业务逻辑?br />
JSR921规范Q即实现企业WEB服务Q定义了WEB服务~程模型。它使用术语portlgQ描qweb服务的服务器端视图。它是服务接口的java实现。而且Q它遵@服务接口到Java的映，q提供了相应的Java实现。需要将它部|ƈq行在容器中。用EJB开发WEB服务需要创qportlg。其中，q需要提供若qXML部v描述W。当Ӟ直接ZEJB实现WEB服务是J2EEq_中实现WEB服务的最大优ѝ?/p>
JAX-RPC服务端点接口Q现在，来开发另一q程接口Q它企业Bean所提供的业务方法都列D出来Q我们称之ؓ服务Endpoint接口(Service Endpoint Interface,SEI)Q下面给Z代码?br />
package com.testproject.ejb.web;/* * Hello服务Endpoint接口 * 需要注意的是，q里使用的是EJB2.1无状态会话Bean,它作为WEB服务端点时可以不提供Home接口和Remote * Locale接口Q它提供的是web服务端点接口Q这个接口扩展了Remote接口?br />
*/public interface HelloInterface extends java.rmi.Remote { public String hello()throws java.rmi.RemoteException;}
JAX-RPC要求WEB服务提供SEIQEJB容器同WEB服务交互旉要用它。JAX-RPC规范要求SEI遵@如下规则Q?br />
1、接口必间接或直接l承java.rmi.Remote.
2、所有的Ҏ必须抛出java.rmi.RemoteException.
3、方法参数和q回cd必须是JAX-RPC支持的JAVAcd?br />
4、SEI中不能包含敞亮?/p>
在J2EE1.4q_中，可以对EJB技术进行了升Q得无状态会话Bean可以直接部v为Web服务端点。这P在J2ee1.4q_下，开发Web服务更加简单。这PEJB2.1中的无状态会话Bean可以?U不同的客户端：本地接口的客L、远E接口的客户端和web服务客户端。EJB的WEB服务客户端视N过WSDL文档描述?br /> 待箋......
]]>
一旦EJB中的成员变量W合如下条gQ则可以认ؓ它是会话状态的l成部分之一?br /> 1、成员变量是非transientcd的java原始cd?br /> 2、成员变量是非transientcd的Java对象cd?br /> 当容器将EJB实例挂vӞ它需要将实例的会话状态写入到二存储源中Q比如文件或者RDBMS中。通过调用EJB实例的ejbPassivate()回调ҎQ容器能够完成实例的挂v工作。借助于ejbPassivate()Ҏ能够告知EJB实例QEJB容器需要挂起它Q这使得释放其持有的资源成ؓ可能。比如EJB实例可能持有的资源有QRDBMSq接、已打开的Socket和文件或者其他Q何资源?br /> 在实际场合中Q客戯用了EJB对象中的某个ҎQ而当时在内存中暂时找不到该EJB对象Q与此同ӞEJB容器持有的企业Bean实例的个数已l到达了讑֮的上限。因此在处理客户h前，容器需要挂hq未使用的EJB实例Q在挂v它后Q容器才能够获得所需的EJB对象?br /> 有状态会话Bean的部|描q符?br />
<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar version="2.1" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd">
<enterprise-beans>
<session>
<ejb-name>Count</ejb-name>
<home>examples.CountHome</home>
<remote>examples.Count</remote>
<ejb-class>examples.CountBean</ejb-class>
<session-type>Stateful</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
</ejb-jar>
<ejb-jar version="2.1" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd">
<enterprise-beans>
<session>
<ejb-name>Count</ejb-name>
<home>examples.CountHome</home>
<remote>examples.Count</remote>
<ejb-class>examples.CountBean</ejb-class>
<session-type>Stateful</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
</ejb-jar>
服务端企业Bean:
package com.wyq.ejb02;
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
/**
* 演示有状态Bean
* 它会初始化val,q提供业务方法?br /> * 该实例演CZ最单的有状态会话Bean,q给Z挂v、激zȝ工作机理?br /> */
public class CountBean implements SessionBean {
//会话状?/span>
public int val;
//业务Ҏ
public int count(){
System.out.println("count");
return ++val;
}
public void ejbCreate(int val)throws CreateException{
this.val = val;
System.out.println("ejbCreate()");
}
public void ejbActivate() throws EJBException, RemoteException {
System.out.println("ejbActivate()");
}
public void ejbPassivate() throws EJBException, RemoteException {
System.out.println("ejbPassivate()");
}
public void ejbRemove() throws EJBException, RemoteException {
System.out.println("ejbRemove()");
}
public void setSessionContext(SessionContext ctx) throws EJBException,
RemoteException {
}
}
客户端调用：import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
/**
* 演示有状态Bean
* 它会初始化val,q提供业务方法?br /> * 该实例演CZ最单的有状态会话Bean,q给Z挂v、激zȝ工作机理?br /> */
public class CountBean implements SessionBean {
//会话状?/span>
public int val;
//业务Ҏ
public int count(){
System.out.println("count");
return ++val;
}
public void ejbCreate(int val)throws CreateException{
this.val = val;
System.out.println("ejbCreate()");
}
public void ejbActivate() throws EJBException, RemoteException {
System.out.println("ejbActivate()");
}
public void ejbPassivate() throws EJBException, RemoteException {
System.out.println("ejbPassivate()");
}
public void ejbRemove() throws EJBException, RemoteException {
System.out.println("ejbRemove()");
}
public void setSessionContext(SessionContext ctx) throws EJBException,
RemoteException {
}
}
package com.wyq.ejb02;
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import com.wyq.ejb01.HelloHome;
/**
* 1、获得JNDI InitialContext上下文?br /> * 2、借助于JNDI,定义Home对象?br /> * 3、用Home对象创徏3个不同的CountEjb对象。因此，q将建立?个不同的会话q程Q而且模拟?个不同的客户?br /> * 4、由于内存中仅能存活2个EJB实例Q因此在创徏Count EJB实例期间QEJB容器需要完成实例的挂v操作?br /> * 5、调用各个EJB对象的count()Ҏ?br /> * 6、最后，删除所有的EJB对象?br /> */
public class CountClient {
/**
* 客户代码CZ
*
* 此时Q创Z3个EJB对象。但我们规定容器Q在内存中最多存?个实例?br /> * 因ؓQ能够看到挂h作的发生?br /> */
public static void main(String[] args) {
try{
/*
* 获得JNDI环境属?br /> */
Properties props = System.getProperties();
/*
* 获得对Home对象的引用，Home对象是EJB对象的工?br /> */
Context ctx = new InitialContext(props);
Object obj = ctx.lookup("CountHome");
CountHome home =(CountHome)javax.rmi.PortableRemoteObject.narrow(obj,CountHome.class);
/*
* 能够持有3个Count对象的数l?nbsp;
*/
Count count[] = new Count[3];
int countVal = 0;
/*
* 创徏EJB实例Qƈ调用各自的count()
*/
System.out.println("Instantiating beans
");
for(int i=0;i<3;i++){
/*
* 创徏EJB对象Qƈ初始化它?br /> */
count[i] = home.create(countVal);
/*
* ?Qƈ打印出来
*/
countVal = count[i].count();
System.out.print(countVal);
/*
* {待1/2U?br /> */
Thread.sleep(500);
}
/*
* 调用各个EJB对象的count()ҎQ从而能够浏览到EJB被挂Pq被成功Ȁz?br /> */
System.out.println("Calling count() on beans");
for(int i=0;i<3;i++){
/*
* ?Qƈ打印出来
*/
countVal = count[i].count();
System.out.println(countVal);
/*
* {待1/2U?br /> */
Thread.sleep(500);
}
/*
* 使用完后Q销毁它?br /> */
for(int i=0;i<3;i++){
count[i].remove();
}
}catch(Exception e){
e.printStackTrace();
}
}
}
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import com.wyq.ejb01.HelloHome;
/**
* 1、获得JNDI InitialContext上下文?br /> * 2、借助于JNDI,定义Home对象?br /> * 3、用Home对象创徏3个不同的CountEjb对象。因此，q将建立?个不同的会话q程Q而且模拟?个不同的客户?br /> * 4、由于内存中仅能存活2个EJB实例Q因此在创徏Count EJB实例期间QEJB容器需要完成实例的挂v操作?br /> * 5、调用各个EJB对象的count()Ҏ?br /> * 6、最后，删除所有的EJB对象?br /> */
public class CountClient {
/**
* 客户代码CZ
*
* 此时Q创Z3个EJB对象。但我们规定容器Q在内存中最多存?个实例?br /> * 因ؓQ能够看到挂h作的发生?br /> */
public static void main(String[] args) {
try{
/*
* 获得JNDI环境属?br /> */
Properties props = System.getProperties();
/*
* 获得对Home对象的引用，Home对象是EJB对象的工?br /> */
Context ctx = new InitialContext(props);
Object obj = ctx.lookup("CountHome");
CountHome home =(CountHome)javax.rmi.PortableRemoteObject.narrow(obj,CountHome.class);
/*
* 能够持有3个Count对象的数l?nbsp;
*/
Count count[] = new Count[3];
int countVal = 0;
/*
* 创徏EJB实例Qƈ调用各自的count()
*/
System.out.println("Instantiating beans
");for(int i=0;i<3;i++){
/*
* 创徏EJB对象Qƈ初始化它?br /> */
count[i] = home.create(countVal);
/*
* ?Qƈ打印出来
*/
countVal = count[i].count();
System.out.print(countVal);
/*
* {待1/2U?br /> */
Thread.sleep(500);
}
/*
* 调用各个EJB对象的count()ҎQ从而能够浏览到EJB被挂Pq被成功Ȁz?br /> */
System.out.println("Calling count() on beans
");for(int i=0;i<3;i++){
/*
* ?Qƈ打印出来
*/
countVal = count[i].count();
System.out.println(countVal);
/*
* {待1/2U?br /> */
Thread.sleep(500);
}
/*
* 使用完后Q销毁它?br /> */
for(int i=0;i<3;i++){
count[i].remove();
}
}catch(Exception e){
e.printStackTrace();
}
}
}
会话Bean的声明周期流E图
1、v初，EJB实例q不存在?br /> 2、EJB容器决定是否需要实例化新的EJB实例。容器将何时实例化新的EJB实例Q取决于容器使用的EJB实例池策略?br /> 3、容器实例化EJB BeancREJB容器调用Class.newInsatance("HelloBean.class");卛_态创建HelloBean实例Q这使得容器不会EJBBeancȝ名字编码在Java代码中。最后，q得容器更具通用性，能够操控M企业Bean.
4、容器调用setSessionContext()Ҏ。这为EJB实例讄了上下文对象。最l，EJB实例能够访问到EJB容器?br /> 5、容器调用ejbCreate().q将初始化EJB实例。由于无状态会话Bean的ejbCreate()Ҏq不存在参数Q因此EJB客户不可能ؓ它提供Q何启动EJB实例的参C息?br /> 6、EJB容器调用EJB实例的业务方法。对于EJB实例提供的所有业务方法，EJB容器都可以用。由于所有EJB实例间不存在区别Q因此完全不同的客户可以调用相同的业务方法。在业务Ҏ调用l束后，各个无状态会话Bean实例依然是相同的Q因此，EJB容器能够针对客户hQ在每个ҎU将各个EJB实例指定l客P即同一客户对同一业务Ҏ的多ơ调用，都可以由不同的EJB实例响应它，当然Q将EJB实例指定l客L具体实现{略取决于具体的EJB容器?br /> 7、最后，容器调用ejbRemove()Ҏ?br />
]]>
<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar version="2.1" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd">
<!--
<ejb-name>:企业Bean的昵U。在部v描述W的其他地方能够引用它，供设|其他参C用?br /> <home>:Home接口的全限定名?br /> <remote>:q程接口的全限定名?br /> <local-home>:本地Home接口的全限定名?br /> <local>:本地接口的全限定名?br /> <ejb-class>:企业Beancȝ全限定名?br /> <session-type>:标识企业Bean是有状态的Q还是无状态的?br /> <transaction-type>:事务cd?br /> -->
<enterprise-beans>
<session>
<ejb-name>Hello</ejb-name>
<home>examples.HelloHome</home>
<remote>examples.Hello</remote>
<local-home>examples.HelloLocalHome</local-home>
<local>examples.HelloLocal</local>
<ejb-class>examples.HelloBean</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
</ejb-jar>
<ejb-jar version="2.1" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd">
<!--
<ejb-name>:企业Bean的昵U。在部v描述W的其他地方能够引用它，供设|其他参C用?br /> <home>:Home接口的全限定名?br /> <remote>:q程接口的全限定名?br /> <local-home>:本地Home接口的全限定名?br /> <local>:本地接口的全限定名?br /> <ejb-class>:企业Beancȝ全限定名?br /> <session-type>:标识企业Bean是有状态的Q还是无状态的?br /> <transaction-type>:事务cd?br /> -->
<enterprise-beans>
<session>
<ejb-name>Hello</ejb-name>
<home>examples.HelloHome</home>
<remote>examples.Hello</remote>
<local-home>examples.HelloLocalHome</local-home>
<local>examples.HelloLocal</local>
<ejb-class>examples.HelloBean</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
</ejb-jar>
Ejb-jar文gQ?br /> HelloWorld EJBlg准备好了之后只需他们打包成Ejb-jar文g。手工创建jar文g
jar cf HelloWorld.jar *
注意Qejb-jar.xml文g必须攄在META-INF子目录中。当EJB容器初次打开Ejb-jar文gӞ在ejb-jar.xml中查找Ejb-jar所包含的EJBlg信息?br />
如何调用EJBlgQ?br /> 目前Q存?cdP
1、基于Java RMI-IIOP的客戗这cd户用JNDI,即通过|络查找对象。另外，它们使用JTA控制事务?br /> 2、CORBA客户。这cdh寻CORBA标准。这对于使用其他语言讉KEJBlg的客戯言Q意义深q，CORBA客户使用CORBA命名服务Q即通过|络查找对象?br /> 讉KEJBlg的步骤：
1、查找Home对象
2、用Home对象创徏EJB对象
3、调用EJB对象的业务方?br /> 4、销毁EJB对象
查找Home对象Q?br /> 开发EJB应用的最主要目标之一是，应用代码能够"一ơ编写，到处q行".如果已部v在机器A上的EJB应用q移到机器B上，EJB应用代码不需要改动，因ؓEJB实现了位|透明性?br /> 借助于命名和目录服务能够实现EJB的位|透明性。命名和目录服务是能够在|络中存储和查找资源的品?br />
在企业部|场景中QEJB服务器用命名服务存储位|信息，而这些位|信息是用于标识资源的，其中的资源涉及到EJB Home对象、企业Bean环境属性、数据库JDBC驱动、消息服务驱动和其他资源{。通过使用命名服务Q应用代码不用将具体机器或资源名编码在代码中，q就是EJB所具备的位|透明性，它得代码具有便携性?br />
为实C|透明性，EJB容器需要屏蔽掉Home对象的具体位|，使得EJBlg的客户代码感知不到其具体位置。客户不用将Home对象宿主的机器名编码于代码中。相反，使用JNDIp够查扑ֈHome对象。物理上QHome对象可以存在于网l上的Q何地方，比如在运行EJB容器的同一q程地址I间中，其他机器上的EJB容器中?br />
客户为定位Home对象Q它必须提供企业Bean的Home对象的JNDI늧。客户用该늧标识所需的Home对象。一旦将EJBlg部v到容器中Q容器会自动HelloHome늧l定到Home对象。因此，在对已部|EJBlg的物理机器位|不知情Ӟ开发者能够在M机器上用该늧查找CqHome对象Q借助于JNDI能够查找到它。JNDI能够在网l上查找命名服务Q或在JNDI树中查找到Home对象Q当ӞHome对象也可能位于客户同一q程中，最后一旦找到Home对象Q客户将获得对它的引用?br />
package com.wyq.ejb;
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
/**
* 客户代码实例Q用于调用简单、无状态会话Bean中的Ҏ?br /> *
*/
public class HelloClient {
public static void main(String[] args)throws Exception {
/*
* 讄属性，用于JNDI初始化，从命令行d属性?br /> */
Properties props = System.getProperties();
/*
* 初始上下文是q接到JNDI树的入口?br /> * 借助于环境属性，能够完成JNDI驱动、服务器的网l地址{的讄
*/
Context ctx = new InitialContext(props);
/*
* 获得对Home对象的引用。Home对象是创建EJB对象的工厂?br /> */
Object obj = ctx.lookup("HelloHome");
/*
* Home对象是RMI-IIOP对象。因此，需要借助于特D的RMI-IIOP造型操作它们造型成RMI-IIOP对象
*/
HelloHome home =(HelloHome)javax.rmi.PortableRemoteObject.narrow(obj,HelloHome.class);
/*
* 使用工厂Q来创徏Hello EJB对象?br /> */
Hello hello = home.create();
/*
* 调用EJB对象的hello()Ҏ。它会将调用委派lEJB Beancd例。一旦接收到响应l果Q它便会q回?br /> */
System.out.println(hello.hello());
/*
* 在用完EJB对象后，需要销毁它。EJB容器负责销毁EJB对象?br /> */
hello.remove();
}
}
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
/**
* 客户代码实例Q用于调用简单、无状态会话Bean中的Ҏ?br /> *
*/
public class HelloClient {
public static void main(String[] args)throws Exception {
/*
* 讄属性，用于JNDI初始化，从命令行d属性?br /> */
Properties props = System.getProperties();
/*
* 初始上下文是q接到JNDI树的入口?br /> * 借助于环境属性，能够完成JNDI驱动、服务器的网l地址{的讄
*/
Context ctx = new InitialContext(props);
/*
* 获得对Home对象的引用。Home对象是创建EJB对象的工厂?br /> */
Object obj = ctx.lookup("HelloHome");
/*
* Home对象是RMI-IIOP对象。因此，需要借助于特D的RMI-IIOP造型操作它们造型成RMI-IIOP对象
*/
HelloHome home =(HelloHome)javax.rmi.PortableRemoteObject.narrow(obj,HelloHome.class);
/*
* 使用工厂Q来创徏Hello EJB对象?br /> */
Hello hello = home.create();
/*
* 调用EJB对象的hello()Ҏ。它会将调用委派lEJB Beancd例。一旦接收到响应l果Q它便会q回?br /> */
System.out.println(hello.hello());
/*
* 在用完EJB对象后，需要销毁它。EJB容器负责销毁EJB对象?br /> */
hello.remove();
}
}
]]>
package com.wyq.ejb;
import javax.ejb.EJBHome;
/**
* Hello EJBlg的Home接口。它由EJB服务器提供的工具实现。Home接口实现
* UC为Home对象。Home对象充当了创建EJB对象的工厂?br /> *
* 在该Home接口中，存在create()Ҏ。它对应于HelloBean中的ejbCreate()Ҏ?br /> */
public interface HelloHome extends EJBHome {
/**
* 创徏EJB对象Q?br /> * @return 新徏的EJB对象?br /> */
Hello create() throws java.rmi.RemoteException,javax.ejb.CreateException;
/**
* 1、ؓ获得对EJB对象的引用，客户需要用createҎ。其中，createҎq能够完?br /> * EJBlg的初始化工作?br /> * 2、createҎ抛出了如下异常：RemoteException和CreateException。由于Home对象是网l?br /> * 使能的基于RMI-IIOP的远E对象，因此要抛出RemoteException异常?br /> */
}
import javax.ejb.EJBHome;
/**
* Hello EJBlg的Home接口。它由EJB服务器提供的工具实现。Home接口实现
* UC为Home对象。Home对象充当了创建EJB对象的工厂?br /> *
* 在该Home接口中，存在create()Ҏ。它对应于HelloBean中的ejbCreate()Ҏ?br /> */
public interface HelloHome extends EJBHome {
/**
* 创徏EJB对象Q?br /> * @return 新徏的EJB对象?br /> */
Hello create() throws java.rmi.RemoteException,javax.ejb.CreateException;
/**
* 1、ؓ获得对EJB对象的引用，客户需要用createҎ。其中，createҎq能够完?br /> * EJBlg的初始化工作?br /> * 2、createҎ抛出了如下异常：RemoteException和CreateException。由于Home对象是网l?br /> * 使能的基于RMI-IIOP的远E对象，因此要抛出RemoteException异常?br /> */
}
本地Home接口是Home接口的高性能版本?br />
package com.wyq.ejb;
import javax.ejb.EJBLocalHome;
/**
* Hello EJBlg的本地Home接口。它由EJB服务器提供的工具实现?br /> * 本地Home接口实现UC为本地Home对象。本地Home对象充当了创建EJB本地对象的工厂?br /> *
*/
public interface HelloLocalHome extends EJBLocalHome {
/**
* 创徏EJB本地对象
* @return q回新创建的EJB本地对象?br /> */
HelloLocal create()throws javax.ejb.CreateException;
}
import javax.ejb.EJBLocalHome;
/**
* Hello EJBlg的本地Home接口。它由EJB服务器提供的工具实现?br /> * 本地Home接口实现UC为本地Home对象。本地Home对象充当了创建EJB本地对象的工厂?br /> *
*/
public interface HelloLocalHome extends EJBLocalHome {
/**
* 创徏EJB本地对象
* @return q回新创建的EJB本地对象?br /> */
HelloLocal create()throws javax.ejb.CreateException;
}
创徏企业Beanc?br />
package com.wyq.ejb;
import java.rmi.RemoteException;
import javax.ejb.EJBException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
/**
* 演示无状态会话Bean.
*
*/
public class HelloBean implements SessionBean {
private SessionContext ctx;
//EJB规范定义的方?/span>
public void ejbCreate(){
System.out.println("ejbCreate()");
}
public void ejbRemove() throws EJBException, RemoteException {
System.out.println("ejbRemove()");
}
public void ejbActivate() throws EJBException, RemoteException {
System.out.println("ejbActivate()");
}
public void ejbPassivate() throws EJBException, RemoteException {
System.out.println("ejbPassivate()");
}
/**
* ׃企业Bean宿主在受容器中Q因此容器能够在M时候调用企业Bean的方法。但如果企业Bean
* 需要查询容器的当前信息的话Q需要ؓEJB提供何种信息呢？比如在EJB中，lg本n可能需要查询当前用?br /> * 的安全性凭证信息?br /> *
* 容器这些信息包含在UC?EJB上下?的对象中。EJB上下文对象是通往EJB容器的关口。其中，EJB?br /> * 下文是容器的l成部分Q开发者能够在企业Bean中访问到它。因此，在某U程度上,EJB上下文是Z业Bean
* 讉K容器提供的回调。该回调有助于企业Bean探知其自w的状态，q修改他们?br /> *
* EJB上下文对于会话Bean、实体Bean、消息驱动Bean而言很有用。比如会话Bean含有会话上下文、实体Bean
* 含有实体上下文、消息驱动Bean含有消息驱动上下文?br /> * 依据EJBcd的不同，开发者能够分别通过调用setSessionContext、setEntityContext、setMessageDivenContext
* Ҏ讄EJB上下文信息?br /> */
public void setSessionContext(SessionContext ctx) throws EJBException,
RemoteException {
this.ctx = ctx;
}
//业务Ҏ
public String hello(){
System.out.println("hello()");
return "Hello,World!";
}
}
import java.rmi.RemoteException;
import javax.ejb.EJBException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
/**
* 演示无状态会话Bean.
*
*/
public class HelloBean implements SessionBean {
private SessionContext ctx;
//EJB规范定义的方?/span>
public void ejbCreate(){
System.out.println("ejbCreate()");
}
public void ejbRemove() throws EJBException, RemoteException {
System.out.println("ejbRemove()");
}
public void ejbActivate() throws EJBException, RemoteException {
System.out.println("ejbActivate()");
}
public void ejbPassivate() throws EJBException, RemoteException {
System.out.println("ejbPassivate()");
}
/**
* ׃企业Bean宿主在受容器中Q因此容器能够在M时候调用企业Bean的方法。但如果企业Bean
* 需要查询容器的当前信息的话Q需要ؓEJB提供何种信息呢？比如在EJB中，lg本n可能需要查询当前用?br /> * 的安全性凭证信息?br /> *
* 容器这些信息包含在UC?EJB上下?的对象中。EJB上下文对象是通往EJB容器的关口。其中，EJB?br /> * 下文是容器的l成部分Q开发者能够在企业Bean中访问到它。因此，在某U程度上,EJB上下文是Z业Bean
* 讉K容器提供的回调。该回调有助于企业Bean探知其自w的状态，q修改他们?br /> *
* EJB上下文对于会话Bean、实体Bean、消息驱动Bean而言很有用。比如会话Bean含有会话上下文、实体Bean
* 含有实体上下文、消息驱动Bean含有消息驱动上下文?br /> * 依据EJBcd的不同，开发者能够分别通过调用setSessionContext、setEntityContext、setMessageDivenContext
* Ҏ讄EJB上下文信息?br /> */
public void setSessionContext(SessionContext ctx) throws EJBException,
RemoteException {
this.ctx = ctx;
}
//业务Ҏ
public String hello(){
System.out.println("hello()");
return "Hello,World!";
}
}
]]>
package com.wyq.ejb;
import javax.ejb.EJBObject;
/**
* Hello EJBlg的远E接?br /> *
* 在客户同EJB对象交互Ӟ需要用这一接口。容器厂商会实现q一接口Q而相应的实现对象
* 是EJB对象。EJB对象会将客户h委派l实际的EJB BeancR?br /> *
*/
public interface Hello extends EJBObject {
/**
* q回Ƣ迎信息l客戗?br /> */
public String hello()throws java.rmi.RemoteException;
/**
* 注意Q远E接口承于javax.ejb.EJBObject.其含义是Q容器生成的EJB对象实现了远E接?EJBObject)
* 即javax.ejb.EJBObject接口中定义的各个Ҏ。其中包括比较不同EJB对象的方法，删除EJB对象的方法等?br /> * 仅实C单个业务Ҏ,即hello().HelloWorld EJBlg的Beanc需要实现helloҎ。另外，׃Hello
* 接口是RMI-IIOPcd的远E接口，因此必须抛出q程异常。这也是企业BeancMhelloҎ{同远E接口中
* helloҎ{的区别?br /> */
}
import javax.ejb.EJBObject;
/**
* Hello EJBlg的远E接?br /> *
* 在客户同EJB对象交互Ӟ需要用这一接口。容器厂商会实现q一接口Q而相应的实现对象
* 是EJB对象。EJB对象会将客户h委派l实际的EJB BeancR?br /> *
*/
public interface Hello extends EJBObject {
/**
* q回Ƣ迎信息l客戗?br /> */
public String hello()throws java.rmi.RemoteException;
/**
* 注意Q远E接口承于javax.ejb.EJBObject.其含义是Q容器生成的EJB对象实现了远E接?EJBObject)
* 即javax.ejb.EJBObject接口中定义的各个Ҏ。其中包括比较不同EJB对象的方法，删除EJB对象的方法等?br /> * 仅实C单个业务Ҏ,即hello().HelloWorld EJBlg的Beanc需要实现helloҎ。另外，׃Hello
* 接口是RMI-IIOPcd的远E接口，因此必须抛出q程异常。这也是企业BeancMhelloҎ{同远E接口中
* helloҎ{的区别?br /> */
}
问EJBlg的业务方法，本地客户应该使用本地接口Q而不是远E接口?br />
package com.wyq.ejb;
import javax.ejb.EJBLocalObject;
/**
* Hello EJBlg的本地接口?br /> *
* 当本地客户同EJB本地对象交互Ӟ需要用这一接口。容器厂商会实现q一接口?br /> * 而相应的实现对象是EJB本地对象。EJB本地对象会将客户h委派l实际的EJB BeancR?br /> *
*/
public interface HelloLocal extends EJBLocalObject {
/**
* q回Ƣ迎信息l客?本地接口l承EjbLocalObject接口Qƈ且不需要抛出RemoteException.
*/
public String hello();
}
import javax.ejb.EJBLocalObject;
/**
* Hello EJBlg的本地接口?br /> *
* 当本地客户同EJB本地对象交互Ӟ需要用这一接口。容器厂商会实现q一接口?br /> * 而相应的实现对象是EJB本地对象。EJB本地对象会将客户h委派l实际的EJB BeancR?br /> *
*/
public interface HelloLocal extends EJBLocalObject {
/**
* q回Ƣ迎信息l客?本地接口l承EjbLocalObject接口Qƈ且不需要抛出RemoteException.
*/
public String hello();
}
]]>
度考虑客户不应该对EJB对象的位|信息进行关注?br /> 得对EJB对象的引用，客户代码需要从EJB对象工厂中请求EJB对象。该工厂负责实例化EJB对象。EJB规范这U工?br />
UC为Home对象。Home对象的职责主要有Q?br /> 1、创建EJB对象
2、查扄有的EJB对象
3、删除EJB对象
同EJB对象一PHome对象专属于特定的EJB容器。Home对象含有容器特定的逻辑Q如负蝲均衡逻辑、借助于图形化理
控制台追t信息等。与此同ӞHome对象也是EJB容器的组成部分，通过容器提供的工兯够自动创建它?br /> Home对象是创建EJB对象的工厂。但是Home对象是如何实例化EJB对象的呢Qؓ创徏Home对象QEJB容器需要掌握这斚w?br />
信息。通过指定Home接口l容器即可完成这斚w信息的注入。Home接口单的定义了用于创建、销毁和查找EJB对象的方法?br />
容器的Home对象实现了Home接口?br /> 使用Home接口存在一个问题，即通过Home接口创徏EJB实例速度很慢Q而且Q借助于远E接口调用EJB实例也是如此。当
讉KEJB对象Ӟ通常会依ơ触发如下内容：
1、客戯用本地存?br /> 2、存根将参数压包成适合|络传输格式
3、存根借助于网l将参数传递给骨架
4、骨架将参数解包成适合Java的格式?br /> 5、骨架调用EJB对象?br /> 6、EJB对象获得所需的中间g服务Q如q接池、事务、安全性和生命周期服务?br /> 7、EJB对象调用企业Bean实例QBean实例处理客户h?br /> 从EJB2.0开始，客户能够通过本地对象(而不是EJB对象)快速、高效的讉K企业Beanlg。具体过E如下：
1、客戯问本地对?br /> 2、本地对象获得所需的中间g服务
3、一旦企业Bean实例处理完客戯求，则将l果q回l本地对象，最l传回给客户?br />
EJB对象指请求拦截器Q远E接口指供请求拦截器使用的接口，Home对象指工厂，Home接口指工厂接口?br /> 本地接口存在的缺?
1、只在同一q程中有效。如在同一应用服务器中存在讉K银行账号实体Bean的银行出U会话Bean,如果EJBlg代码本n依赖
于本地接口实玎ͼ则不能够通过q程讉K到它?br /> 2、通过引用(传址)Q而不是传值来marshal参数?br />
部v描述W：借助于部|描q符文gQEJBlg能够声明其依赖的中间件服务。然后，EJB容器通过部v描述W了解到lg
待用的中间件服务?br />
]]>
和企业Bean本n必须遵@EJB规范。EJB规范要求企业Bean暴露若干所要求的方法，而这些暴露的Ҏ是供EJB容器l一理?br />
们用的Q无论EJBlg部v在何UEJB容器中?br /> EJB2.1规范定义?UEJBlgcd?br /> 会话Bean:会话Bean用于建模业务q程。即为完成某些Q务而存在?br /> 实体Bean:实体Bean用于建模业务数据。他们是数据对象。实体Bean是用于缓存数据库信息的Java对象?br /> 消息驱动Bean:MDBcM于会话Bean,因ؓ它们都是为完成某些Q务而存在的?br />
EJBlg是基于分布式对象构徏的，q程pȝ能够调用分布式对象。当Ӟq程内的客户、进E外的客户及|络中的其他
客户都能够与分布式对象进行交互。具体过E如下：
客户调用存根Q即为客L提供的代理对象。存根负责将|络通信屏蔽掉，q对于客戯言意义p。存根能够?br />
Socket讉K|络中的其他资源Q其间将调用所需的参数构建成|络要求的调用格式?br /> 借助于网l：存根能够实现与服务器端的骨架q行交互。骨架是为服务器端提供的代理对象。骨架负责将|络通信屏蔽
掉，q对于分布式对象而言意义p。骨架能够处理来自Socket的访问请求。当Ӟ骨架q能够将存根构徏好的参数转换?br />
Java表示?br /> 骨架具体的客户调用委派l合适的分布式对象实现。因此，该对象将完成具体的访问请求，q将l果q回l骨架。依
此类推，骨架结果返回给存根Q最后客户将获得分布式对象的响应l果(通过存根获得)?br /> 重要Q存根和服务器端实现的对象都实现了同一接口(UCE接?。其意味着存根克隆了分布式对象的方法签名?br />
调用存根中的Ҏ的客户以为其自n直接调用了分布式对象Q但实际情况是客L接调用存根，而存根处理具体的|络讉K
工作。因此，q可以称之ؓ分布透明性?br /> 分布式对象是对如下几个协作对象的一U抽象：存根、骨架、实现的对象Q单一的参与者不可能构成分布式对象?br /> 分布式对象是很诱人的Q因为开发者能够基于网l构建应用。在开发大型的分布式对象应用的时候，需要借助于中间g
服务Q如事务和安全性?br />
q程对象Q?br /> (1)、企业Bean的业务逻辑需要在BeancM实现。EJB规范定义了企业Beancd实现的若q接口。这些接口得所有的?br />
业Beanc能够暴露同一套接口。各U企业Bean的Beanc都需要实现javax.ejb.EnterpriseBean接口?br /> 当然QEJB规范分别Z话Bean、实体Bean和消息驱动Bean提供了更专属的接口类型，
SessionBean,EntityBean,MessageDriverBean.
(2)、当客户使用企业Beancȝ某实例时Q它q不是直接调用BeancȝҎQEJB容器拦截客戯用，然后委派l企?br />
Bean实例。通过拦截客户hQEJB容器能够自动操作隐式中间件服务?br /> 因此Q在客户和EJBlg_引入了间接层Q即EJB容器。引入的间接层将自n装为单一的网l能对象，即EJB对象Q?br />
EJB对象正是h拦截器。EJB对象是代理对象，它可以与|络、事务、安全性等q行交互。企业Bean客户调用EJB对象提供?br />
ҎQ而不是企业Bean本n。因此，EJB对象必须复制企业BeancL露的业务Ҏ。但是，自动生成EJB对象的工h怎么?br />
道业务方法的?{案是，通过企业Bean提供者提供的接口来实玎ͼ卌E接口。这个接口复制企业BeancL露的业务Ҏ?br />
EJB容器负责理EJBlgQ通过调用EJBlg提供的回调方法，EJB容器能够同EJBlg交互。这些回调方法仅供EJB容器理
EJBlg使用?br /> EJB容器最为重要的一工作是Q提供EJBlgq行的环境。EJB容器宿主了EJBlgQ从而供q程客户调用。因此，可以
认ؓEJB容器充当了客户和EJBlg的中间h。EJB容器负责客戯接到EJBlgQ完成事务协调工作，提供持久化能力，?br />
理EJBlg的声明周期及其他d?br /> EJB的远E接口还需复制企业Beancȝ业务Ҏ。一旦企业Bean客户调用业务ҎQEJB对象把调用操作委派l相应的
BeancR?br /> (3)、Java RMI-IIOP和EJB对象Qjavax.ejb.EJBObjectl承于java.rmi.Remote.M实现了Remote接口的对象都是远E?br />
对象Q即能够从其他JVM中访问到它，q就是Java实现RMI方式。由于容器提供的EJB对象实现了EJBlg的远E接口，因此EJB
对象也间接实Cjava.rmi.Remote接口。EJB对象是具有完整网l功能的RMI-IIOP对象Q供其他JVM或者网l中其他物理机器
讉K。实际上QEJBq程接口仅仅是RMI-IIOPq程接口Q只不过它还遵@EJB规范|了?br /> q程接口q必遵从RMI-IIOP的参C递约定。ƈ不是所有的内容都能够跨JVM传递的。方法中传递的参数必须是符?br />
RMI-IIOPU定的有效JavacdQ如Java原型、序列化对象和RMI-IIOP对象?br /> MQEJB容器需要负责权衡资源管理和理已部|EJBlg的生命周期?
]]>
]]>