stub 和 skeleton 的讲解，自己实现一个stub和skeleton程序

​

RMI的本质就是实现在不同JVM之间的调用,它的实现方法就是在两个JVM中各开一个Stub和Skeleton，二者通过socket通信来实现参数和返回值的传递。

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

Ⅰ：RMI工作原理(自定义实现一个Stub 和 Skeleton)

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

Person代码:

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

2. Person的实现PersonServer类

PersonServer代码:

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

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

Person_Stub代码:

//存根（stub）Person_Stub的实现:

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

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

4. 骨架（Skeleton）的实现

Person_Skeleton代码:

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

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

5. 最后一个，Client的实现

PersonClient 代码:

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

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

注意它的写法：

Person person = new Person_Stub();而不是Person_Stub person = new Person_Stub();为什么？因为要面向接口编程嘛，呵呵。

//RMI实质上就是生成2个类stub，skeleton来进行参数和返回值的传递，采用值传递方式

//类似于以前写的聊天室程序，被传递的对象应实现java.io.Serializable接口