How RMI Works

RMI working principle (GO) Work Socketjava Application Server network application RMI (remote method invocation) is a set of Java APIs that support the development of distributed applications. RMI defines a remote object using the Java language interface, which aggregates the Java serialization and Java Remote Method Protocol (Java Protocol). It greatly enhances the ability of Java to develop distributed applications. Simply put, this makes the original program in the same operating system as the method call, which becomes a method call between the different operating systems of the program. This also means that RMI can implement a call to execute a method between different JVMs. Since the Java EE is a distributed program platform, RMI mechanism realizes the communication between the program components and different operating systems.

Is the RMI architecture:



With the RMI architecture, you can already see how RMI works in general:

Server-side services that expose remote methods that can be invoked in the form of interfaces, so that clients can invoke remote methods through the service interface to implement complex business logic. On the server side, the implementation of the methods provided in the interface first, so that the client calls can complete a certain business logic, then need to generate skeleton, in the skeleton to really implement the call to the business method, the completion of the call of the client request process, The result of the fetch method is returned to the client through a serialization mechanism, which is answered. On the client side, the stub is adopted to receive the data (object) returned by the server, that is, it is deserialized here, that is, to read the stream of bytes of the network, and then refactor. In skeleton and stubs, network communication is processed, such as establishing sockets, establishing network connections, and preparing for the actual business needs.

As can be seen, the client does not really perform direct interaction with the server-side components.

Here, there is an important concept, which is the Java object Serialization mechanism. Serialization is the writing of an object to a stream so that the object can be transmitted over the network, which is executed at the output. Deserialization, that is, at the receiving end, in order to be able to obtain the transmitted object, it is necessary to reconstruct the stream of bytes of the object, and get the complete object again. The process of serializing a Java object is to serialize an instance of an existing class, starting with a concrete instance.

The following example is implemented by invoking the server-side method on the client, which can intuitively simulate the RMI work, further deepening the understanding of the RMI working mechanism. I developed tests using Oracle JDeveloper 10g.

Development process

1, in the service interface, the client can make a call method exposed to the client.

The Shirdrnservice interface lists the methods that can be called, and the Shirdrnservice interface is as follows:
Java code

1. Package org.shirdrn.rmi.server;
3. Import java.io.IOException;
5. Public interface Shirdrnservice {
6. Public String GetServerTime () throws IOException, ClassNotFoundException;
7. Public String getgreetings () throws IOException, ClassNotFoundException;
8. }

2, in the server side to really implement these methods in the service interface, the Shirdrnserviceimpl class implements the methods listed in the Shirdrnservice interface.

The implementation of the Shirdrnserviceimpl class is as follows:
Java code

2. Package org.shirdrn.rmi.server;
6. Import java.io.IOException;
10. Import Java.util.Date;
14. Public class Shirdrnserviceimpl implements Shirdrnservice {
16. Public Shirdrnserviceimpl () {
18. }
22. Public String GetServerTime () throws IOException, classnotfoundexception{
24. Date date = new Date ();
26. String time = date.tolocalestring ();
28. return time;
30. }
34. Public String getgreetings () throws IOException, classnotfoundexception{
36. Date date = new Date ();
38. int hour = Date.gethours ();
40. String greetings = "";
42. if (Hour < && hour > 6) {
44. Greetings = "Good morning!"  ";
46. }
48. Else if (hour <= && hour > ) {
50. Greetings = "Good afternoon!"  ";
52. }
54. else{
56. Greetings = "Good evening!"  ";
58. }
60. return greetings;
62. }
64. }

3, the implementation of the client stub

The Shirdrnstub class implements the Shirdrnservice interface, which is the most straightforward implementation of the client's access to the service result data. However, it does not deal directly with the implementation class that actually implements the service interface on the server side, but instead obtains the execution result data of the calling method through the network transmission.
Java code

