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. public interface Person {      
2.     public int getAge() throws Throwable;      
3.     public String getName() throws Throwable;      
4. }

 

 

2. Person的實現PersonServer類

PersonServer代碼:

 

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

 

3. 好，我們現在要在Client機器上調用getAge()和getName()這兩個business method，那么就得編寫相應的Stub(Client端)和Skeleton(Server端)程序。這是Stub的實現：

Person_Stub代碼:

//存根（stub）Person_Stub的實現:

 

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

 

注意，Person_Stub和PersonServer一樣，都implements Person。它們都實現了getAge()和getName()兩個business method，不同的是PersonServer是真的實現，Person_Stub是建立socket連接，並向Skeleton發請求，然后通過Skeleton調用PersonServer的方法，最后接收返回的結果。

4. 骨架（Skeleton）的實現

Person_Skeleton代碼:

 

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

  

Skeleton類 extends from Thread，它長駐在后台運行，隨時接收client發過來的request。並根據發送過來的key去調用相應的business method。

5. 最后一個，Client的實現

PersonClient 代碼:

 

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(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接口