ejb中sessionbean的见解

EJB学习笔记五（SessionBean的生命周期）

1.前言

前几篇主要介绍了有状态和无状态、远程和本地调用的SessionBean，这篇介绍一下有关SessionBean的生命周期。SessionBean处于EJB容器管理之下，对于客户端来说是完全透明的。但对于开发者来说，必须要了解SessionBean在EJB容器中的运行规律。

 2.为何会有SessionBean的生命周期

EJB容器创建和管理SessionBean实例，有些时候，可能也需要定制SessionBean的管理过程。例如，我想在创建SessionBean实例的时候初始化字段变量，或者在bean实例被销毁的时候关掉外部资源。这些都可以通过在bean类中定义生命周期方法，采用回调来实现。

 3.无状态SessionBean的生命周期

分析：通过上图可以看出，如果需要改变无状态的SessionBean的生命周期，可以通过使用注解的形式，例如@PostConstruct、@PreDestroy来实现

 4.有状态的SessionBean

有状态的SessionBean声明周期就有点复杂，因为客户端需要维护状态。

分析：从图上可以看出，有状态的SessionBean比无状态的SessionBean多了一个生命周期，去活状态，因而这就多出了两个注解：@PrePassivate和@PostActivate

 5.生命周期分析

 @PostConstruct：当 bean 对象完成实例化后，使用了这个注释的方法会被立即调用。这个注释同时适用于

有状态和无状态的会话 bean。

·@PreDestroy：使用这个注释的方法会在容器从它的对象池中销毁一个无用的或者过期的 bean 实例之前调

用。这个注释同时适用于有状态和无状态的会话 bean。

·@PrePassivate：当一个有状态的 session bean 实例空闲过长的时间，容器将会钝化(passivate)它，并把它的状态保存在缓存当中。使用这个注释的方法会在容器钝化 bean 实例之前调用。这个注释适用于有状态的会话 bean。当钝化后，又经过一段时间该 bean 仍然没有被操作，容器将会把它从存储介质中删除。以后，任何针对该 bean方法的调用容器都会抛出例外。

·@PostActivate：当客户端再次使用已经被钝化的有状态 session bean 时，新的实例被创建，状态被恢复。使用此注释的 session bean 会在 bean 的激活完成时调用。这个注释只适用于有状态的会话 bean。

·@Init：这个注释指定了有状态 session bean 初始化的方法。它区别于@PostConstruct 注释在于：多个@Init注释方法可以同时存在于有状态 session bean 中，但每个 bean 实例只会有一个@Init 注释的方法会被调用。这取决于 bean 是如何创建的（细节请看 EJB 3.0 规范）

@PostConstruct :在@Init 之后被调用。

@Remove，特别是对于有状态 session bean。当应用通过存根对象调用使用了@Remove 注释的方法时，容器就知道在该方法执行完毕后，要把 bean 实例从对象池中移走。

 6.Demo分析

由于远程调用的SessionBean的生命周期比较复杂，下面也就以远程调用生命周期为例，来展示一下。

生命周期方法

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;">package ejbsessionbean;  
2.   
3. import javax.annotation.PostConstruct;  
4. import javax.annotation.PreDestroy;  
5. import javax.ejb.*;  
6.   
7. @Stateful  
8. @Remote(LifeCycle.class)  
9. public class LifeCycleBean implements LifeCycle {  
10.   
11.     public LifeCycleBean(){  
12.         System.out.println("构造函数初始化");  
13.     }  
14.   
15.     public String Say() {  
16.         try {  
17.             Thread.sleep(1000*10);  
18.         } catch (InterruptedException e) {  
19.             e.printStackTrace();  
20.         }  
21.         return "这是会话Bean生命周期应用例子";  
22.     }  
23.   
24.     @Init  
25.     public void initialize () {  
26.       System.out.println("@Init事件触发");  
27.     }     
28.       
29.     @PostConstruct  
30.     public void Construct () {  
31.       System.out.println("@PostConstruct事件触发");  
32.     }  
33.   
34.     @PreDestroy  
35.     public void exit () {  
36.       System.out.println("@PreDestroy事件触发");  
37.     }  
38.   
39.     @PrePassivate  
40.     public void serialize () {  
41.       System.out.println("@PrePassivate事件触发");  
42.     }  
43.   
44.     @PostActivate  
45.     public void activate () {  
46.       System.out.println("@PostActivate事件触发");  
47.     }  
48.   
49.     @Remove  
50.     public void stopSession () {  
51.       System.out.println("@Remove事件触发");   
52.       //调用该方法以通知容器，移除该bean实例、终止会话。方法体可以是空的。  
53.     }  
54.   
55. }  
56. </span>  