2. Package org.shirdrn.rmi.client;
6. Import java.io.IOException;
10. Import Java.io.ObjectInputStream;
12. Import Java.io.ObjectOutputStream;
16. Import Java.net.Socket;
20. Import java.net.UnknownHostException;
24. Import Org.shirdrn.rmi.server.ShirdrnService;
28. Public class Shirdrnstub implements shirdrnservice{
32. Socket socket;
36. Public shirdrnstub () {
38. try {
40. Socket = New socket ("56987b31c0b246d",8888);
42. } catch (Unknownhostexception e) {
44. E.printstacktrace ();
46. System.out.println ("[message] Create socket exception: Unknown host name.  ");
48. } catch (IOException e) {
50. E.printstacktrace ();
52. }
54. }
60. Public String GetServerTime () throws IOException, classnotfoundexception {
62. ObjectOutputStream Oos = new ObjectOutputStream (Socket.getoutputstream ());
64. Oos.writeobject ("GetServerTime");
66. Oos.flush ();
68. ObjectInputStream ois = new ObjectInputStream (Socket.getinputstream ());
70. return (String) ois.readobject ();
72. }
76. Public String getgreetings () throws IOException, classnotfoundexception {
78. ObjectOutputStream Oos = new ObjectOutputStream (Socket.getoutputstream ());
80. Oos.writeobject ("getgreetings");
82. Oos.flush ();
84. ObjectInputStream ois = new ObjectInputStream (Socket.getinputstream ());
86. return (String) ois.readobject ();
88. }
90. }

4, the implementation of server-side skeleton

The Shirdrnskeleton class inherits the thread, so it can start the server thread, and it is a single thread. In Shirdrnskeleton, there is a real interaction with the class that provides the service implementation. After establishing the connection, first obtains the method which the client calls, according to the customer's choice to directly interacts with the service realization, executes the method obtains the execution result data, thus serializes the result data, transmits to the customer through the network to complete the reply process.

After instantiating an instance of the Shirdrnskeleton class, start the thread, which is much like a server-side listener that listens for client actions to complete the service request.
Java code

2. Package org.shirdrn.rmi.server;
6. Import Java.io.ObjectInputStream;
10. Import Java.io.ObjectOutputStream;
14. Import Java.net.ServerSocket;
16. Import Java.net.Socket;
20. Public class Shirdrnskeleton extends Thread {
22. Shirdrnserviceimpl Shirdrnserviceimpl;
24. Public Shirdrnskeleton (Shirdrnserviceimpl shirdrnserviceimpl) {
26. This.shirdrnserviceimpl = Shirdrnserviceimpl;
28. }
30. public Void Run () {
32. try {
34. ServerSocket serversocket = new ServerSocket (8888);
36. Socket socket = serversocket.accept ();
38. While (socket! = null) {
40. ObjectInputStream ois = new ObjectInputStream (Socket.getinputstream ());
42. String method = (string) ois.readobject ();
44. if (method.equals ("GetServerTime")) {
46. String servertime = Shirdrnserviceimpl.getservertime ();
48. ObjectOutputStream Oos = new ObjectOutputStream (Socket.getoutputstream ());
50. Oos.writeobject (Servertime);
52. Oos.flush ();
54. }
56. if (method.equals ("getgreetings")) {
58. String greetings = shirdrnserviceimpl.getgreetings ();
60. ObjectOutputStream Oos = new ObjectOutputStream (Socket.getoutputstream ());
62. Oos.writeobject (Greetings);
64. Oos.flush ();
66. }
68. }
70. } catch (Exception e) {
72. E.printstacktrace ();
74. }
76. }
80. public static void Main (string[] args) {
82. Shirdrnserviceimpl SSI = new Shirdrnserviceimpl ();
84. Shirdrnskeleton skeleton = new Shirdrnskeleton (SSI);
86. Skeleton.start ();
88. }
92. }

5. Client test Program

By using the main function in the Shirdrnclient class, the method in the service interface provided by the server side is implemented to invoke:
Java code

2. Package org.shirdrn.rmi.client;
6. Import java.io.IOException;
10. Import Org.shirdrn.rmi.server.ShirdrnService;
14. Public class Shirdrnclient {
16. Public shirdrnclient () {
18. }
22. public static void Main (string[] args) throws IOException,
24. classnotfoundexception {
26. Shirdrnservice stub = new Shirdrnstub ();
28. System.out.println ("Getting server time ...");
30. SYSTEM.OUT.PRINTLN ("Server Time:" +stub.getservertime ());
32. System.out.println ("getting greetings ...");
34. System.out.println ("Greeting:" +stub.getgreetings ());
36. }
38. }

6. Test process


Summary of Experience

1, the client is directly through the instantiation of a stub, because the stub implements the interface exposed by the service party, so you can directly through a stub instance to invoke the service method. However, this does not directly invoke the implementation of the service interface of the provider.

2, the service side has the real realization of the service interface. And the real invocation of the service interface implementation class is in the server-side skeleton, in the skeleton is responsible for invoking the real service implementation, the execution results are returned to the client, masking the implementation details of the method call.

3, the client stub and server-side skeleton established network connection between the network communication, the main is to carry out the results of transmission/reception, skeleton the results through the network to the client, and the stub through the proxy interface to receive the resulting data transmission.

How RMI Works