EJB工作原理学习�W�记�Q��{载）

hardson — Fri, 13 Jul 2007 03:17:00 GMT

EJB工作原理学习�W�记

个�h感觉该文章写得相当详�l�，推荐大家阅读

1 RMI工作原理
2 websphere实现
3 weblogic实现
4 理解体会

1�Q�RMI工作原理

RMI的本质就是实现在不同JVM之间的调�?它的实现�Ҏ(gu��)��是在两个JVM中各开一个Stub和Skeleton�Q�二者通过socket通信来实现参数和�q�回值的传递�?

有关RMI的例子代码网上可以找��C��，但绝大部分都是通过extend the interface java.rmi.Remote实现�Q�已�l�封装的很完善了�Q�不免��人有��N��看花的感觉。下面的例子是我在《Enterprise JavaBeans》里看到的，虽然很粗�p�，但很直观�Q�利于很快了解它的工作原理�?

1. 定义一个Person的接口，其中有两个business method, getAge() 和getName()

代码:

public interface Person {
public int getAge() throws Throwable;
public String getName() throws Throwable;
}

2. Person的实现PersonServer�c?
代码:

public class PersonServer implements Person {
int age;
String name;

     public PersonServer(String name, int age) {
         this.age = age;
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public String getName() {
         return name;
     }
}

3. 好，我们现在要在Client机器上调用getAge()和getName()�q�两个business

method�Q�那么就得编写相应的Stub(Client�?和Skeleton(Server�?�E�序。这是Stub的实玎ͼ�
代码:

import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.net.Socket;

public class Person_Stub implements Person {
Socket socket;

     public Person_Stub() throws Throwable {
         // connect to skeleton
         socket = new Socket("computer_name", 9000);
     }

     public int getAge() throws Throwable {
         // pass method name to skeleton
         ObjectOutputStream outStream =
             new ObjectOutputStream(socket.getOutputStream());
         outStream.writeObject("age");
         outStream.flush();

         ObjectInputStream inStream =
             new ObjectInputStream(socket.getInputStream());
         return inStream.readInt();
     }

     public String getName() throws Throwable {
         // pass method name to skeleton
         ObjectOutputStream outStream =
             new ObjectOutputStream(socket.getOutputStream());
         outStream.writeObject("name");
         outStream.flush();

         ObjectInputStream inStream =
             new ObjectInputStream(socket.getInputStream());
         return (String)inStream.readObject();
     }
}

注意�Q�Person_Stub和PersonServer一��P��都implements

Person。它们都实现了getAge()和getName()两个business

method�Q�不同的是PersonServer是真的实玎ͼ�Person_Stub是徏立socket�q�接�Q��ƈ向Skeleton发请求，然后通过

Skeleton调用PersonServer的方法，最后接收返回的�l�果�?

4. Skeleton实现
代码:

import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.net.ServerSocket;

public class Person_Skeleton extends Thread {
PersonServer myServer;

     public Person_Skeleton(PersonServer server) {
         // get reference of object server
         this.myServer = server;
     }

     public void run() {
         try {
             // new socket at port 9000
             ServerSocket serverSocket = new ServerSocket(9000);
             // accept stub's request
             Socket socket = serverSocket.accept();

             while (socket != null) {
                 // get stub's request
                 ObjectInputStream inStream =
                     new ObjectInputStream(socket.getInputStream());
                 String method = (String)inStream.readObject();

                 // check method name
                 if (method.equals("age")) {
                     // execute object server's business method
                     int age = myServer.getAge();
                     ObjectOutputStream outStream =
                         new ObjectOutputStream(socket.getOutputStream());

                     // return result to stub
                     outStream.writeInt(age);
                     outStream.flush();
                 }

                 if(method.equals("name")) {
                     // execute object server's business method
                     String name = myServer.getName();
                     ObjectOutputStream outStream =
                         new ObjectOutputStream(socket.getOutputStream());

                     // return result to stub
                     outStream.writeObject(name);
                     outStream.flush();
                 }
             }
         } catch(Throwable t) {
             t.printStackTrace();
             System.exit(0);
         }
     }

     public static void main(String args []) {
         // new object server
         PersonServer person = new PersonServer("Richard", 34);

         Person_Skeleton skel = new Person_Skeleton(person);
         skel.start();
     }
}

Skeleton�c?extends from Thread�Q�它镉K��在后台运行，随时接收client发过来的request。�ƈ�Ҏ(gu��)��发送过来的

key去调用相应的business method�?

5. 最后一个，Client的实�?
代码:

public class PersonClient {
     public static void main(String [] args) {
         try {
             Person person = new Person_Stub();
             int age = person.getAge();
             String name = person.getName();
             System.out.println(name + " is " + age + " years old");
         } catch(Throwable t) {
             t.printStackTrace();
         }
     }
}

Client的本质是�Q�它要知道Person接口的定义，�q�实例一个Person_Stub�Q�通过Stub来调用business method�Q?/p>

至于Stub怎么��d��Server沟通，Client��׃��用管了�?

注意它的写法�Q?
Person person = new Person_Stub();
而不�?
Person_Stub person = new Person_Stub();

��Z��么？因�ؓ要面向接口编�E�嘛�Q�呵��c�?/p>

//RMI实质上就是生�?个类stub�Q�skeleton来进行参数和�q�回值的传递，采用��g��递方�?/font>

//�c�M��于以前写的聊天室�E�序�Q�被传递的对象应实现java.io.Serializable接口

2�Q�websphere实现

EJB�c�M��?nbsp;
�q�里�l�合WebSphere来讲讲各个类的调用关�p�d��?

假定我们要创��Z��个读取User信息的SessionBean�Q�需要我们写的有3个文�Ӟ��
1. UserServiceHome.java
Home接口

2. UserService.java
Remote接口

3. UserServiceBean.java
Bean实现

WSAD最�l�会生成10个class。其�?个是什么呢�Q�我们一个一个数�q�来�Q?

4. _UserServiceHome_Stub.java
�q�个当然��是Home接口在Client�?动态加�?的Stub�c�M��Q�它implements UserServiceHome�?

5. _EJSRemoteStatelessUserServiceHome_a940aa04_Tie.java
Home接口在Server端的Skeleton�c�，"a940aa04"应该是随机生成的�Q�所有其他的相关class名里都会有这个标�?/p>

�Ԍ��Tie是Corba对Skeleton的叫法�?

6. EJSRemoteStatelessUserServiceHome_a940aa04.java
Home接口在Server端的实现�Q�当�Ӟ��它也implements UserServiceHome�?

7. EJSStatelessUserServiceHomeBean_a940aa04.java
�?6调用�Q�create _UserService_Stub�?��Z��?6不能直接create _UserService_Stub呢？后面再讲�?

8. _UserService_Stub.java
Remote接口在Client�?动态加�?的Stub�c�R��它implements UserService�?

9. _EJSRemoteStatelessUserService_a940aa04_Tie.java
Remote接口在Server端的Skeleton�c�R�?

10. EJSRemoteStatelessUserService_a940aa04.java
Remote接口在Server端的实现�Q�当�Ӟ��它也implements UserService。�ƈ且，它负责调用UserServiceBean—�?/p>

也就是我们所写的Bean实现�c�Z��—里面的business method�?

那么�Q�各个类之间的调用关�p�d��底是怎么��L��呢？��单的��_��是两次RMI循环�?




�W�一个RMI循环
先来看看Client端的�E�序是怎么写的�Q?

代码:

try {
InitialContext ctx = new InitialContext();

     //�W�一�?
     UserServiceHome home =
         (UserServiceHome) PortableRemoteObject.narrow(
             ctx.lookup(JNDIString),
             UserServiceHome.class);

//home: _UserServiceHome_Stub
System.out.println(home.toString());

//�W�二�?
UserService object = home.create();

//ojbect: _UserService_Stub
System.out.println(object.toString());

     //�W�三�?
     int userId = 1;
     UserInfo ui = object.getUserInfo(userId);
}

在第一步之后，我们得到了一个UserServiceHome(interface)定义的对象home�Q�那么，home到底是哪个class�?/p>

instance呢？用debug看一下，知道了home原来��是_UserServiceHome_Stub的实例�?

从第二步开始，��是我们的关注所在，虽然只有��单的一行代码，
UserService object = home.create();
但是他背后的�pȝ��是怎么�q�做的呢�Q�我们进入代码来看吧�Q?

1. 调用home.create()
代码:

UserServiceHome home;
UserService obj = home.create();

2. 实际是调用_UserServiceHome_Stub.create()�Q�在�q�个�Ҏ(gu��)��里面�Q�Stub向Skeleton发送了一个create的字�?/p>

�Q?
代码:

org.omg.CORBA.portable.OutputStream out = _request("create", true);
in = (org.omg.CORBA_2_3.portable.InputStream)_invoke(out);

3. Server端的Skeleton接收Stub发来的request�Q��ƈ调用相应的方法：
代码:

_EJSRemoteStatelessUserServiceHome_a940aa04_Tie._invoke() {
     ......
     switch (method.length()) {
         case 6:
             if (method.equals("create")) {
                 return create(in, reply);
             }
         ......
     }
}

代码:

_EJSRemoteStatelessUserServiceHome_a940aa04_Tie.create() {
     EJSRemoteStatelessUserServiceHome_a940aa04 target = null;
     result = target.create();
     org.omg.CORBA.portable.OutputStream out = reply.createReply();
     Util.writeRemoteObject(out,result);
     return out;
}

4. Skeleton调用的是UserServiceHome的Server端实现类的create�Ҏ(gu��)��
代码:

EJSRemoteStatelessUserServiceHome_a940aa04.create() {
UserService _EJS_result;
_EJS_result = EJSStatelessUserServiceHomeBean_a940aa04.create();
}

5. #4又调用EJSStatelessUserServiceHomeBean_a940aa04.create()
代码:

UserService result = super.createWrapper(new BeanId(this, null));

��x��Q�我们终于结束了�W�一个RMI循环�Q��ƈ得到了Remote接口UserService的Stub�c�_UserService_Stub�Q�就�?5

里面的result�?

�q�里有一个问题，��Z��?4不直接create _UserService_Stub�Q�而又转了一�?5的手呢？因�ؓ#4 extends from

EJSWrapper�Q�它没有能力create Stub�Q�因此必��d��助#5�Q�which extends from EJSHome�Q�这��h��可以生成一�?/p>

Stub。如果不是�ؓ了生成这个Stub�Q�应该可以不�?5�q�一步�?



�W�二个RMI循环
OK, now we got the object which is instanceOf _UserService_Stub, and implements UserService

现在我们的Client端走到第三步了：
UserInfo ui = object.getUserInfo(userId);

�l�箋看代码，开始第二个RMI循环�Q?

1. 调用object.getUserInfo()
代码:

UserService object;
object.getUserInfo(userId);

2. 实际是调用_UserService_Stub.getUserInfo(int

arg0)�Q�在�q�个�Ҏ(gu��)��里面�Q�Stub向Skeleton发送了一个getUserInfo的字串和arg0�q�个参数�Q?

代码:

org.omg.CORBA.portable.OutputStream out = _request("getUserInfo", true);
out.write_long(arg0);
in = (org.omg.CORBA_2_3.portable.InputStream)_invoke(out);

3. Server端的Skeleton接收Stub发来的request�Q��ƈ调用相应的方法：
代码:

_EJSRemoteStatelessUserService_a940aa04_Tie._invoke() {
     switch (method.charAt(5))
     {
         case 83:
             if (method.equals("getUserInfo")) {
                 return getUserInfo(in, reply);
             }
         ......
     }
}

_EJSRemoteStatelessUserService_a940aa04_Tie.getUserInfo() {
     EJSRemoteStatelessUserService_a940aa04 target = null;
     int arg0 = in.read_long();
     UserDTO result = target.getUserInfo(arg0);
     org.omg.CORBA_2_3.portable.OutputStream out = reply.createReply();
     out.write_value(result,UserDTO.class);
     return out;
}

4. Skeleton调用的是UserService的Server端实现类的getUserInfo�Ҏ(gu��)��
代码:

EJSRemoteStatelessUserService_a940aa04.getUserInfo() {
UserServiceBean _EJS_beanRef = container.preInvoke(this, 0, _EJS_s);
_EJS_result = _EJS_beanRef.getUserInfo(id);
}

最后的最后，#4�l�于调用了我们写的UserServiceBean里的getUserInfo�Ҏ(gu��)��Q�这才是我们真正惌��d��的事�?/p>

�?

��x��Q�第二个RMI循环也终于结束了�?



调用��程�?nbsp;
回顾一下上面的分析�Q�可以很清晰的看��C��ơRMI循环的过�E�，下图(见链�?描述了整个流�E�：

http://www.pbase.com/image/27229257

黄色�?�Q?�Q?0是程序员要写的，其余是系�l�生成的�?

#1是Home interface, #2�?4都implements 了它�?
#6是Remote interface, #7�?9都implements 了它�?
#10是Bean实现�?

3�Q�weblogic实现
一个远�E�对象至��要包括4个class文�g�Q�远�E�对象；�q�程对象的接口；实现�q�程接口的对象的stub�Q�对象的ske

leton�q?个class文�g�?/p>

在EJB中则臛_��要包�?0个class�Q?/p>

Bean�c�，特定App Server的Bean实现�c?/p>

Bean的remote接口�Q�特定App Server的remote接口实现�c�，特定App

Server的remote接口的实现类的stub�c�d��skeleton�c?/p>

Bean的home接口�Q�特定App Server的home接口实现�c�，特定App

Server的home接口的实现类的stub�c�d��skeleton�c?/p>

和RMI不同的是�Q�EJB中这10个class真正需要用��L��写的只有3个，分别是Bean�c�d��它的remote接口�Q�home接口

�Q�至于其它的7个class到底是怎么生成�Q�被打包在什么地方，或者是否需要更多的�c�L��Ӟ��会根据不同的App

Server表现出比较大的差异，不能一概而论�?/p>

拿Weblogic的来说吧�Q�W(xu��)eblogic的Bean实现�c�，以及两个接口的Weblogic的实现类是在ejbc的时候被打包到EJB

的jar包里面的�Q�这3个class文�g可以看到。而home接口和remote接口的Weblogic的实现类的stub�c�d��skeleton

�c�L��在EJB被部�|�到Weblogic的时候，由Weblogic动态生成stub�c�d��Skeleton�cȝ��字节码，因此看不到这4个类

文�g�?/p>

对于一�ơ客��L��q�程调用EJB�Q�要�l�过两个�q�程对象的多�ơRMI循环。首先是通过JNDI查找Home接口�Q�获得Home

接口的实现类�Q�这个过�E�其实相当复杂，首先是找到Home接口的Weblogic实现�c�，然后创徏一个Home接口的Web

logic实现�cȝ��stub�cȝ��对象实例�Q�将它序列化传送给客户端（注意stub�cȝ��实例是在�W?�ơRMI循环中，由服�?/p>

器动态发送给客户端的�Q�因此不需要客��L��保存Home接口的Weblogic实现�cȝ��stub�c�）�Q�最后客��L��获得该stu

b�cȝ��对象实例�Q�普通的RMI需要在客户端保存stub�c�，而EJB不需要，因�ؓ服务器会把stub�cȝ��对象实例发送给

客户端）�?/p>

客户端拿到服务器�l�它的Home接口的Weblogic实现�cȝ��stub�c�d��象实例以后，调用stub�cȝ��create�Ҏ(gu��)��Q?在代

码上��是home.create()�Q�但是后台要做很多事�?,于是�l�过�W?�ơRMI循环�Q�在服务器端�Q�Home接口的Weblogic

实现�cȝ��skeleton�c�L��到stub�cȝ��调用信息后，由它再去调用Home接口的Weblogic实现�cȝ��create�Ҏ(gu��)��?/p>

在服务端�Q�Home接口的Weblogic实现�cȝ��create�Ҏ(gu��)��再去调用Bean�cȝ��Weblogic实现�cȝ��ejbCreate�Ҏ(gu��)��Q�在�?/p>

务端创徏或者分配一个EJB实例�Q�然后将�q�个EJB实例的远�E�接口的Weblogic实现�cȝ��stub�c�d��象实例序列化�?/p>

送给客户端�?/p>

客户端收到remote接口的Weblogic实现�cȝ��stub�cȝ��对象实例�Q�对该对象实例的�Ҏ(gu��)��调用�Q�在客户端代码中�?/p>

际上��是对remote接口的调用）�Q�将传送给服务器端remote接口的Weblogic实现�cȝ��skeleton�c�d��象，而skele

ton�c�d��象再调用相应的remote接口的Weblogic实现�c�，然后remote接口的Weblogic实现�c�d��去调用Bean�cȝ��We

blogic实现�c�，如此��完成一�ơEJB对象的远�E�调用�?/p>

看了一遍帖子，感觉�q�是没有说太清楚�Q�既然写了帖子，��想��d��把它说清楚�?/p>

先拿普通RMI来说�Q�有4个class�Q�分别是�q�程对象�Q�对象的接口�Q�对象的stub�c�d��skeleton�c�R��而对象本�w�和�?/p>

象的stub�c�d��旉��实现了接口类。而我们在客户端代码调用远�E�对象的时候，虽然在代码中操纵接口�Q�实质上

是在操纵stub�c�，例如�Q?/p>

接口�c�：Hello

�q�程对象�Q�Hello_Server

stub�c�：Hello_Stub

skeleton�c�：Hello_Skeleton

客户端代码要�q�样写：

Hello h = new Hello_Stub();
h.getString();

我们不会�q�样写：

Hello_Stub h = new Hello_Stub();
h.getString();

因�ؓ使用接口适用性更�q�，��q��更换了接口实现类�Q�也不需要更改代码。因此客��L��需要Hello.class和Hello_

Stub.class�q�两个文件。但是对于EJB来说�Q�就不需要Hello_Stub.class�Q�因为服务器会发送给它，但是Hello.

class文�g客户端是省不了的�Q�必��L��。表面上我们的客��L��代码在操�U�Hello�Q�但别忘��C��Hello只是一个接�?/p>

�Q�抽象的�Q�实质上是在操纵Hello_Stub�?/p>

拿Weblogic上的EJB举例子，10个class分别是：

Bean�c�：HelloBean �Q�用��L��写）
Bean�cȝ��Weblogic实现�c�：HelloBean_Impl �Q�EJBC生成�Q?br> Home接口�Q�HelloHome �Q�用��L��写）
Home接口的Weblogic实现�c?((Hello Bean))_HomeImpl�Q�EJBC生成�Q?br> Home接口的Weblogic实现�cȝ��stub�c?((Hello Bean))_HomeImpl_WLStub�Q�部�|�的时候动态生成字节码�Q?br> Home接口的Weblogic实现�cȝ��skeleton�c?((Hello Bean))_HomeImpl_WLSkeleton�Q�部�|�的时候动态生成字节码

�Q?br> Remote接口�Q?Hello �Q�用��L��写）
Remote接口的Weblogic实现�c?((Hello Bean))_EOImpl�Q�EJBC生成�Q?br> Remote接口的Weblogic实现�cȝ��stub�c?((Hello Bean))_EOImpl_WLStub�Q�部�|�的时候动态生成字节码�Q?br> Remote接口的Weblogic实现�cȝ��skeleton�c?((Hello Bean))_EOImpl_WLSkeleton�Q�部�|�的时候动态生成字节码

�Q?/p>

客户端只需要Hello.class和HelloHome.class�q�两个文件�?/p>

((Hello Home)) home = (Home) ((Portable Remote Object)).narrow(ctx.lookup("Hello"), ((Hello

Home)).class);

�q�一行代码是从JNDI获得Home接口�Q�但是请��C��Q�接口是抽象的，那么home�q�个对象到底是什么类的对象实�?/p>

呢？很简单，用toString()输出看一下就明白了，下面一行是输出�l�果�Q?/p>

((Hello Bean))_HomeImpl_WLStub@18c458

�q�表明home�q�个通过从服务器的JNDI树上查找获得的对象实际上是HelloBean_HomeImpl_WLStub�cȝ��一个实例�?/p>

接下来客��L��代码�Q?/p>

Hello h = home.create()

同样Hello只是一个抽象的接口�Q�那么h对象是什么东西呢�Q�打��C��下：

((Hello Bean))_EOImpl_WLStub@8fa0d1

原来是HelloBean_EOImpl_WLStub的一个对象实例�?/p>

用这个例子来��q�C��遍EJB调用�q�程�Q?/p>

首先客户端JNDI查询�Q�服务端JNDI树上Hello�q�个名字实际上绑定的对象是HelloBean_HomeImpl_WLStub�Q�所�?/p>

服务端将创徏HelloBean_HomeImpl_WLStub的一个对象实例，序列化返回给客户端�?/p>

于是客户端得到home对象�Q�表面上是得到HelloHome接口的实例，实际上是�q�行了一�ơ远�E�调用得��C��HelloBea

n_HomeImpl_WLStub�cȝ��对象实例�Q�别忘记了HelloBean_HomeImpl_WLStub也实��C��HelloHome接口�?/p>

然后home.create()实质上就是HelloBean_HomeImpl_WLStub.create()�Q�该�Ҏ(gu��)��发送信息给HelloBean_HomeIm

pl_WLSkeleton�Q�而HelloBean_HomeImpl_WLSkeleton接受��C��息后�Q�再去调用HelloBean_HomeImpl的create�?/p>

法，��x��完成�W?�ơ完整的RMI循环�?/p>

注意在这�ơRMI循环�q�程中，�q�程对象是HelloBean_HomeImpl�Q�远�E�对象的接口是HelloHome�Q�对象的stub是Hel

loBean_HomeImpl_WLStub�Q�对象的skeleton是HelloBean_HomeImpl_WLSkeleton�?/p>

然后HelloBean_HomeImpl再去调用HelloBean_Impl的ejbCreate�Ҏ(gu��)��Q�而HelloBean_Impl的ejbCreate�Ҏ(gu��)��负

责创建或者分配一个Bean实例�Q��ƈ且创��Z��个HelloBean_EOImpl_WLStub的对象实例�?/p>

�q�一步比较有��的是，在前一步RMI循环中，�q�程对象HelloBean_HomeImpl在客��L��有一个代理类HelloBean_Ho

meImpl_WLStub�Q�但在这一步，HelloBean_HomeImpl自己却充当了HelloBean_Impl的代理类�Q�只不过HelloBean_

HomeImpl不在客户端，而是在服务端�Q�因此不�q�行RMI�?/p>

然后HelloBean_EOImpl_WLStub的对象实例序列化�q�回�l�客��L��Q�这一步也很有��，上次RMI�q�程�Q�主角是Hello

Bean_HomeImpl和它的代理类HelloBean_HomeImpl_WLStub�Q�但�q�这一�ơ换成了HelloBean_EOImpl和它的代理类H

elloBean_EOImpl_WLStub来玩了�?/p>

Hello h = home.create();h.helloWorld();

假设Hello接口有一个helloWorld�q�程�Ҏ(gu��)��Q�那么表面上是在调用Hello接口的helloWorld�Ҏ(gu��)��Q�实际上是在�?/p>

用HelloBean_EOImpl_WLStub的helloWorld�Ҏ(gu��)��?/p>

然后HelloBean_EOImpl_WLStub的helloWorld�Ҏ(gu��)��发送信息给服务器上的HelloBean_EOImpl_WLSkeleton�Q�而H

elloBean_EOImpl_WLSkeleton收到信息以后�Q�再去调用HelloBean_EOImpl的helloWorld�Ҏ(gu��)��。至此，完成�W?��?/p>

完整的RMI循环�q�程�?/p>

在刚才HelloBean_EOImpl是作��E�对象被调用的，它的代理�c�L��HelloBean_EOImpl_WLStub�Q�但现在HelloBea

n_EOImpl要作为HelloBean_Impl的代理类了。现在HelloBean_EOImpl去调用HelloBean_Impl的helloWorld�Ҏ(gu��)��

。注意！HelloBean_Impl�l�承了HelloBean�Q�而HelloBean中的helloWorld�Ҏ(gu��)��是我们亲自编写的代码�Q�现在终

于调用到了我们编写的代码了！

��x��Q�一�ơEJB调用�q�程�l�于完成。在整个�q�程中，服务端主要要调用的类是HelloBean_Impl�Q?Hello

Bean?_HomeImpl�Q�HelloBean_HomeImpl_WLSkeleton�Q�HelloBean_EOImpl�Q�HelloBean_EOImpl_WLSkeleton。客

��L��主要调用的类是HelloBean_HomeImpl_WLStub�Q�HelloBean_EOImpl_WLStub�Q�这两个�c�d��客户端代码中�q�不

会直接出玎ͼ�出现在代码中的类是他们的接口HelloHome和Hello�Q�因此客��L��需要这两个接口文�g�Q�而Stub�?/p>

服务器传送给他们的�?/p>

4 理解体会
��单讲�Q�就是�ؓ了适应分布式开发的需要�?

首先�Q�回到我最后给出的��程图�?
http://www.pbase.com/nobo123/image/27229257

Client端最原始的冲动，肯定是能直接调用#10.UserServiceBean��q��了。那么第一个问题来了，
Client和Server不在一个JVM里�?

�q�好办，我们不是有RMI吗，好，�q�个问题��p��么解决了�Q?
1. UserServiceBeanInterface.getUserInfo()
2. UserServiceBeanStub
3. UserServiceBeanSkeleton
4. UserServiceBean

用着用着�Q�第二个问题来了�Q?
UserServiceBean只有人用�Q�没人管理，transaction logic, security logic, bean instance pooling logic

�q�些不得不考虑的问题��Q出水面了�?

OK�Q�我们想到用一个delegate�Q�EJBObject�Q�来�q�行所有这些logic的管理。client和EJBObject打交道，EJBObj

ect调用UserServiceBean�?

注意�Q�这个EJBObject也是一个Interface�Q?6.UserService�q�个interface正是从它extends而来。�ƈ且EJBObje

ct所��理的这些logic�Q�正是AppServer的一部分�?

现在的流�E�变��Z��Q?
EJBObject
1. UserService.getUserInfo()
2. UserServiceStub
3. UserServiceSkeleton
4. UserServiceImp
5. UserServiceBean

�q�已�l�和整幅��N��?6, #7, #8, #9, #10一一对应了�?

现在能满��x��们的需求了吗？不，�W�三个问题又来了�Q?
既然是分布式开发，那么我当然没理由只用一个Specified Server�Q�我可能需要用到好几个不同的Server�Q��?/p>

且EJBObject也需要管理呀

OK�Q��ؓ了适应你的需要，我们�q�得加再一个HomeObject�Q�首先它来决定用哪个Server(当然�Q�是�׃��用JNDI

String讑֮��?�Q�其�ơ，它来��理EJBObject�?

注意�Q�这个EJBHome也是一个Interface�Q?1.UserServiceHome�q�个interface正是从它extends而来。�ƈ且EJBHo

me��理EJBObject的logic�Q�也是AppServer的一部分�?

现在的调用次序是
1. EJBHome.create()
2. EJBHomeStub
3. EJBHomeSkeleton
4. EJBHomeImp(EJSWrapper)
5. EJSHome

得到EJBObject

6. UserService.getUserInfo()
7. UserServiceStub
8. UserServiceSkeleton
9. UserServiceImp
10. UserServiceBean

现在已经完全和流�E�图的调用顺序一致了�?

//EJB的基��是RMI IIOP,原理�q�不是很难，关键是实现�v来比较绕�Q�一个简单的功能要用10个（或更多）�c�L��实现�Q�但每一个都不是多余的�?/strong>

//EJB的这�U�模式（或说RMI�Q�完全屏蔽了底层的网�l�，�q�很好的实现了对业务代码的保护�?/strong>

hardson 2007-07-13 11:17 发表评论

亚洲不卡AV影片在线播放,在线看亚洲十八禁网站,亚洲视频精品在线观看

EJB工作原理学习�W�记�Q��{载）