.exe sun targe fin rgs [] 網絡技術 ref ket

原帖地址 感謝 作者 http://blog.csdn.net/rulon147/article/details/53814589

一、什麽是RPC

RPC（Remote Procedure Call Protocol）——遠程過程調用協議，它是一種通過網絡從遠程計算機程序上請求服務，而不需要了解底層網絡技術的協議。RPC協議假定某些傳輸協議的存在，如TCP或UDP，為通信程序之間攜帶信息數據。在OSI網絡通信模型中，RPC跨越了傳輸層和應用層。RPC使得開發包括網絡分布式多程序在內的應用程序更加容易。 RPC采用客戶機/服務器模式。請求程序就是一個客戶機，而服務提供程序就是一個服務器。首先，客戶機調用進程發送一個有進程參數的調用信息到服務進程，然後等待應答信息。在服務器端，進程保持睡眠狀態直到調用信息到達為止。當一個調用信息到達，服務器獲得進程參數，計算結果，發送答復信息，然後等待下一個調用信息，最後，客戶端調用進程接收答復信息，獲得進程結果，然後調用執行繼續進行。 有多種 RPC模式和執行。最初由 Sun 公司提出。IETF ONC 憲章重新修訂了 Sun 版本，使得 ONC RPC 協議成為 IETF 標準協議。現在使用最普遍的模式和執行是開放式軟件基礎的分布式計算環境（DCE）。

二、圖例說明

三、java 實例演示

1、實現技術方案

下面使用比較原始的方案實現RPC框架，采用Socket通信、動態代理與反射與Java原生的序列化。

2、RPC框架架構

RPC架構分為三部分：

1. 服務提供者，運行在服務器端，提供服務接口定義與服務實現類。
2. 服務中心，運行在服務器端，負責將本地服務發布成遠程服務，管理遠程服務，提供給服務消費者使用。
3. 服務消費者，運行在客戶端，通過遠程代理對象調用遠程服務。

3、 具體實現

1）服務提供者接口定義與實現，代碼如下：

[java] view plain copy

1. package services;
4. public interface HelloService {
7. String sayHi(String name);
10. }

2）HelloServices接口實現類：

[java] view plain copy

1. package services.impl;
4. import services.HelloService;
7. public class HelloServiceImpl implements HelloService {
10. public String sayHi(String name) {
11. return "Hi, " + name;
12. }
15. }

3）服務中心代碼實現，代碼如下：

[java] view plain copy

1. package services;
4. import java.io.IOException;
7. public interface Server {
8. public void stop();
11. public void start() throws IOException;
14. public void register(Class serviceInterface, Class impl);
17. public boolean isRunning();
20. public int getPort();
21. }

4）服務中心實現類：

[java] view plain copy

1. package services.impl;
8. import java.io.IOException;
9. import java.io.ObjectInputStream;
10. import java.io.ObjectOutputStream;
11. import java.lang.reflect.Method;
12. import java.net.InetSocketAddress;
13. import java.net.ServerSocket;
14. import java.net.Socket;
15. import java.util.HashMap;
16. import java.util.concurrent.ExecutorService;
17. import java.util.concurrent.Executors;
20. import services.Server;
23. public class ServiceCenter implements Server {
24. private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime()
25. .availableProcessors());
28. private static final HashMap<String, Class> serviceRegistry = new HashMap<String, Class>();
31. private static boolean isRunning = false;
34. private static int port;
37. public ServiceCenter(int port) {
38. this.port = port;
39. }
42. public void stop() {
43. isRunning = false;
44. executor.shutdown();
45. }
48. public void start() throws IOException {
49. ServerSocket server = new ServerSocket();
50. server.bind(new InetSocketAddress(port));
51. System.out.println("start server");
52. try {
53. while (true) {
54. // 1.監聽客戶端的TCP連接，接到TCP連接後將其封裝成task，由線程池執行
55. executor.execute(new ServiceTask(server.accept()));
56. }
57. } finally {
58. server.close();
59. }
60. }
63. public void register(Class serviceInterface, Class impl) {
64. serviceRegistry.put(serviceInterface.getName(), impl);
65. }
68. public boolean isRunning() {
69. return isRunning;
70. }
73. public int getPort() {
74. return port;
75. }
78. private static class ServiceTask implements Runnable {
79. Socket clent = null;
82. public ServiceTask(Socket client) {
83. this.clent = client;
84. }
87. public void run() {
88. ObjectInputStream input = null;
89. ObjectOutputStream output = null;
90. try {
91. // 2.將客戶端發送的碼流反序列化成對象，反射調用服務實現者，獲取執行結果
92. input = new ObjectInputStream(clent.getInputStream());
93. String serviceName = input.readUTF();
94. String methodName = input.readUTF();
95. Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
96. Object[] arguments = (Object[]) input.readObject();
97. Class serviceClass = serviceRegistry.get(serviceName);
98. if (serviceClass == null) {
99. throw new ClassNotFoundException(serviceName + " not found");
100. }
101. Method method = serviceClass.getMethod(methodName, parameterTypes);
102. Object result = method.invoke(serviceClass.newInstance(), arguments);
105. // 3.將執行結果反序列化，通過socket發送給客戶端
106. output = new ObjectOutputStream(clent.getOutputStream());
107. output.writeObject(result);
108. } catch (Exception e) {
109. e.printStackTrace();
110. } finally {
111. if (output != null) {
112. try {
113. output.close();
114. } catch (IOException e) {
115. e.printStackTrace();
116. }
117. }
118. if (input != null) {
119. try {
120. input.close();
121. } catch (IOException e) {
122. e.printStackTrace();
123. }
124. }
125. if (clent != null) {
126. try {
127. clent.close();
128. } catch (IOException e) {
129. e.printStackTrace();
130. }
131. }
132. }
135. }
136. }
143. }