测试方法

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. import javax.naming.InitialContext;  
4. import javax.naming.NamingException;  
5.   
6. import ejbsessionbean.LifeCycle;  
7.   
8.   
9. public class testDemo {  
10.     public static void main(String[] args) throws NamingException {  
11.         InitialContext ctx=new InitialContext();  
12.         LifeCycle lifecycle = (LifeCycle) ctx.lookup("LifeCycleBean/remote");  
13.         System.out.println(lifecycle.Say());  
14.         lifecycle.stopSession();  
15.         System.out.println("请注意观察Jboss控制台输出.等待10分钟,容器将会钝化此会话Bean,@PrePassivate注释的方法将会执行");  
16.         System.out.println("你可以调用stopSession方法把会话Bean实例删除。在删除会话Bean时，将触发@PreDestroy事件");  
17.     }  
18. }  
19. </span>  

经过测试，会在创建EJB对象实例的时候，自动的回调各个生命周期方法。

 7.小结

SessionBean的生命周期方法的方法名可以是任意的

SessionBean的生命周期方法不能定义任何形参

SessionBean的生命周期方法的返回值必须是void

SessionBean的生命周期方法不能声明抛出checked异常

SessionBean中相同类型的生命周期方法最多只能定义一个，比如@PostConstruct修饰的方法最多只能有一个。

============================================================

1.前言

在EJB概述的博客中也曾提到过EJB3.0中的SessionBean的两种状态，下面呢，通过本篇博客深入的分析一下，两种状态的SessionBean到底有何区别。

 2.开发一个有状态的SessionBean

2.1、接口

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. public interface StateFulEjbBean {  
4.     public void compute(int i);  
5.     public int getResult();  
6. }  
7. </span></span>  

2.2、实现类

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. import javax.ejb.Remote;  
4. import javax.ejb.Stateful;  
5.   
6. //有状态的SessionBean实现类  
7. @Stateful  
8. //远程访问接口  
9. @Remote  
10. public class StateFulEjbBeanImp implements StateFulEjbBean {  
11.   
12.     private int state;  
13.     public void compute(int i) {  
14.         state=state+i;  
15.     }  
16.   
17.     public int getResult() {  
18.         return state;  
19.     }  
20.   
21. }  
22. </span></span>  

 3.开发一个无状态的SessionBean

有状态和无状态SessionBean，在定义上，只不过是注解形式不一样而已，有状态的注解关键字是StateFul，无状态是StateLess

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. import javax.ejb.Remote;  
4. import javax.ejb.Stateless;  
5.   
6. @Stateless  
7. @Remote  
8. public class StateLessEjbBeanImpl implements StateLessEjbBean{  
9.   
10.     private int state;  
11.     public void compute(int i) {  
12.         state=state+i;  
13.     }  
14.   
15.     public int getResult() {  
16.         return state;  
17.     }  
18.   
19. }  
20. </span></span>  

 4.简单测试

4.1、有状态客户端编写

