手写RPC机制--理解Dubbo核心

内容

1、Dubbo框架的概述

2、RPC如何理解更加准确

3、手写JAVA版RPC机制

4、理解分布式微服务体系的痛点问题

一、Dubbo概念介绍

1.1、Dubbo是什么？
Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。简单的说，dubbo就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有dubbo这样的分布式服务框架的需求，并且本质上是个服务调用的东东，说白了就是个远程服务调用的分布式框架

其核心部分包含:
1》远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。
2》集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。
3》自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。

1.2. Dubbo能做什么？

1.透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。
2.软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。

3. 服务自动注册与发现，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。

1.3. dubbo的架构

dubbo架构图如下所示：

节点角色说明：
Provider: 暴露服务的服务提供方。
Consumer: 调用远程服务的服务消费方。
Registry: 服务注册与发现的注册中心。
Monitor: 统计服务的调用次调和调用时间的监控中心。
Container: 服务运行容器。

对于这些角色来说，其他都还好，Monitor可能猿友们前期使用会把它忽略，但是后期会发现它的作用十分明显哦，如服务的调用量越来越大，服务的容量问题就暴露出来，这个服务需要多少机器支撑？什么时候该加机器？为了解决这个问题，第一步，要将服务现在每天的调用量，响应时间，都统计出来，作为容量规划的参考指标。其次，要可以动态调整权重，在线上，将某台机器的权重一直加大，并在加大的过程中记录响应时间的变化，直到响应时间到达阀值，记录此时的访问量，再以此访问量乘以机器数反推总容量。

调用关系说明：
0 服务容器负责启动，加载，运行服务提供者。
1 服务提供者在启动时，向注册中心注册自己提供的服务。
2 服务消费者在启动时，向注册中心订阅自己所需的服务。
3 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
4 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
5 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

1.4. dubbo使用方法

Dubbo采用全Spring配置方式，透明化接入应用，对应用没有任何API侵入，只需用Spring加载Dubbo的配置即可，Dubbo基于Spring的Schema扩展进行加载。如果不想使用Spring配置，而希望通过API的方式进行调用（不推荐）
Dubbo采用全Spring配置方式，透明化接入应用，对应用没有任何API侵入，只需用Spring加载Dubbo的配置即可，Dubbo基于Spring的Schema扩展进行加载。

二、RPC概述

1、什么是RPC

RPC（Remote Procedure Call Protocol）远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。简言之，RPC使得程序能够像访问本地系统资源一样，去访问远端系统资源。比较关键的一些方面包括：通讯协议、序列化、资源（接口）描述、服务框架、性能、语言支持等。RPC本身而言是个非常泛的概念，只要满足基于网络跨进程的数据交互服务都可以叫做RPC，可以类似的比喻为J接口。早期的XML+HTTP、json+HTTP、RESTful风格的API都是RPC不同时期的实现。

简单的说，RPC就是从一台机器(客户端)上通过参数传递的方式调用另一台机器(服务器)上的一个函数或方法(可以统称为服务)并得到返回的结果。

2、RPC 核心功能

RPC 的核心功能是指实现一个 RPC 最重要的功能模块，也就是”RPC 协议”部分：

一个 RPC 的核心功能主要有 5 个部分组成，分别是：客户端、客户端 Stub、网络传输模块、服务端 Stub、服务端等。

下面分别介绍核心 RPC 框架的重要组成：

• 客户端(Client)：服务调用方。
• 客户端存根(Client Stub)：存放服务端地址信息，将客户端的请求参数数据信息打包成网络消息，再通过网络传输发送给服务端。
• 服务端存根(Server Stub)：接收客户端发送过来的请求消息并进行解包，然后再调用本地服务进行处理。
• 服务端(Server)：服务的真正提供者。
• Network Service：底层传输，可以是 TCP 或 HTTP。

三、手写JAVA版RPC机制

1、rpcapi工程

1.1 用户传输对象 UserDTO.java

import lombok.Data;
import java.io.Serializable;
/**
 * UserDto:用户传输对象
 */
/**
 * @Data生成get、set、tostring方法
 */
@Data
public class UserDto implements Serializable {
    //序列化与反序列化时的安全检查
    private static final long serialVersionUID = -2697890869834365586L;
    private String name;
    private int age;
    private String userID;
}

1.2 定义标准接口 UserService.java

import com.axman.dto.UserDto;
/**
 * 定义标准接口
 */
public interface UserService {
    public UserDto adduser(UserDto userDto);
}

1.3 统一的传输的请求标准 RPCCommonReqDTO.java

package com.axman.dto;
import lombok.Data;
import java.io.Serializable;
/**
 * 统一的传输的请求标准
 */
@Data
public class RPCCommonReqDTO implements Serializable {
    private static final long serialVersionUID = -8110433671784290943L;
    private String methodName;
    private String classPath;
    private Object[] args;
}

1.4 将rpcapi工程通过Maven发布到本地仓库

2、rpcprovider工程

2.1 标准的实现类 UserServiceImpl.java

package com.axman.api.impl;
import com.axman.api.UserService;
import com.axman.dto.UserDto;
import java.util.Random;
/**
 * 标准的实现类
 */
public class UserServiceImpl implements UserService {
    public UserDto adduser(UserDto userDto) {
        //具体的业务逻辑，比如
        System.out.println("接收:"+userDto);
        userDto.setUserID(new Random().nextInt(10000000)+"");
        System.out.println("接收:"+userDto);
        return userDto;
    }
}

2.2 提供对外的网络服务 NetServer.java

package com.axman.net;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 提供对外的网络服务
 */
