EJB工作原理

前两天在这个版块的精华区里翻到了Robbin关于EJB的调用原理的分析，受益非浅，但感觉用纯文字来表达效果似乎不够直观，而且对RMI的阐述也略嫌少了些。这里我根据自己的一点体会，在Robbin帖子的基础上再来说说这个话题，供大家参考。 

首先，我想先说说RMI的工作原理，因为EJB毕竟是基于RMI的嘛。废话就不多讲了，RMI的本质就是实现在不同JVM之间的调用，工作原理图如下： 

 

它的实现方法就是在两个JVM中各开一个Stub和Skeleton，二者通过socket通信来实现参数和返回值的传递。 

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

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

Java代码  

1. public interface Person {  
2.     public int getAge(); throws Throwable;  
3.     public String getName(); throws Throwable;  
4. }  

2. Person的实现PersonServer类 

Java代码  

1. public class PersonServer implements Person {  
2.     int age;  
3.     String name;  
4.   
5.     public PersonServer(String name, int age); {  
6.         this.age = age;  
7.         this.name = name;  
8.     }  
9.   
10.     public int getAge(); {  
11.         return age;  
12.     }  
13.   
14.     public String getName(); {  
15.         return name;  
16.     }  
17. }  

3. 好，我们现在要在Client机器上调用getAge()和getName()这两个business method，那么就得编写相应的Stub(Client端)和Skeleton(Server端)程序。这是Stub的实现： 

Java代码  

1. import java.io.ObjectOutputStream;  
2. import java.io.ObjectInputStream;  
3. import java.net.Socket;  
4.   
5. public class Person_Stub implements Person {  
6.     Socket socket;  
7.   
8.     public Person_Stub(); throws Throwable {  
9.         // connect to skeleton  
10.         socket = new Socket("computer_name", 9000);;  
11.     }  
12.   
13.     public int getAge(); throws Throwable {  
14.         // pass method name to skeleton  
15.         ObjectOutputStream outStream =  
16.             new ObjectOutputStream(socket.getOutputStream(););;  
17.         outStream.writeObject("age");;  
18.         outStream.flush();;  
19.   
20.         ObjectInputStream inStream =  
21.             new ObjectInputStream(socket.getInputStream(););;  
22.         return inStream.readInt();;  
23.     }  
24.   
25.     public String getName(); throws Throwable {  
26.         // pass method name to skeleton  
27.         ObjectOutputStream outStream =  
28.             new ObjectOutputStream(socket.getOutputStream(););;  
29.         outStream.writeObject("name");;  
30.         outStream.flush();;  
31.   
32.         ObjectInputStream inStream =  
33.             new ObjectInputStream(socket.getInputStream(););;  
34.         return (String);inStream.readObject();;  
35.     }  
36. }  

注意，Person_Stub和PersonServer一样，都implements Person。它们都实现了getAge()和getName()两个business method，不同的是PersonServer是真的实现，Person_Stub是建立socket连接，并向Skeleton发请求，然后通过Skeleton调用PersonServer的方法，最后接收返回的结果。 

4. Skeleton实现 

Java代码  

1. import java.io.ObjectOutputStream;  
2. import java.io.ObjectInputStream;  
3. import java.net.Socket;  
4. import java.net.ServerSocket;  
5.   
6. public class Person_Skeleton extends Thread {  
7.     PersonServer myServer;  
8.   
9.     public Person_Skeleton(PersonServer server); {  
10.         // get reference of object server  
11.         this.myServer = server;  
12.     }  
13.   
14.     public void run(); {  
15.         try {  
16.             // new socket at port 9000  
17.             ServerSocket serverSocket = new ServerSocket(9000);;  
18.             // accept stub's request  
19.             Socket socket = serverSocket.accept();;  
20.   
21.             while (socket != null); {  
22.                 // get stub's request  
23.                 ObjectInputStream inStream =  
24.                     new ObjectInputStream(socket.getInputStream(););;  
25.                 String method = (String);inStream.readObject();;  
26.   
27.                 // check method name  
28.                 if (method.equals("age");); {  
29.                     // execute object server's business method  
30.                     int age = myServer.getAge();;  
31.                     ObjectOutputStream outStream =  
32.                         new ObjectOutputStream(socket.getOutputStream(););;  
33.   
34.                     // return result to stub  
35.                     outStream.writeInt(age);;  
36.                     outStream.flush();;  
37.                 }  
38.   
39.                 if(method.equals("name");); {  
40.                     // execute object server's business method  
41.                     String name = myServer.getName();;  
42.                     ObjectOutputStream outStream =  
43.                         new ObjectOutputStream(socket.getOutputStream(););;  
44.   
45.                     // return result to stub  
46.                     outStream.writeObject(name);;  
47.                     outStream.flush();;  
48.                 }  
49.             }  
50.         } catch(Throwable t); {  
51.             t.printStackTrace();;  
52.             System.exit(0);;  
53.         }  
54.     }  
55.   
56.     public static void main(String args []); {  
57.         // new object server  
58.         PersonServer person = new PersonServer("Richard", 34);;  
59.   
60.         Person_Skeleton skel = new Person_Skeleton(person);;  
61.         skel.start();;  
62.     }  
63. }  