下面通过一个客户端来分别调用一下，上述Demo中的有状态和无状态的SessionBean，调用方法和上一篇博客类似，就不再详细的介绍。

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. import javax.naming.InitialContext;  
4. import javax.naming.NamingException;  
5.   
6.   
7. public class StatefulEjbClient {  
8.   
9.     public static void main(String[] args) throws NamingException {  
10.         //如果不配置JNDI的话,需要在代码中书写如下  
11. //      Properties props=new Properties();  
12.       
13.           
14.         // 第一次会话  
15.         InitialContext context = new InitialContext();  
16.         StateFulEjbBean ejb1 = (StateFulEjbBean) context  
17.                 .lookup("StateFulEjbBeanImp/remote");  
18.   
19.         System.out.println(ejb1.getResult());  
20.           
21.         ejb1.compute(1);  
22.   
23.         System.out.println(ejb1.getResult());  
24.           
25.           
26.         //第二次会话,新的对象,新的会话,因为是有状态的,所以会创建新的对象,变量不是单例的  
27.         StateFulEjbBean ejb2 = (StateFulEjbBean) context  
28.                 .lookup("StateFulEjbBeanImp/remote");  
29.           
30.           
31.   
32.         System.out.println(ejb2.getResult());  
33.         ejb2.compute(1);  
34.   
35.         System.out.println(ejb2.getResult());  
36.         ejb2.compute(1);  
37.   
38.           
39.     }  
40.   
41. }  
42. </span></span>  

4.2、测试有状态SessionBean

当把EJB部署到JBoss中，测试上述实例的时候，无论测试几次，结果都如下所示

4.3、测试无状态SessionBean

当把EJB项目部署到JBoss中，测试上述实例的时候，每次运行的结果不一样，有一个累加的过程，如下图

 4.4.两种状态的区别

1.关键字上一个是StateFul。另一个是StateLess

2.无状态的SessionBean有以下好处

EJB容器无须为每个客户端分配一个EJB实例（对于有状态的Session Bean而言，系统必须为每个客户端分配一个EJB实例），可以减少创建、维护EJB实例的系统开销

EJB容器无须维护EJB的内部状态，系统开销大大降低。

3.有状态的SessionBean使用场景

客户端数量比较有限 ，当客户端数量巨大时，那就意味着EJB容器要同时为何大量有状态的EJB，这将导致EJB容器的性能直线下降。因此，只有当客户端数量比较固定时，才可以考虑使用有状态的SessionBean

客户端与服务端之间的会话比较多。

================================================================================

一。Enterprise Beans在EJB（Enterprise Java Beans）中定义了两种不同类别的Enterprise Bean ：*会话 Bean （Session Bean）

    *实体Bean （Entity Bean）

    1. 会话 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 的代码分析：

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

public void ejbActivate() {
}//ejbActivate

}//class sailorsy

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

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

4.ejbActivate()方法
和ejbPassivate正好相反，它将被挂起的Bean从新调回。

5.ejbRemove()方法
    它可以清除EJB容器中的Bean。

以上这些是EJB必需的回调方法，我们可以在里面加入自己的方法，加入自己的商务逻辑。

B.Home 接口: sailorsyHome
    import java.rmi.*;
    import javax.ejb.*;

    public interface sailorsyHome extends EJBHome {
    public sailorsyRemote create() throws RemoteException, CreateException;
    }
    C. Remote接口：sailorsyRemote
    import java.rmi.*;
    import javax.ejb.*;

    public interface sailorsyRemote extends EJBObject {
    public java.lang.String showname() throws RemoteException;
    }

    三.调用会话 Bean：sailorsyTestClient1

 import javax.naming.*;
import javax.ejb.*;
import javax.rmi.PortableRemoteObject;
import java.rmi.*;

public class sailorsyTestClient1 {
private sailorsyHome sailorsyHomeObject = null;

//Construct the EJB test client
public sailorsyTestClient1() {
try {
//以下是客户端使用JNDI定位Home对象。
Context ctx = new InitialContext();

//look up jndi name
Object ref = ctx.lookup("sailorsy");

//cast to Home interface
sailorsyHomeObject = (sailorsyHome) PortableRemoteObject.narrow(ref, sailorsyHome.class);

}
catch(Exception e) {
e.printStackTrace();
}
}

//----------------------------------------------------------------------------
// Utility Methods
//----------------------------------------------------------------------------

public sailorsyHome getHome() {
return sailorsyHomeObject;
}
//Main method

public static void main(String[] args) throws Exception{
sailorsyTestClient1 client = new sailorsyTestClient1();
sailorsyRemote sr=client.getHome() .create() ;
String s=sr.showname() ;
system.out.print(s);
// Use the getHome() method of the client object to call Home interface
// methods that will return a Remote interface reference. Then
// use that Remote interface reference to access the EJB.
}
}


    以上的EJB在win2000+jbuilder5/jbuilder6+BAS4.5经过测试。

