原文链接
想要手写出一个东西我们肯定要先知道一个东西的原理,我们先看看一个RPC框架需要哪些东西。
如何调用他人的远程服务?
由于各服务部署在不同机器,服务间的调用免不了网络通信过程,服务消费方每调用一个服务都要写一坨网络通信相关的代码,不仅复杂而且极易出错。要让网络通信细节对使用者透明,我们需要对通信细节进行封装,我们先看下一个RPC调用的流程涉及到哪些通信细节:
-
服务消费方(client)调用以本地调用方式调用服务;
-
client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体;
-
client stub找到服务地址,并将消息发送到服务端;
-
server stub收到消息后进行解码;
-
server stub根据解码结果调用本地的服务;
-
本地服务执行并将结果返回给server stub;
-
server stub将返回结果打包成消息并发送至消费方;
-
client stub接收到消息,并进行解码;
-
服务消费方得到最终结果。
RPC的目标就是要2~8这些步骤都封装起来,让用户对这些细节透明。
1. 怎么做到透明化远程服务调用?
怎么封装通信细节才能让用户像以本地调用方式调用远程服务呢?对java来说就是使用代理!java代理有两种方式:1) jdk 动态代理;2)字节码生成。尽管字节码生成方式实现的代理更为强大和高效,但代码维护不易,大部分公司实现RPC框架时还是选择动态代理方式。我们这个最简易版的自然也是采用动态代理的方式。
2. 怎么对消息进行编码和解码?
2.1 确定消息数据结构
-
接口名称:在我们的例子里接口名是“HelloWorldService”,如果不传,服务端就不知道调用哪个接口了;
-
方法名:一个接口内可能有很多方法,如果不传方法名服务端也就不知道调用哪个方法;
-
参数类型&参数值参数类型有很多,比如有bool、int、long、double、string、map、list,甚至如struct(class)以及相应的参数值;超时时间
2.2 序列化
从RPC的角度上看,主要看三点:1)通用性,比如是否能支持Map等复杂的数据结构;2)性能,包括时间复杂度和空间复杂度,由于RPC框架将会被公司几乎所有服务使用,如果序列化上能节约一点时间,对整个公司的收益都将非常可观,同理如果序列化上能节约一点内存,网络带宽也能省下不少;3)可扩展性,对互联网公司而言,业务变化飞快,如果序列化协议具有良好的可扩展性,支持自动增加新的业务字段,而不影响老的服务,这将大大提供系统的灵活度。我们的是最简易版所以就采用了jdk序列化的方式来处理。
开始撸代码
-
初始化工程
首先创建2个项目分别是server和client;server项目下两个模块分别是rpc-server-api和rpc-server-provider。
为什么server项目要创建两个模块?
client在调用服务端的服务时需要知道服务端的一些信息,client可以依赖于这个模块。我们的项目中SDK和契约包就是提供了这个功能。而真正的实现是放在rpc-server-provider中。
-
rpc-server-api
public interface IHelloService {
String sayHello(String content);
String saveUser(User user);
}
请求参数类
private String className;
private String methodName;
private Object[] parameters;
-
rpc-server-provider
首先rpc-server-provider是依赖rpc-server-api的。我们写一个实现类,来实现api中定义的接口。
public class HelloServiceImpl implements IHelloService{ @Override public String sayHello(String content) { System.out.println("request in sayHello:"+content); return "Say Hello:"+content; } }
我这么写好了实现远程要怎么才能调用的到呢?我们还需把服务暴露出去,那就需要一个服务暴露的方法。这里就是不断去接受请求,每一个socket交给一个processorHandler来处理。
public class RpcProxyServer { ExecutorService executorService = Executors.newCachedThreadPool(); public void publisher(Object service, int port) { ServerSocket serverSocket = null; try { serverSocket = new ServerSocket(port); while (true) {//不断接受请求 Socket socket = serverSocket.accept();//BIO //每一个socket 交给一个processorHandler来处理 executorService.execute(new ProcessorHandler(socket, service)); } } catch (IOException e) { e.printStackTrace(); } finally { if (serverSocket != null) { try { serverSocket.close(); } catch (IOException e) { e.printStackTrace(); } } } } }
具体processorHandler的代码,从socket中获取请求对象,并是使用请求对象调用本服务方法,同时返回方法执行结果,将返回结果写入socket中。
public class ProcessorHandler implements Runnable { private Socket socket; private Object service; public ProcessorHandler(Socket socket, Object service) { this.socket = socket; this.service = service; } @Override public void run() { try (InputStream inputStream = socket.getInputStream(); ObjectInputStream objectInputStream = new ObjectInputStream(inputStream); ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream())) { //输入流中应该有什么东西? //请求哪个类,方法名称、参数 RpcRequest rpcRequest = (RpcRequest) objectInputStream.readObject(); Object result = invoke(rpcRequest); //反射调用本地服务 objectOutputStream.writeObject(result); objectOutputStream.flush(); } catch (IOException | ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); } } private Object invoke(RpcRequest request) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { //反射调用 Object[] args = request.getParameters(); //拿到客户端请求的参数 Class<?>[] types = new Class[args.length]; //获得每个参数的类型 for (int i = 0; i < args.length; i++) { types[i] = args[i].getClass(); } Class clazz = Class.forName(request.getClassName()); //跟去请求的类进行加载 Method method = clazz.getMethod(request.getMethodName(), types); //sayHello, saveUser找到这个类中的方法 return method.invoke(service, args); } }
大功告成,把服务发布出去。
/** * Hello world! * */ public class App { public static void main( String[] args ){ IHelloService helloService=new HelloServiceImpl(); RpcProxyServer proxyServer=new RpcProxyServer(); // 发布到8080端口 proxyServer.publisher(helloService,8080); } }
-
客户端代码开撸。我们现在在客户端依赖了服务端的api(SDK、契约包)如何才能实现调用远程方法呢?类似于服务端代理类。
public class RpcProxyClient { public <T> T clientProxy(final Class<T> interfaceCls,final String host,final int port){ return (T)Proxy.newProxyInstance(interfaceCls.getClassLoader(), new Class<?>[]{interfaceCls},new RemoteInvocationHandler(host,port)); } }
public class RemoteInvocationHandler implements InvocationHandler {
private String host; private int port; public RemoteInvocationHandler(String host, int port) { this.host = host; this.port = port; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //请求数据的包装 RpcRequest rpcRequest=new RpcRequest(); rpcRequest.setClassName(method.getDeclaringClass().getName()); rpcRequest.setMethodName(method.getName()); rpcRequest.setParameters(args); //远程通信 RpcNetTransport netTransport=new RpcNetTransport(host,port); Object result=netTransport.send(rpcRequest); return result; }
}
处理网络传输的类
public class RpcNetTransport {
private String host; private int port; public RpcNetTransport(String host, int port) { this.host = host; this.port = port; } public Object send(RpcRequest request) { Object result = null; try (//建立连接 Socket socket = new Socket(host, port); //网络socket ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream()); ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream())) { outputStream.writeObject(request); //序列化() outputStream.flush(); result = inputStream.readObject(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } return result; }
最后使用这个远程调用:
public class App {
public static void main(String[] args) {
RpcProxyClient rpcProxyClient = new RpcProxyClient();IHelloService iHelloService = rpcProxyClient.clientProxy(IHelloService.class,"localhost",8080);
}
}
最后画一张来总结一下整个流程