Skeleton类 extends from Thread，它长驻在后台运行，随时接收client发过来的request。并根据发送过来的key去调用相应的business method。 

5. 最后一个，Client的实现 

Java代码  

1. public class PersonClient {  
2.     public static void main(String [] args); {  
3.         try {  
4.             Person person = new Person_Stub();;  
5.             int age = person.getAge();;  
6.             String name = person.getName();;  
7.             System.out.println(name + " is " + age + " years old");;  
8.         } catch(Throwable t); {  
9.             t.printStackTrace();;  
10.         }  
11.     }  
12. }  

Client的本质是，它要知道Person接口的定义，并实例一个Person_Stub，通过Stub来调用business method，至于Stub怎么去和Server沟通，Client就不用管了。 

注意它的写法： 
Person person = new Person_Stub(); 
而不是 
Person_Stub person = new Person_Stub(); 

为什么？因为要面向接口编程嘛，呵呵。 

感谢您有耐心看到这里，关于RMI，我想说的就这么多了。但是好象还没写到EJB，本人就累了个半死，算了，我还是先去睡觉，明天再往下续吧。。。

本人没有用过Weblogic，这里就结合WebSphere来讲讲各个类的调用关系吧。 

假定我们要创建一个读取User信息的SessionBean，需要我们写的有3个文件： 
1. UserServiceHome.java 
Home接口 

2. UserService.java 
Remote接口 

3. UserServiceBean.java 
Bean实现 

WSAD最终会生成10个class。其它7个是什么呢？我们一个一个数过来： 

4. _UserServiceHome_Stub.java 
这个当然就是Home接口在Client端(动态加载)的Stub类了，它implements UserServiceHome。 

5. _EJSRemoteStatelessUserServiceHome_a940aa04_Tie.java 
Home接口在Server端的Skeleton类，"a940aa04"应该是随机生成的，所有其他的相关class名里都会有这个标志串，Tie是Corba对Skeleton的叫法。 

6. EJSRemoteStatelessUserServiceHome_a940aa04.java 
Home接口在Server端的实现，当然，它也implements UserServiceHome。 

7. EJSStatelessUserServiceHomeBean_a940aa04.java 
由#6调用，create _UserService_Stub。(为什么#6不能直接create _UserService_Stub呢？后面再讲。) 

8. _UserService_Stub.java 
Remote接口在Client端(动态加载)的Stub类。它implements UserService。 

9. _EJSRemoteStatelessUserService_a940aa04_Tie.java 
Remote接口在Server端的Skeleton类。 

10. EJSRemoteStatelessUserService_a940aa04.java 
Remote接口在Server端的实现，当然，它也implements UserService。并且，它负责调用UserServiceBean——也就是我们所写的Bean实现类——里面的business method。 

那么，各个类之间的调用关系到底是怎么样的呢？简单的说，就是两次RMI循环。

先来看看Client端的程序是怎么写的： 

Java代码  

1. try {  
2.     InitialContext ctx = new InitialContext();;  
3.   
4.     //第一步  
5.     UserServiceHome home =  
6.         (UserServiceHome); PortableRemoteObject.narrow(  
7.             ctx.lookup(JNDIString);,  
8.             UserServiceHome.class);;  
9.   
10.     //home: _UserServiceHome_Stub  
11.     System.out.println(home.toString(););;  
12.   
13.     //第二步  
14.     UserService object = home.create();;  
15.   
16.     //ojbect: _UserService_Stub  
17.     System.out.println(object.toString(););;  
18.   
19.     //第三步  
20.     int userId = 1;  
21.     UserInfo ui = object.getUserInfo(userId);;  
22. }  