================================================================

EJB学习笔记三（有状态和无状态SessionBean的区别）

1.前言

在EJB概述的博客中也曾提到过EJB3.0中的SessionBean的两种状态，下面呢，通过本篇博客深入的分析一下，两种状态的SessionBean到底有何区别。

 2.开发一个有状态的SessionBean

2.1、接口

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. public interface StateFulEjbBean {  
4.     public void compute(int i);  
5.     public int getResult();  
6. }  
7. </span></span>  

2.2、实现类

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. import javax.ejb.Remote;  
4. import javax.ejb.Stateful;  
5.   
6. //有状态的SessionBean实现类  
7. @Stateful  
8. //远程访问接口  
9. @Remote  
10. public class StateFulEjbBeanImp implements StateFulEjbBean {  
11.   
12.     private int state;  
13.     public void compute(int i) {  
14.         state=state+i;  
15.     }  
16.   
17.     public int getResult() {  
18.         return state;  
19.     }  
20.   
21. }  
22. </span></span>  

 3.开发一个无状态的SessionBean

有状态和无状态SessionBean，在定义上，只不过是注解形式不一样而已，有状态的注解关键字是StateFul，无状态是StateLess

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. import javax.ejb.Remote;  
4. import javax.ejb.Stateless;  
5.   
6. @Stateless  
7. @Remote  
8. public class StateLessEjbBeanImpl implements StateLessEjbBean{  
9.   
10.     private int state;  
11.     public void compute(int i) {  
12.         state=state+i;  
13.     }  
14.   
15.     public int getResult() {  
16.         return state;  
17.     }  
18.   
19. }  
20. </span></span>  

 4.简单测试

4.1、有状态客户端编写

下面通过一个客户端来分别调用一下，上述Demo中的有状态和无状态的SessionBean，调用方法和上一篇博客类似，就不再详细的介绍。

[java] view plain copy print?

1. <span style="font-family:SimSun;font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.test;  
2.   
3. import javax.naming.InitialContext;  
4. import javax.naming.NamingException;  
5.   
6.   
7. public class StatefulEjbClient {  
8.   
9.     public static void main(String[] args) throws NamingException {  
10.         //如果不配置JNDI的话,需要在代码中书写如下  
11. //      Properties props=new Properties();  
12.       
13.           
14.         // 第一次会话  
15.         InitialContext context = new InitialContext();  
16.         StateFulEjbBean ejb1 = (StateFulEjbBean) context  
17.                 .lookup("StateFulEjbBeanImp/remote");  
18.   
19.         System.out.println(ejb1.getResult());  
20.           
21.         ejb1.compute(1);  
22.   
23.         System.out.println(ejb1.getResult());  
24.           
25.           
26.         //第二次会话,新的对象,新的会话,因为是有状态的,所以会创建新的对象,变量不是单例的  
27.         StateFulEjbBean ejb2 = (StateFulEjbBean) context  
28.                 .lookup("StateFulEjbBeanImp/remote");  
29.           
30.           
31.   
32.         System.out.println(ejb2.getResult());  
33.         ejb2.compute(1);  
34.   
35.         System.out.println(ejb2.getResult());  
36.         ejb2.compute(1);  
37.   
38.           
39.     }  
40.   
41. }  
42. </span></span>  

4.2、测试有状态SessionBean

当把EJB部署到JBoss中，测试上述实例的时候，无论测试几次，结果都如下所示

4.3、测试无状态SessionBean

当把EJB项目部署到JBoss中，测试上述实例的时候，每次运行的结果不一样，有一个累加的过程，如下图

 4.4.两种状态的区别

1.关键字上一个是StateFul。另一个是StateLess

2.无状态的SessionBean有以下好处

EJB容器无须为每个客户端分配一个EJB实例（对于有状态的Session Bean而言，系统必须为每个客户端分配一个EJB实例），可以减少创建、维护EJB实例的系统开销

EJB容器无须维护EJB的内部状态，系统开销大大降低。

