目录
  1. 1. 背景
  2. 2. 手写RPC来模拟Dubbo的简单通信
    1. 2.1. 服务端
    2. 2.2. 客户端
    3. 2.3. 我们来看下结果
手写RPC通信和服务发现——模拟Dubbo的实现机制(上篇)

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

背景

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

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

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

服务端

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

    1
    ExecutorService executorService = Executors.newFixedThreadPool(5);

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    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 ));
    }
    }
    }
  2. 处理客户端的请求
    客户端会向服务端发送socket请求数据(服务方法的全称),如com.leehao.rpc.server.dao.OrderDao.query以及方法的参数信息。服务端拿到这些信息后,会做对应的处理,并将结果返回。
    为了方便,我们把方法相关的信息(包、类、方法、参数)做了封装,封装为RpcInfo。
    注意:该类在客户端和服务端均需要引入,而且包名需保持一致,都为package com.leehao.rpc.info。类似于Dubbo中的api中的model。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    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;
    }
    }

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    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) {

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    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);
    }

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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();
    }
    }

客户端

  1. 和服务端保持一致,引入RpcInfo。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    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;
    }
    }
  2. 编写Socket客户端来实现和Server的通信,并将需要调用的方法名称传递过去。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    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();


    }
    }

至此,基本通信已完成。

我们来看下结果

  1. 启动服务端,服务端处于等待客户端连接状态:

  2. 启动客户端
    a、服务端和客户端建立连接
    b、客户端向服务端发送请求的方法信息
    c、服务端执行客户端请求的方法
    d、将执行结果返回给客户端(此处略)
    执行后结果如图:

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

但是,我们发现一个问题,我们在客户端调用服务端接口的时候,包名、方法名等这些参数是已知。如果我们想知道服务端有哪些接口暴露出来了供客户端来调用,或者说客户端可通过某种途径列出所有的服务端可调用的接口,该怎么做呢?
下一篇,手写服务注册来实现服务端接口暴露。

文章作者: 李浩
文章链接: https://leehoward.cn/2019/11/27/手写RPC通信和服务发现——模拟Dubbo的实现机制(上篇)/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 leehoward
打赏
  • 微信
  • 支付宝

评论