当前位置: 首页 > news >正文

手写一个简单的RPC框架

学习RPC框架,由繁化简,了解其本质原理

文章目录

  • 项目简介
    • 什么是RPC?
    • 项目模块
  • 项目代码
    • common模块
    • client模块
    • server模块
    • framework模块
    • 测试

项目简介

什么是RPC?

RPC(Remote Procedure Call)即远程过程调用,不同于本地调用,RPC是指调用远端机器的函数或方法,且不需要关心底层的调用细节,如网络协议和传输协议等,对于调用者来说,和调用本地方法没有什么区别。

项目模块

  1. common模块:定义了用户接口和实体类User
  2. client模块:调用RPC框架的代理类,获取结果
  3. server模块:
  • 实现common的接口,把实现类注册到注册中心中
  • 调用RpcServer开启socket
  • 根据RpcRequest类的信息,获取到注册中心的实现类
  • 执行方法,返回结果,通过socket返回
  1. Rpc framework
  • 注册中心
  • RpcRequest,装载类的信息
  • RpcServer:创建socket,接受客户端的请求

在这里插入图片描述

项目代码

common模块

实体类和定义的接口

package com.rpc.common;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 10:37
 * @Desc: 网络中传输的信息
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class User implements Serializable {

    private Integer id;

    private String name;

    private Integer age;

    private int sex;
}

package com.rpc.common;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 10:38
 * @Desc:
 */
public interface IUserService {
    User getById(Integer id);

    User getUsername(String userName);
}

client模块

package com.rpc.client;

import com.rpc.common.IUserService;
import com.rpc.framework.proxy.RpcProxy;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 11:39
 * @Desc:
 */
public class Client {
    public static void main(String[] args) {
        RpcProxy rpcProxy = new RpcProxy();
        IUserService productService = (IUserService) rpcProxy.remoteCall("localhost", 10000, IUserService.class);
        System.out.println("productService = " + productService.getById(10));
    }
}

server模块

package com.rpc.server;

import com.rpc.common.IUserService;
import com.rpc.framework.Registry;
import com.rpc.framework.RpcServer;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 11:37
 * @Desc:
 * https://www.cnblogs.com/fantongxue/p/16004920.html
 */
public class Server {
    /**
     * 把接口和实现类注册到RPC的注册中心,然后通过RPC的RPCServer开启一个serversocket,监听某一个端口。
     * @param args
     */
    public static void main(String[] args) {
        Registry.put(IUserService.class.getName(), UserServiceImpl.class);
        new RpcServer().provide(10000);
    }
}

package com.rpc.server;

import com.rpc.common.User;
import com.rpc.common.IUserService;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 11:35
 * @Desc:
 */
public class UserServiceImpl implements IUserService {
    @Override
    public User getById(Integer id) {
        return User.builder()
                .id(id)
                .name("yangmiao")
                .age(100)
                .sex(1)
                .build();
    }

    @Override
    public User getUsername(String userName) {
        return User.builder()
                .name(userName)
                .build();
    }
}

framework模块

package com.rpc.framework;

import java.util.HashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 10:39
 * @Desc: 注册中心
 */
public class Registry {
    private final static HashMap<String, Class> map = new HashMap<>();
    private final static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**
     * 读缓存
     * @param key
     * @return
     */
    public static Class get(String key){
        // 读锁
        Lock writeLock = readWriteLock.writeLock();
        // 写锁
        Lock readLock = readWriteLock.readLock();

        Class v = null;
        readLock.lock();
        try {
            v = map.get(key);
        }finally {
            readLock.unlock();
        }
        if (v != null){
            return v;
        }
        // 缓存中不存在
        writeLock.lock();
        try {
            v = map.get(key);
            if (v==null){
                // 1.查询数据库
                // 2.写入缓存
                map.put(key,v);
            }
        }finally {
            writeLock.unlock();
        }
        return v;
    }

    /**
     * 写缓存
     * @param key
     * @param value
     * @return
     */
    public static Class put(String key, Class value){
        Lock writeLock = readWriteLock.writeLock();
        writeLock.lock();
        try {
            return map.put(key,value);
        }finally {
            writeLock.unlock();
        }
    }

    public static boolean containsKey(String key){
        return map.containsKey(key);
    }

}
package com.rpc.framework;

import lombok.Data;

import java.io.Serializable;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 10:41
 * @Desc:
 */
@Data
public class RpcRequest implements Serializable {

    private String className;

    private String methodName;

    private Class[] types;

    private Object[] params;

}
package com.rpc.framework;


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

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 10:42
 * @Desc:
 */
public class RpcServer {
    /**
     * 创建线程池
     */
    private ExecutorService executors = Executors.newFixedThreadPool(5);