3.有状态的SessionBean使用场景

客户端数量比较有限 ，当客户端数量巨大时，那就意味着EJB容器要同时为何大量有状态的EJB，这将导致EJB容器的性能直线下降。因此，只有当客户端数量比较固定时，才可以考虑使用有状态的SessionBean

客户端与服务端之间的会话比较多。

========================================================================

EJB学习: Stateful  SessionBean

二、Stateful  SessionBean

有状态会话Bean与无状态会话Bean在代码上没有任何区别。

作为一个EJB必需有三个类组成：

１、home接口

２、远程接口

３、实现类

为什么要这样设计呢？这是由ＥＪＢ的功能决定的，因为ＥＪＢ的设计初衷是为了分布式计算，也就是在不同的ＪＶＣ中运行，而又不能曝露自己的实现类，只能曝露home接口和远程接口给客户端：

home接口：

RnbEjbHome.java:

import javax.ejb.EJBHome;
import javax.ejb.CreateException;
import java.rmi.RemoteException;

public interface RnbEjbHome extends EJBHome {//目的是产生远程接口
   public RnbEjb create() throws CreateException,RemoteException;
}

远程接口：

RnbEjb.java:

import javax.ejb.EJBObject;
import java.rmi.RemoteException;

public interface RnbEjb extends EJBObject {

//定义了一个与实现类中一样的方法，客户最后也就是调用此方法
   public double getRmb(double usd) throws RemoteException;
}

实现类：

import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import javax.ejb.CreateException;

//有状态会话bean
//多个客户端调用服务器的ejb时，实际上，服务器端只生成一个ejb对 象为其服务，
//顺序是：构造函数-》setSessionContext-》ejbCreate（），目的是节省内存
//客户端可以命令服务端ejb消亡，  remote.remove();

//在有状态Bean下，可以消亡其ejb
//客户端在调用create()方法时就生成ejb对象，没有延迟加载
//特点：你可以用成员变量来定义一些状态信息，你可以用额外的ejbCreate()来初始化这些状态信息
//状态会话Bean其实也可以定义成员变量，但是这些成员变量必须是所有客户共享的如数据库连接，有状态会话Bean可以定义自己的变量
//缺点：消耗资源
//解决办法：服务器：1钝化机制，长期不用的EJB对象，被暂时保存在缓存中，腾出内存，自动调用ejbPassivate()，如果长期不用，服务器自动调用remove()
//2：客户端在使用时要将对应的ejb对象消亡，一般情况下是将远程接口保存在session中，在退出系统时，调用其remove()方法
//尽量不使用有状态的会话Bean，因为可以用Web中有session一来保存状态
public classRnbEjbBean implements SessionBean {

   SessionContext sessionContext;

    publicRnbEjbBean() { //ejb创建时，自动调用
       System.out.println("RnbEjbBean");
    }

    publicvoid ejbCreate() throws CreateException { //ejb创建时，自动调用
       System.out.println("ejbCreate");
    }

    publicvoid setSessionContext(SessionContext sessionContext) {//ejb创建时，自动调用，初始化的工作可以写在这儿
       this.sessionContext = sessionContext;
       System.out.println("setSessionContext");
    }

    publicvoid ejbRemove() { //从接口重写，当ejb消亡时调用，释放资源的代码可以写在这儿
       System.out.println("ejbRemove");
    }

    publicvoid ejbActivate() {//从接口重写，在无状态会话bean中无用，钝化状态到活动状态时调用，
       System.out.println("RnbEjbBean");
    }

    publicvoid ejbPassivate() {　//从接口重写，会话bean中用，钝化时用
       System.out.println("ejbPassivate");
    }

    publicdouble getRmb(double usd) {　//业务逻辑的实现，不能曝露给客户端，和远程接口中的getRmb方法对应
       System.out.println("getRmb");
       return 7.92 * usd;

    }
}

 

同样也有以下四个：

１、ejb-jar.xml（重要：EJB自身的信息）

２、weblogic-ejb-jar.xml（重要：在weblogic中的JNDI配置）

３、ejb-modeler-layout.xml（不太重要，一般不用修改）