5）客戶端的遠程代理對象：

[java] view plain copy

1. package client;
4. import java.io.ObjectInputStream;
5. import java.io.ObjectOutputStream;
6. import java.lang.reflect.InvocationHandler;
7. import java.lang.reflect.Proxy;
8. import java.net.InetSocketAddress;
9. import java.net.Socket;
10. import java.lang.reflect.Method;
13. public class RPCClient<T> {
14. @SuppressWarnings("unchecked")
15. public static <T> T getRemoteProxyObj(final Class<?> serviceInterface, final InetSocketAddress addr) {
16. // 1.將本地的接口調用轉換成JDK的動態代理，在動態代理中實現接口的遠程調用
17. return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[] { serviceInterface },
18. new InvocationHandler() {
19. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
20. Socket socket = null;
21. ObjectOutputStream output = null;
22. ObjectInputStream input = null;
23. try {
24. // 2.創建Socket客戶端，根據指定地址連接遠程服務提供者
25. socket = new Socket();
26. socket.connect(addr);
29. // 3.將遠程服務調用所需的接口類、方法名、參數列表等編碼後發送給服務提供者
30. output = new ObjectOutputStream(socket.getOutputStream());
31. output.writeUTF(serviceInterface.getName());
32. output.writeUTF(method.getName());
33. output.writeObject(method.getParameterTypes());
34. output.writeObject(args);
37. // 4.同步阻塞等待服務器返回應答，獲取應答後返回
38. input = new ObjectInputStream(socket.getInputStream());
39. return input.readObject();
40. } finally {
41. if (socket != null)
42. socket.close();
43. if (output != null)
44. output.close();
45. if (input != null)
46. input.close();
47. }
48. }
49. });
50. }
51. }

6）最後為測試類：

[java] view plain copy

1. package client;
4. import java.io.IOException;
5. import java.net.InetSocketAddress;
8. import services.HelloService;
9. import services.Server;
10. import services.impl.HelloServiceImpl;
11. import services.impl.ServiceCenter;
14. public class RPCTest {
15. public static void main(String[] args) throws IOException {
16. new Thread(new Runnable() {
17. public void run() {
18. try {
19. Server serviceServer = new ServiceCenter(8088);
20. serviceServer.register(HelloService.class, HelloServiceImpl.class);
21. serviceServer.start();
22. } catch (IOException e) {
23. e.printStackTrace();
24. }
25. }
26. }).start();
27. HelloService service = RPCClient
28. .getRemoteProxyObj(HelloService.class, new InetSocketAddress("localhost", 8088));
29. System.out.println(service.sayHi("test"));
30. }
33. }

運行結果：

[java] view plain copy

1. regeist service HelloService
2. start server
3. Hi, test

通俗易懂的rpc原理