通俗易懂的rpc原理

原帖地址 感谢 作者 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;
  2. public interface HelloService {
  3. String sayHi(String name);
  4. }

2）HelloServices接口实现类：

[java] view plain copy

  1. package services.impl;
  2. import services.HelloService;
  3. public class HelloServiceImpl implements HelloService {
  4. public String sayHi(String name) {
  5. return "Hi, " + name;
  6. }
  7. }

3）服务中心代码实现，代码如下：

[java] view plain copy

  1. package services;
  2. import java.io.IOException;
  3. public interface Server {
  4. public void stop();
  5. public void start() throws IOException;
  6. public void register(Class serviceInterface, Class impl);
  7. public boolean isRunning();
  8. public int getPort();
  9. }

4）服务中心实现类：

[java] view plain copy

  1. package services.impl;
  2. import java.io.IOException;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  5. import java.lang.reflect.Method;
  6. import java.net.InetSocketAddress;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.HashMap;
  10. import java.util.concurrent.ExecutorService;
  11. import java.util.concurrent.Executors;
  12. import services.Server;
  13. public class ServiceCenter implements Server {
  14. private static ExecutorService              executor        = Executors.newFixedThreadPool(Runtime.getRuntime()
  15. .availableProcessors());
  16. private static final HashMap<String, Class> serviceRegistry = new HashMap<String, Class>();
  17. private static boolean                      isRunning       = false;
  18. private static int                          port;
  19. public ServiceCenter(int port) {
  20. this.port = port;
  21. }
  22. public void stop() {
  23. isRunning = false;
  24. executor.shutdown();
  25. }
  26. public void start() throws IOException {
  27. ServerSocket server = new ServerSocket();
  28. server.bind(new InetSocketAddress(port));
  29. System.out.println("start server");
  30. try {
  31. while (true) {
  32. // 1.监听客户端的TCP连接，接到TCP连接后将其封装成task，由线程池执行
  33. executor.execute(new ServiceTask(server.accept()));
  34. }
  35. } finally {
  36. server.close();
  37. }
  38. }
  39. public void register(Class serviceInterface, Class impl) {
  40. serviceRegistry.put(serviceInterface.getName(), impl);
  41. }
  42. public boolean isRunning() {
  43. return isRunning;
  44. }
  45. public int getPort() {
  46. return port;
  47. }
  48. private static class ServiceTask implements Runnable {
  49. Socket clent = null;
  50. public ServiceTask(Socket client) {
  51. this.clent = client;
  52. }
  53. public void run() {
  54. ObjectInputStream input = null;
  55. ObjectOutputStream output = null;
  56. try {
  57. // 2.将客户端发送的码流反序列化成对象，反射调用服务实现者，获取执行结果
  58. input = new ObjectInputStream(clent.getInputStream());
  59. String serviceName = input.readUTF();
  60. String methodName = input.readUTF();
  61. Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
  62. Object[] arguments = (Object[]) input.readObject();
  63. Class serviceClass = serviceRegistry.get(serviceName);
  64. if (serviceClass == null) {
  65. throw new ClassNotFoundException(serviceName + " not found");
  66. }
  67. Method method = serviceClass.getMethod(methodName, parameterTypes);
  68. Object result = method.invoke(serviceClass.newInstance(), arguments);
  69. // 3.将执行结果反序列化，通过socket发送给客户端
  70. output = new ObjectOutputStream(clent.getOutputStream());
  71. output.writeObject(result);
  72. } catch (Exception e) {
  73. e.printStackTrace();
  74. } finally {
  75. if (output != null) {
  76. try {
  77. output.close();
  78. } catch (IOException e) {
  79. e.printStackTrace();
  80. }
  81. }
  82. if (input != null) {
  83. try {
  84. input.close();
  85. } catch (IOException e) {
  86. e.printStackTrace();
  87. }
  88. }
  89. if (clent != null) {
  90. try {
  91. clent.close();
  92. } catch (IOException e) {
  93. e.printStackTrace();
  94. }
  95. }
  96. }
  97. }
  98. }
  99. }

5）客户端的远程代理对象：

[java] view plain copy

  1. package client;
  2. import java.io.ObjectInputStream;
  3. import java.io.ObjectOutputStream;
  4. import java.lang.reflect.InvocationHandler;
  5. import java.lang.reflect.Proxy;
  6. import java.net.InetSocketAddress;
  7. import java.net.Socket;
  8. import java.lang.reflect.Method;
  9. public class RPCClient<T> {
  10. @SuppressWarnings("unchecked")
  11. public static <T> T getRemoteProxyObj(final Class<?> serviceInterface, final InetSocketAddress addr) {
  12. // 1.将本地的接口调用转换成JDK的动态代理，在动态代理中实现接口的远程调用
  13. return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[] { serviceInterface },
  14. new InvocationHandler() {
  15. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  16. Socket socket = null;
  17. ObjectOutputStream output = null;
  18. ObjectInputStream input = null;
  19. try {
  20. // 2.创建Socket客户端，根据指定地址连接远程服务提供者
  21. socket = new Socket();
  22. socket.connect(addr);
  23. // 3.将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
  24. output = new ObjectOutputStream(socket.getOutputStream());
  25. output.writeUTF(serviceInterface.getName());
  26. output.writeUTF(method.getName());
  27. output.writeObject(method.getParameterTypes());
  28. output.writeObject(args);
  29. // 4.同步阻塞等待服务器返回应答，获取应答后返回
  30. input = new ObjectInputStream(socket.getInputStream());
  31. return input.readObject();
  32. } finally {
  33. if (socket != null)
  34. socket.close();
  35. if (output != null)
  36. output.close();
  37. if (input != null)
  38. input.close();
  39. }
  40. }
  41. });
  42. }
  43. }

