service能去调另外一个service吗_不装了，摊牌了！我要手写一个RPC

前言

RPC是远程过程调用（Remote Procedure Call）的缩写形式。SAP系统RPC调用的原理其实很简单，有一些类似于三层构架的C/S系统，第三方的客户程序通过接口调用SAP内部的标准或自定义函数，获得函数返回的数据进行处理后显示或打印。

随着微服务、分布式的大热，开发者慢慢趋向于将一个大的服务拆分成多个独立的小的服务。
服务经过拆分后，服务与服务之间的通信就变得至关重要。

RPC说白了就是节点A去调用节点B的服务，站在Java的角度看，就是像调用本地函数一样调用远程函数。

---

需要解决的问题

要想实现RPC，首先需要解决以下几个问题：

1. 服务之间如何通信？Socket 网络IO。
2. 请求参数、返回结果如何传输？Java将对象序列化为字节数组通过网络IO传输。
3. 接口没有实现类，该如何调用？JDK动态代理生成代理对象。
4. 如何发起远程调用？在代理对象中发起Socket请求远程服务器。

手写RPC实战

首先看下目录结构：

1、定义通信协议

消费者发起一个调用请求，服务者必须知道你要调哪个服务，参数是什么，这些需要封装好。

@Data
public class RpcMessage implements Serializable {
    private static final long serialVersionUID = 1L;

    private String interfaceName;//调用的Service接口名
    private String methodName;//调用的方法名
    private Class<?>[] argsType;//参数类型列表
    private Object[] args;//参数
}

2、自定义注解

分别是服务的提供者和消费者。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Service//引入Spring Service，自动注入IOC容器
// 服务提供者
public @interface MyRpcService {

}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 服务消费者
public @interface MyRpcReference {

}

3、定义接口

public interface UserService {

    // 根据UserId查找用户
    R<UserResp> findById(Long userId);
}

4、实现接口

加上自定义注解@MyRpcService，后续需要扫描这些实现类，并暴露服务。

@MyRpcService
public class UserServiceImpl implements UserService{

    @Override
    public R<UserResp> findById(Long userId) {
        UserResp userResp = new UserResp();
        userResp.setId(userId);
        userResp.setName("张三");
        userResp.setPwd("root@abc");
        return R.ok(userResp);
    }
}

5、暴露服务并监听处理请求

应用程序启动后，从Spring的IOC容器中，找到加了@MyRpcService注解的服务，并暴露出去。

/**
 * @author: pch
 * @description: 程序启动，暴露Service服务
 * @date: 2020/10/13
 **/
@Component
public class ProviderListener implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent) {
        ConfigurableApplicationContext context = applicationStartedEvent.getApplicationContext();
        for (Object bean : context.getBeansWithAnnotation(MyRpcService.class).values()) {
            ProviderHolder.addService(bean);
        }
        try {
            ProviderHolder.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.err.println("provider...启动");
    }
}

暴露服务，处理消费者请求的核心代码

/**
 * @author: pch
 * @description: 服务持有者
 * @date: 2020/10/13
 **/
public class ProviderHolder {
    // 缓存所有的服务提供者
    private static final Map<String, Provider> SERVICES = new ConcurrentHashMap<>();
    // 起一个线程池，处理消费者的请求
    private static final ExecutorService EXECUTOR_SERVICE = Executors.newCachedThreadPool();

    // 添加服务
    public static void addService(Object bean) {
        Class<?> beanClass = bean.getClass();
        String interfaceName = beanClass.getInterfaces()[0].getName();
        SERVICES.put(interfaceName, new Provider(bean));
    }

    /**
     * 启动服务
     * @throws Exception
     */
    public static void start() throws Exception {
        if (SERVICES.isEmpty()) {
            return;
        }
        // 开启ServerSocket，端口3333，监听消费者发起的请求。
        ServerSocket serverSocket = new ServerSocket(3333);
        while (true) {
            // 当有请求到达，提交一个任务到线程池
            Socket socket = serverSocket.accept();
            EXECUTOR_SERVICE.submit(() -> {
                try {
                    // 从网络IO中读取消费者发送的参数
                    Object o = new ObjectInputStream(socket.getInputStream()).readObject();
                    if (o instanceof RpcMessage) {
                        RpcMessage message = (RpcMessage) o;
                        // 找到消费者要调用的服务
                        Provider provider = SERVICES.get(message.getInterfaceName());
                        if (provider == null) {
                            return;
                        }
                        // 利用反射调用服务
                        Object result = provider.invoke(message.getMethodName(), message.getArgsType(), message.getArgs());
                        OutputStream outputStream = socket.getOutputStream();
                        // 将返回结果序列化为字节数组并通过Socket写回
                        outputStream.write(ObjectUtil.serialize(result));
                        outputStream.flush();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

6、生成RPC动态代理对象

/**
 * @author: pch
 * @description: 基于JDK动态代理生成代理对象，发起RPC调用
 * @date: 2020/10/13
 **/
public class RpcProxy implements InvocationHandler {
    private Object origin = new Object();

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(origin, args);
        }
        // 开启一个Socket
        Socket socket = new Socket("127.0.0.1", 3333);
        // 封装请求协议
        RpcMessage message = new RpcMessage();
        message.setInterfaceName(method.getDeclaringClass().getName());
        message.setMethodName(method.getName());
        message.setArgsType(method.getParameterTypes());
        message.setArgs(args);
        // 将请求参数序列化成字节数组通过网络IO写回
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(ObjectUtil.serialize(message));
        outputStream.flush();
        // 阻塞，等待服务端处理完毕返回结果
        Object o = new ObjectInputStream(socket.getInputStream()).readObject();
        // 返回给调用者
        return o;
    }
}

7、消费者注入RPC动态代理对象

/**
 * @author: pch
 * @description: 注入加了@MyRpcReference注解的属性
 * @date: 2020/10/13
 **/
@Component
public class RpcBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> beanClass = bean.getClass();
        Field[] fields = ClassUtil.getDeclaredFields(beanClass);
        for (Field field : fields) {
            if (field.getAnnotation(MyRpcReference.class) == null) {
                continue;
            }
            Object proxy = Proxy.newProxyInstance(beanClass.getClassLoader(), new Class[]{field.getType()}, new RpcProxy());
            field.setAccessible(true);
            try {
                field.set(bean, proxy);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return bean;
    }
}

功能测试

核心代码写好了，那就可以开始测试功能是否符合预期了。

1、启动服务提供者

2、启动消费者，并发起一个请求

最后

基于篇幅原因，本文只是实现了RPC最基本最简单的功能，主要是理解RPC的思想。
当然，还有很多可以优化的点：

1. Service暴露的所有方法缓存起来，每次调用再反射查找开销还是很大的。
2. 使用Netty提升网络IO的通信性能。
3. 连接池的引入。
4. 注册中心的加入。
5. 写回的数据没有包装协议。
6. 数据格式的扩展，请求头的加入。

文章产出不易，还望各位小伙伴们支持一波！

作者：程序员小潘
链接： https:// blog.csdn.net/qq_320998 33/article/details/109141994?utm_
来源：CSDN