手写RPC通信和服务发现——模拟Dubbo的实现机制（上篇）

文章借鉴了鲁班学院中的思路，在此致以感谢。

背景

如果服务在一个应用中调用，那么不需要考虑那么多，因为所有的调用都在一个进程中。但随着分布式微服务架构的逐渐应用，服务之间的调用越来越复杂，越来越多的调用都需要跨服务、跨进程、跨机器。如何有效合理的来解决这些问题，RPC（远程服务调用）通信应运而生，随之衍生了诸多分布式服务调用夸框架。Dubbo则是其中的一种框架，由阿里团队开发，简单的说，Dubbo 是基于 Java 的RPC 框架。Dubbo 工作分为 4 个角色，分别是服务提供者、服务消费者、注册中心、和监控中心。

手写RPC来模拟Dubbo的简单通信

远程通信底层是采用Socket来实现服务之间互相调用。

服务端

启动一个Socket的Server端来进行服务发布，为了实现多客户端连接，采用线程池实现。
在这里，我们本地启动Socket的服务端，端口号为6666，通过while(true)阻塞等待客户端的连接。
如果客户端有连接，那么服务端执行客户端传递过来的具体方法：

1	`ExecutorService executorService = Executors.newFixedThreadPool(5);` JAVA

启动线程池来对每一个客户端的请求进行进行处理，这样就避免了单线程下多客户端的连接请求会排队等待的问题。
ServerHandler(accept) 该方法为处理客户端的请求。

package com.leehao.rpc.server.request;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ClassName ServerRequest
 * @Description ServerRequest
 * @Author lihao
 * @Date 2019/9/24 19:01
 * @Version 1.0
 **/
public class ServerRequest {
    public void publishServer() throws Exception {
        ServerSocket serverSocket = new ServerSocket(6666);
        //5个线程
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        while (true){
            //阻塞
            System.out.println("wait connect.");
            Socket accept = serverSocket.accept();
            System.out.println("success connect");
            executorService.execute(new ServerHandler(accept ));
        }
    }
}
JAVA

处理客户端的请求
客户端会向服务端发送socket请求数据（服务方法的全称），如com.leehao.rpc.server.dao.OrderDao.query以及方法的参数信息。服务端拿到这些信息后，会做对应的处理，并将结果返回。
为了方便，我们把方法相关的信息（包、类、方法、参数）做了封装，封装为RpcInfo。
注意：该类在客户端和服务端均需要引入，而且包名需保持一致，都为package com.leehao.rpc.info。类似于Dubbo中的api中的model。

package com.leehao.rpc.info;

import java.io.Serializable;

/**
 * @ClassName RpcInfo
 * @Description RpcInfo
 * @Author lihao
 * @Date 2019/9/24 19:13
 * @Version 1.0
 **/
public class RpcInfo implements Serializable {

    private static final long serialVersionUID = 1581945819786934744L;

    private String packageName;
    private String clazzName;
    private String method;
    private Object[] args;

    public String getPackageName() {
        return packageName;
    }

    public void setPackageName(String packageName) {
        this.packageName = packageName;
    }

    public String getClazzName() {
        return clazzName;
    }

    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public Object[] getArgs() {
        return args;
    }

    public void setArgs(Object[] args) {
        this.args = args;
    }
}
JAVA

在ServerHandler中执行用户请求的方法，原理是利用反射机制获取到类、方法、参数，并执行。
注：最后可以选择将执行结果通过Socket返回给客户端，此处只在服务端执行客户端的请求，返回过程略。

package com.leehao.rpc.server.request;

import com.leehao.rpc.info.RpcInfo;

import java.io.ObjectInputStream;
import java.lang.reflect.Method;
import java.net.Socket;

/**
 * @ClassName ServerHandler
 * @Description ServerHandler
 * @Author lihao
 * @Date 2019/9/24 19:29
 * @Version 1.0
 **/
public class ServerHandler implements Runnable {

    private Socket socket;

    public ServerHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());

            RpcInfo rpcInfo = (RpcInfo) inputStream.readObject();

            Class<?> aClass = Class.forName(rpcInfo.getPackageName() + "." + rpcInfo.getClazzName());

            //获取参数类型、个数
            Class[] classes = new Class[rpcInfo.getArgs().length];
            for (int i = 0; i < classes.length; i++) {
                classes[i] = rpcInfo.getArgs()[i].getClass();
            }
            Method method = aClass.getMethod(rpcInfo.getMethod(), classes);
            //执行方法，参数值
            method.invoke(aClass.newInstance(), rpcInfo.getArgs());

        } catch (Exception e) {

        }
    }
}
JAVA

在服务端编写一个简单的查询服务方法，传入name，供客户端进行调用。

package com.leehao.rpc.server.dao;


/**
 * @ClassName OrderDao
 * @Description OrderDao
 * @Author lihao
 * @Date 2019/9/24 18:58
 * @Version 1.0
 **/
public class OrderDao {
   
    public void query(String name){
        System.out.println("name="+name);
    }
  
}
JAVA

在服务端编写一个测试类用来启动服务端

package com.leehao.rpc.server.test;

import com.leehao.rpc.server.request.ServerRequest;

/**
 * @ClassName Test
 * @Description Test
 * @Author lihao
 * @Date 2019/9/24 19:04
 * @Version 1.0
 **/
public class Test {
    public static void main(String[] args) throws Exception {
        new ServerRequest().publishServer();
    }
}
JAVA

客户端

和服务端保持一致，引入RpcInfo。

package com.leehao.rpc.info;

import java.io.Serializable;

/**
 * @ClassName RpcInfo
 * @Description RpcInfo
 * @Author lihao
 * @Date 2019/9/24 19:13
 * @Version 1.0
 **/
public class RpcInfo implements Serializable {

    private static final long serialVersionUID = 1581945819786934744L;

    private String packageName;
    private String clazzName;
    private String method;
    private Object[] args;

    public String getPackageName() {
        return packageName;
    }

    public void setPackageName(String packageName) {
        this.packageName = packageName;
    }

    public String getClazzName() {
        return clazzName;
    }

    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public Object[] getArgs() {
        return args;
    }

    public void setArgs(Object[] args) {
        this.args = args;
    }
}
JAVA

编写Socket客户端来实现和Server的通信，并将需要调用的方法名称传递过去。

package com.leehao.rpc.client.test;

import com.leehao.rpc.info.RpcInfo;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;

/**
 * @ClassName Test
 * @Description Test
 * @Author lihao
 * @Date 2019/9/24 19:05
 * @Version 1.0
 **/
public class Test {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 6666);
        /**
         * 传给服务端需要调用的方法，包括以下
         * 1、包、类、方法名
         * 2、方法参数
         */
        RpcInfo rpcInfo = new RpcInfo();
        rpcInfo.setPackageName("com.leehao.rpc.server.dao");
        rpcInfo.setClazzName("OrderDao");
        rpcInfo.setMethod("query");
        Object[] paras = new Object[]{"leehao"};
        rpcInfo.setArgs(paras);

        //写入

        //装饰类
        ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
        outputStream.writeObject(rpcInfo);
        outputStream.flush();
        socket.close();
        outputStream.close();
        socket.close();


    }
}
JAVA

至此，基本通信已完成。

我们来看下结果

启动服务端，服务端处于等待客户端连接状态：
启动客户端
a、服务端和客户端建立连接
b、客户端向服务端发送请求的方法信息
c、服务端执行客户端请求的方法
d、将执行结果返回给客户端（此处略）
执行后结果如图：

注：第二个wait connect的打印顺序在执行结果name=leehao之前的原因是：并发，不影响结果。