public class NetServer {
    //多线程的方式完成流的处理
    //线程池
    static final ExecutorService threadPool = Executors.newFixedThreadPool(100);
    public static void startUp(int port) throws Exception {
        ServerSocket serverSocket = new ServerSocket(port);
        while(true){
            //用来阻塞的等待客户端的连接，当有客户端连接时，就会得到一个Socket对象
            Socket socket = serverSocket.accept();
            threadPool.submit(new RPCProcessor(socket));
        }
    }
    public static void main(String[] args) throws Exception {
        startUp(9999);
    }
}

2.3 完成流的处理 RPCProcessor.java

package com.axman.net;
import com.axman.dispatch.ServiceDispatch;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

/**
 *  完成流的处理
 */
public class RPCProcessor implements Runnable {
    private Socket socket;
    public RPCProcessor(Socket socket){
        this.socket = socket;
    }
    public void run() {
        //典型的Blocking IO的方式
        //阻塞工作线程流的Write、Read
        ObjectInputStream objectInputStream = null;
        ObjectOutputStream objectOutputStream = null;
        try {
            //输入输出的处理
            objectInputStream  = new ObjectInputStream(socket.getInputStream());
            //从网络得到输入的对象
            Object object = objectInputStream.readObject();
            //对拿到的对象进行分发
            Object respObj = ServiceDispatch.dispatch(object);
            //输出结果
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            //返回结果
            objectOutputStream.writeObject(respObj);
            //清空
            objectOutputStream.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                objectInputStream.close();
                objectOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.4 分发服务的类 ServiceDispatch.java

package com.axman.dispatch;
import com.axman.dto.*;
import java.lang.reflect.Method;
/**
 * 分发服务的类
 */
public class ServiceDispatch {

    /**
     * 服务的分发
     * @param reqObj
     * @return
     */
    public static Object dispatch(Object reqObj){
        //基于反射机制  instance方法的调用
        //classpath  类的全路径
        //方法名 + 形参列表的类型列表
        //实例对象 Class.newInstance
        //方法调用过程中参数的值
        RPCCommonReqDTO rpcCommonReqDTO = (RPCCommonReqDTO) reqObj;
        String methodName = rpcCommonReqDTO.getMethodName();
        String classPath = rpcCommonReqDTO.getClassPath();
        Object[] args = rpcCommonReqDTO.getArgs();
        //获取参数值得类型
        Class[] types = null;
        if(args!=null && args.length>0){
            types = new Class[args.length];
            for (int i=0; i<args.length; i++){
                types[i] = args[i].getClass();
            }
        }
        //方法获取及调用
        Object respObject = null;
        try {
            Class<?> clazz = Class.forName(classPath);
            Method method = clazz.getDeclaredMethod(methodName, types);
            respObject = method.invoke(clazz.newInstance(), args);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return respObject;
    }
}

3、rpccustomer工程

3.1 代理类 FactoryProxy.java

package com.axman.proxy;
import com.axman.api.UserService;
import java.lang.reflect.Proxy;
public class FactoryProxy {
    /**
     * 传入一个interfaceClazz的类型，返回一个Class的实例对象
     * @param interfaceClazz
     * @param <T>
     * @return
     */
    public static <T> T getInstanceByClassType(Class<T> interfaceClazz){
        //动态代理  需要传三个参数
        return (T) Proxy.newProxyInstance(FactoryProxy.class.getClassLoader(),
                new Class[]{
                        interfaceClazz
                },new RPCInvocationHandler());
    }
}

3.2 处理类 RPCInvocationHandler

package com.axman.proxy;
import com.axman.dto.RPCCommonReqDTO;
import com.axman.dto.UserDto;
import com.axman.net.NetClient;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class RPCInvocationHandler implements InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //组装RPCCommonReqDTO对象  完成网络的调用
        RPCCommonReqDTO rpcCommonReqDTO = new RPCCommonReqDTO();
        rpcCommonReqDTO.setArgs(args);
        rpcCommonReqDTO.setMethodName(method.getName());
        rpcCommonReqDTO.setClassPath("com.axman.api.impl.UserServiceImpl");
        //完成网络的调用
        return NetClient.callRemoteService("localhost",9999,rpcCommonReqDTO);
    }
}

3.3 网络服务类 NetClient

package com.axman.net;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
public class NetClient {
    public static Object callRemoteService(String host, int port, Object reqObject){
        //典型的Blocking IO的方式
        //阻塞工作线程流的Write、Read
        ObjectInputStream objectInputStream = null;
        ObjectOutputStream objectOutputStream = null;
        Object respObject = null;
        //完成跟远端服务的调用
        try {
            Socket socket = new Socket(host, port);
            //流的处理
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(reqObject);
            objectOutputStream.flush();
            //得到从服务器端返回的流
            objectInputStream  = new ObjectInputStream(socket.getInputStream());
            respObject = objectInputStream.readObject();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                objectInputStream.close();
                objectOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return respObject;
    }
}

3.4 测试类 TestRPC

package com.axman;
import com.axman.api.UserService;
import com.axman.dto.UserDto;
import com.axman.proxy.FactoryProxy;
public class TestRPC {
    public static void main(String[] args) {
        UserService userService = FactoryProxy.getInstanceByClassType(UserService.class);
        UserDto userDto = new UserDto();
        userDto.setAge(18);
        userDto.setName("Axman");
        System.out.println("invoke before: "+userDto);
        userDto = userService.adduser(userDto);
        System.out.println("invoke after: "+userDto);
    }
}

4、运行rpcprovider、rpccustomer项目

Client端输出的UserDao对象中有ID