在第一步之后，我们得到了一个UserServiceHome(interface)定义的对象home，那么，home到底是哪个class的instance呢？用debug看一下，知道了home原来就是_UserServiceHome_Stub的实例。 

从第二步开始，就是我们的关注所在，虽然只有简单的一行代码， 
UserService object = home.create(); 
但是他背后的系统是怎么运做的呢？我们进入代码来看吧： 

1. 调用home.create() 

Java代码  

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

2. 实际是调用_UserServiceHome_Stub.create()，在这个方法里面，Stub向Skeleton发送了一个create的字串： 

Java代码  

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

3. Server端的Skeleton接收Stub发来的request，并调用相应的方法： 

Java代码  

1. _EJSRemoteStatelessUserServiceHome_a940aa04_Tie._invoke(); {  
2.     ......  
3.     switch (method.length();); {  
4.         case 6:  
5.             if (method.equals("create");); {  
6.                 return create(in, reply);;  
7.             }  
8.         ......  
9.     }  
10. }  

Java代码  

1. _EJSRemoteStatelessUserServiceHome_a940aa04_Tie.create(); {  
2.     EJSRemoteStatelessUserServiceHome_a940aa04 target = null;  
3.     result = target.create();;  
4.     org.omg.CORBA.portable.OutputStream out = reply.createReply();;  
5.     Util.writeRemoteObject(out,result);;  
6.     return out;  
7. }  

4. Skeleton调用的是UserServiceHome的Server端实现类的create方法 

Java代码  

1. EJSRemoteStatelessUserServiceHome_a940aa04.create(); {  
2.     UserService _EJS_result;  
3.     _EJS_result = EJSStatelessUserServiceHomeBean_a940aa04.create();;  
4. }  

5. #4又调用EJSStatelessUserServiceHomeBean_a940aa04.create() 

Java代码  

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

至此，我们终于结束了第一个RMI循环，并得到了Remote接口UserService的Stub类_UserService_Stub，就是#5里面的result。 

这里有一个问题，为什么#4不直接create _UserService_Stub，而又转了一道#5的手呢？因为#4 extends from EJSWrapper，它没有能力create Stub，因此必须借助#5，which extends from EJSHome，这样才可以生成一个Stub。如果不是为了生成这个Stub，应该可以不走#5这一步。

OK, now we got the object which is instanceOf _UserService_Stub, and implements UserService 

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

继续看代码，开始第二个RMI循环： 

1. 调用object.getUserInfo() 

Java代码  

1. UserService object;  
2. object.getUserInfo(userId);;  

2. 实际是调用_UserService_Stub.getUserInfo(int arg0)，在这个方法里面，Stub向Skeleton发送了一个getUserInfo的字串和arg0这个参数： 

Java代码  

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

3. Server端的Skeleton接收Stub发来的request，并调用相应的方法： 

Java代码  

1. _EJSRemoteStatelessUserService_a940aa04_Tie._invoke(); {  
2.     switch (method.charAt(5););  
3.     {  
4.         case 83:  
5.             if (method.equals("getUserInfo");); {  
6.                 return getUserInfo(in, reply);;  
7.             }  
8.         ......  
9.     }  
10. }  
11.   
12. _EJSRemoteStatelessUserService_a940aa04_Tie.getUserInfo(); {  
13.     EJSRemoteStatelessUserService_a940aa04 target = null;  
14.     int arg0 = in.read_long();;  
15.     UserDTO result = target.getUserInfo(arg0);;  
16.     org.omg.CORBA_2_3.portable.OutputStream out = reply.createReply();;  
17.     out.write_value(result,UserDTO.class);;  
18.     return out;  
19. }  

4. Skeleton调用的是UserService的Server端实现类的getUserInfo方法 

Java代码  

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

最后的最后，#4终于调用了我们写的UserServiceBean里的getUserInfo方法，这才是我们真正想要去做的事情。 

至此，第二个RMI循环也终于结束了。

回顾一下上面的分析，可以很清晰的看到两次RMI循环的过程，下图(见链接)描述了整个流程： 

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

黄色的1，6，10是程序员要写的，其余是系统生成的。 

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

写到这里，基本要说的就说完了。这实在是一项累死人的工作，希望您能稀饭。欢迎补充，欢迎摘错。谢谢，呵呵。