    public void provide(int port){
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while (true){
                Socket socket = serverSocket.accept();
                executors.execute(new ProcessHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
package com.rpc.framework;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.Socket;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 10:50
 * @Desc: 处理服务端逻辑
 */
public class ProcessHandler implements Runnable {
    private Socket socket;

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

    @Override
    public void run() {
        ObjectInputStream objectInputStream = null;
        ObjectOutputStream objectOutputStream = null;

        try {
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            RpcRequest rpcRequest = (RpcRequest) objectInputStream.readObject();

            Class clazz = null;
            // 判断是否存在于注册中心中
            if (Registry.containsKey(rpcRequest.getClassName())){
                clazz = Registry.get(rpcRequest.getClassName());
            }
            Method method = clazz.getMethod(rpcRequest.getMethodName(), rpcRequest.getTypes());
            Object result = method.invoke(clazz.newInstance(), rpcRequest.getParams());

            // 返回结果
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(result);
            objectOutputStream.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }finally {
            try {
                if (objectInputStream !=null){
                    objectInputStream.close();
                }
                if (objectOutputStream !=null){
                    objectOutputStream.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }

        }
    }
}

代理

package com.rpc.framework.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 11:18
 * @Desc: 创建动态代理
 */
public class RpcProxy<T> {

    public T remoteCall(String host,int port,Class clazz){
        return (T) Proxy.newProxyInstance(
                clazz.getClassLoader(),
                (Class<?>[]) new Class[]{clazz},
                new RemoteInvocationHandler(host,port,clazz)
        );
    }
}
package com.rpc.framework.proxy;

import com.rpc.framework.RpcRequest;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Author: Yangmiao
 * @Date: 2023/2/8 11:22
 * @Desc: 代理类执行的逻辑
 */
public class RemoteInvocationHandler implements InvocationHandler {

    private String host;
    private int port;
    private Class clazz;

    public RemoteInvocationHandler(String host,int port,Class clazz){
        this.host = host;
        this.port = port;
        this.clazz = clazz;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        RpcRequest rpcRequest = new RpcRequest();

        rpcRequest.setClassName(clazz.getName());
        rpcRequest.setMethodName(method.getName());
        rpcRequest.setTypes(method.getParameterTypes());
        rpcRequest.setParams(args);

        ObjectOutputStream objectOutputStream = null;
        ObjectInputStream objectInputStream = null;

        try {
            Socket socket = new Socket(host,port);
            // 发送消息
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(rpcRequest);
            objectOutputStream.flush();

            // 接受结果
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            Object readObject = objectInputStream.readObject();
            return readObject;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (objectInputStream !=null){
                    objectInputStream.close();
                }
                if (objectOutputStream!=null){
                    objectOutputStream.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        return null;
    }
}

测试

在这里插入图片描述
在这里插入图片描述

相关文章:

  • 如何创建和编写项目管理计划?
  • 算法设计与分析 实验五 贪心算法
  • 正式环境关闭swagger
  • 动态内存的开辟
  • 【分布式版本控制系统Git】| IDEA 集成 Git 、IDEA 集成 GitHub
  • C语言指针链表
  • 全网最完整,接口测试总结彻底打通接口自动化大门,看这篇就够了......
  • 【JVM虚拟机面试宝典】JVM的内存结构是怎么样的?在JVM中会发生内存溢出的区域有那些?— day06
  • C++ string类
  • 细数那些惊艳一时的 CSS 属性
  • 【C语言】你真的了解结构体吗
  • 可做题2(矩阵快速幂,乘法逆元,exgcd)
  • Mysql用户权限分配详解
  • 一文7个步骤从0到1教你搭建Selenium 自动化测试环境
  • 【网络安全工程师】从零基础到进阶,看这一篇就够了
  • JavaScript-如何实现克隆(clone)函数
  • .pyc 想到的一些问题
  • [分享]iOS开发 - 实现UITableView Plain SectionView和table不停留一起滑动
  • 【React系列】如何构建React应用程序
  • Angular4 模板式表单用法以及验证
  • CSS居中完全指南——构建CSS居中决策树
  • Flannel解读
  • JavaScript函数式编程(一)
  • LeetCode29.两数相除 JavaScript
  • Linux中的硬链接与软链接
  • vue--为什么data属性必须是一个函数
  • 坑!为什么View.startAnimation不起作用?
  • 前端 CSS : 5# 纯 CSS 实现24小时超市
  • 深度学习在携程攻略社区的应用
  • 使用Maven插件构建SpringBoot项目,生成Docker镜像push到DockerHub上
  • 学习JavaScript数据结构与算法 — 树
  • 再谈express与koa的对比
  • hi-nginx-1.3.4编译安装
  • ​LeetCode解法汇总1276. 不浪费原料的汉堡制作方案
  • ​一帧图像的Android之旅 :应用的首个绘制请求
  • # 深度解析 Socket 与 WebSocket:原理、区别与应用
  • #NOIP 2014#Day.2 T3 解方程
  • #pragma once与条件编译
  • #QT(串口助手-界面)
  • (0)Nginx 功能特性
  • (1)(1.9) MSP (version 4.2)
  • (LeetCode 49)Anagrams
  • (LeetCode C++)盛最多水的容器
  • (SpringBoot)第二章:Spring创建和使用
  • (动手学习深度学习)第13章 计算机视觉---图像增广与微调
  • (附源码)python旅游推荐系统 毕业设计 250623
  • (附源码)ssm航空客运订票系统 毕业设计 141612
  • (附源码)计算机毕业设计SSM疫情居家隔离服务系统
  • (官网安装) 基于CentOS 7安装MangoDB和MangoDB Shell
  • (心得)获取一个数二进制序列中所有的偶数位和奇数位, 分别输出二进制序列。
  • (一)u-boot-nand.bin的下载
  • (译)2019年前端性能优化清单 — 下篇
  • (原)本想说脏话,奈何已放下
  • ***通过什么方式***网吧
  • .NET CORE 2.0发布后没有 VIEWS视图页面文件