４、weblogic-cmp-rdbms-jar.xml（实体Bean的CMP创建会用到）

 

ejb-jar.xml:这个配置文件就把home接口、远程（remote）接口、实现类绑定在一起了

<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems,Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
<ejb-jar>
 <display-name>rmb</display-name>
 <enterprise-beans>
   <session>
     <ejb-name>RnbEjb</ejb-name><!--EJB名称-->
     <home>prormb.RnbEjbHome</home>　　<!--定义home接口-->
     <remote>prormb.RnbEjb</remote>　　<!--定义远程接口-->
     <ejb-class>prormb.RnbEjbBean</ejb-class>　<!--定义实现类-->
     <session-type>Stateful</session-type>　<!--定义实现类的状态，是有状态的,区别就在这儿-->
     <transaction-type>Container</transaction-type>　<!--定义实现类的事务管理类型，这儿是容器管理，也就是由weblogic来管理，当然对应另外一种bean管理事务，也就是自己编写事务管理代码-->
   </session>
 </enterprise-beans>

 <assembly-descriptor>
   <container-transaction>
     <method>
       <ejb-name>RnbEjb</ejb-name><!--EJB名称-->
       <method-name>*</method-name><!--此EJB名称下的方法，这儿用通配符说明是针对所有方法-->
     </method>
     <trans-attribute>Required</trans-attribute><!--要求进行事务管理-->
   </container-transaction>
 </assembly-descriptor>
</ejb-jar>

weblogic-ejb-jar.xml（重要：在weblogic中的JNDI配置)

<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE weblogic-ejb-jar PUBLIC "-//BEA Systems,Inc.//DTD WebLogic 8.1.0 EJB//EN" "http://www.bea.com/servers/wls810/dtd/weblogic-ejb-jar.dtd">
<weblogic-ejb-jar>
 <weblogic-enterprise-bean>
   <ejb-name>RnbEjb</ejb-name><!--EJB名称-->
   <jndi-name>RnbEjb</jndi-name><!--此EJB名称的JNDI名称，非常重要,因为以后客户端就用此名子找到这EJB服务-->
 </weblogic-enterprise-bean>
</weblogic-ejb-jar>

客户端调用：

EjbFactory.java //目的得到home接口

import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class EjbFactory {
   public static Object getEjbHome(String jndi) throws NamingException{
       Client1 client1 = new Client1();
       //连接到Weblogic
       Properties pro = new Properties();
       pro.put(Context.INITIAL_CONTEXT_FACTORY,
               "weblogic.jndi.WLInitialContextFactory");
       pro.put(Context.PROVIDER_URL,
               "t3://localhost:7001"); //指定了weblogic服务器的名称（IP），远程调用体现在这儿
       pro.put(Context.SECURITY_PRINCIPAL,
               "weblogic");
       pro.put(Context.SECURITY_CREDENTIALS,
               "weblogic");
       Context context = new InitialContext(pro);
       //因为remote接口和home接口可以曝露给客户端，具体的实现类不能曝露给客户端
       Object obj = context.lookup(jndi);//根据weblogic-ejb-jar.xml文件中的JNDI名称查找，查找到就是Home接口
       return obj;
   }
}

Client1.java客户调用类
 

import prormb.RnbEjbHome;
import prormb.RnbEjb;
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;

public class Client1 {
   public Client1() {
   }

   public static void main(String[] args) throws
           RemoteException, CreateException, NamingException {
       //JNDI的名称
       String jndi = "RnbEjb";
       //通过工厂得到Home接口
       Object obj = EjbFactory.getEjbHome(jndi);
       //得到home接口的引用
       //ConvertEjbHome home=(ConvertEjbHome)obj;
       //另外一种写法，据说性能好一点
       RnbEjbHome home = (RnbEjbHome)PortableRemoteObject.narrow(obj,
               RnbEjbHome.class);
       //利用home接创建remote接口
       RnbEjb remote = home.create();
       double usd = 499;
       //用remote接调用实现类中的方法
       double rmb = remote.getRmb(usd);
       System.out.println("人民币数量：" + rmb);

   }
}

 有状态会话Bean的生命周期：