6）最后为测试类：

[java] view plain copy

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

运行结果：

[java] view plain copy

  1. regeist service HelloService
  2. start server
  3. Hi, test
时间： 2024-11-24 00:31:40

通俗易懂的rpc原理的相关文章

RPC原理解析

1.RPC原理解析 1.1 什么是RPC RPC(Remote Procedure Call Protocol) --远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议.RPC协议假定某些传输协议的存在,如TCP/IP或UDP,为通信程序之间携带信息数据.RPC将原来的本地调用转变为调用远端的服务器上的方法,给系统的处理能力和吞吐量带来了近似于无限制提升的可能.在OSI网络通信模型中,RPC跨域了传输层和应用层.RPC使得开发包括网络分布式多程序在内的应

转发：你应该知道的RPC原理

from : https://www.cnblogs.com/LBSer/p/4853234.html 你应该知道的RPC原理 在学校期间大家都写过不少程序,比如写个hello world服务类,然后本地调用下,如下所示.这些程序的特点是服务消费方和服务提供方是本地调用关系. 而一旦踏入公司尤其是大型互联网公司就会发现,公司的系统都由成千上万大大小小的服务组成,各服务部署在不同的机器上,由不同的团队负责.这时就会遇到两个问题:1)要搭建一个新服务,免不了需要依赖他人的服务,而现在他人的服务都在远

你应该知道的 RPC 原理

在校期间大家都写过不少程序,比如写个hello world服务类,然后本地调用下,如下所示.这些程序的特点是服务消费方和服务提供方是本地调用关系. 而一旦踏入公司,尤其是大型互联网公司就会发现,公司的系统都由成千上万大大小小的服务组成,各服务部署在不同的机器上,由不同的团队负责.这时就会遇到两个问题: (1) 要搭建一个新服务,免不了需要依赖他人的服务,而现在他人的服务都在远端,怎么调用? (2) 其它团队要使用我们的服务,我们的服务该怎么发布以便他人调用? 下文我们将对这两个问题展开探讨: p

RPC原理的简单实现

RpcFramework /* * Copyright 2011 Alibaba.com All right reserved. This software is the * confidential and proprietary information of Alibaba.com ("Confidential * Information"). You shall not disclose such Confidential Information and shall * use

基于RPC原理的dubbo

在校期间大家都写过不少程序,比如写个hello world服务类,然后本地调用下,如下所示.这些程序的特点是服务消费方和服务提供方是本地调用关系. 而一旦踏入公司尤其是大型互联网公司就会发现,公司的系统都由成千上万大大小小的服务组成,各服务部署在不同的机器上,由不同的团队负责.这时就会遇到两个问题:1)要搭建一个新服务,免不了需要依赖他人的服务,而现在他人的服务都在远端,怎么调用?2)其它团队要使用我们的服务,我们的服务该怎么发布以便他人调用?下文我们将对这两个问题展开探讨. Java 1 2

你应该知道的RPC原理

http://www.cnblogs.com/LBSer/p/4853234.html 在学校期间大家都写过不少程序,比如写个hello world服务类,然后本地调用下,如下所示.这些程序的特点是服务消费方和服务提供方是本地调用关系. public interface HelloWorldService { String sayHello(String msg); } public class HelloWorldServiceImpl implements HelloWorldService

【转】Java学习---快速掌握RPC原理及实现

[原文]https://www.toutiao.com/i6592365493435236872/ ?RPC概述 RPC(Remote Procedure Call)即远程过程调用,也就是说两台服务器A,B,一个应用部署在A服务器上,想要调用B服务器上应用提供的函数/方法,由于不在一个内存空间,不能直接调用,需要通过网络来表达调用的语义和传达调用的数据. RPC框架原理 在RPC框架中主要有三个角色:Provider.Consumer和Registry.如下图所示: 节点角色说明: * Serv

分布式架构核心RPC原理

在应用的迭代演进过程中,随着系统访问量提高,业务复杂度提高,代码复杂度提高,应用逐渐从单体式架构向面向服务的分布式架构转变.RPC(Remote Procedure Call Protocol远程过程调用)是分布式架构的核心,按响应方式分如下两种: 同步调用:客户端调用服务方方法,等待直到服务方返回结果或者超时,再继续自己的操作 异步调用:客户端把消息发送给中间件,不再等待服务端返回,直接继续自己的操作. 同步调用的实现方式有WebService和RMI.Web Service提供的服务是基于w

RPC原理详解

RPC 功能目标 RPC 的主要功能目标是让构建分布式计算(应用)更容易,在提供强大的远程调用能力时不损失本地调用的语义简洁性. 为实现该目标,RPC 框架需提供一种透明调用机制让使用者不必显式的区分本地调用和远程调用. 下面我们将具体细化 stub 结构的实现. RPC 调用分类 RPC 调用分以下两种: 同步调用客户方等待调用执行完成并返回结果. 异步调用客户方调用后不用等待执行结果返回,但依然可以通过回调通知等方式获取返回结果. 若客户方不关心调用返回结果,则变成单向异步调用,单向调用不用