分布式框架RPC的实现

最新推荐文章于 2024-05-05 17:30:14 发布
置顶 最新推荐文章于 2024-05-05 17:30:14 发布
阅读量189 收藏
点赞数
文章标签： java rmi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Monday__Friday/article/details/105741593
版权

概述

RPC是一个网际协议，用面向对象的方法实现RPC就是RMI。
RMI：远程方法调用
客户端提供给用户一个API，当用户调用其中某个方法时，客户端把要调用的方法和参数发送到服务器端，服务器根据这个方法名称在服务器端匹配到对应的对象，并且执行对应的方法。再把这个结果返回给客户端。

只有服务器端才真正存在拥有这个方法的对象，中间的网络通信过程用户是不知道的，用户就感觉是调用了一个本地方法而已。这样做的好处就是减轻了服务器的负担。

实现思路

客户端的流程

这个接口中的方法是用户需要调用的方法，真正调用方法的肯定是一个继承这个接口的真实对象，这个真实对象只存在于服务器端。但是为了提供给客户端调用，所以我们通过代理的方式，产生一个此接口的代理对象，为了供用户调用。

//用户需要调用的方法
public interface IDoSomething {
    public String doSomething(int a, int b) throws Exception;
}

//通过JDK代理返回一个接口的代理对象，可以看我之前写的代理博客
private <T> T interfaceJDKProxy(Class<?> klass) {
        ClassLoader classLoader = klass.getClassLoader();
        Class<?>[] interfaces = new Class[]{klass};
        return Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object res = JDKProxy.this.methodInvoker.invoke((Object)null, method, args);
                return res;
            }
        });
    }

上述的methodInvoker是一个接口，接口中有一个invoke方法，是这个代理类执行某个代理方法时，具体的方法调用流程。

这里用到了很牛逼的思想，面向接口编程。对象是接口类型，在具体需要的时候，set进去一个对应的接口实现类，这就实现了滞后。这也是框架中运用很多的思想。

那么根据我们的需求，这个代理对象执行方法时，要把所要执行的方法和对应参数发送到服务器，并且接受服务器执行结果。所以，我们自己编写的methodInvoke就要完成与服务器通信的部分

下一部分是真正提供给用户产生代理对象的方法，需要传入一个接口类型。其中setMethodInvoker就完成了和服务器的通信任务。我们把方法的全名先发送过去，然后在把参数封装到一个类中，发送这个类的gson字符串，服务器端只需要按照已经定好的规则来解析。

public <T> T getProxy(Class<?> klass) throws InstantiationException, IllegalAccessException
            , MethodInvokerNotSetException {
        this.startup();
        mecProxy.setMethodInvoker(new IMethodInvoker() {
            @Override
            public Object invoke(Object o, Method method, Object[] args) throws IllegalAccessException, InvocationTargetException {
                Object result = null;
                DataOutputStream dos = null;
                DataInputStream dis = null;
                try {
                    dos = new DataOutputStream(socket.getOutputStream());
                    dis = new DataInputStream(socket.getInputStream());

                    //先发送方法的全名
                    dos.writeUTF(method.toString());

                    //在把参数包装在ArgumentMaker内发送其Gson字符串
                    ArgumentMaker argumentMaker = new ArgumentMaker();
                    Class<?>[] parameterTypes = method.getParameterTypes();
                    for(int i = 0; i < parameterTypes.length;i++){
                        argumentMaker.add("arg"+i, args[i]);
                    }
                    dos.writeUTF(argumentMaker.toString());

                    Type type = method.getReturnType();
                    String res = dis.readUTF();
                    result = RMIServer.gson.fromJson(res, type);
                } catch (IOException e) {
                    if(dos != null){
                        try {
                            dos.close();
                        } catch (IOException ex) {
                        }
                    }
                    if(dis != null){
                        try {
                            dis.close();
                        } catch (IOException ex) {
                        }
                    }
                    if(socket != null){
                        try {
                            socket.close();
                        } catch (IOException ex) {
                        }
                    }

                }

                return result;
            }
        });

        return mecProxy.getProxy(klass);
    }
服务器端的大概流程

服务器端对于每一个客户端的解析程序。
解析方法的全名和参数，得到这个方法所在的类，方法的名称以及参数的类型。
方法所在的类必定是这个接口，所以我们还需要在服务器端匹配一个对应关系。就是该接口和具体实现类的对应关系，写在xml中并对其提前解析。然后根据所找到的类，再通过方法找到具体的类中方法，反射调用执行，结果再返回。

//接口和实现类对应关系，在客户端调用之前，就解析这个xml文件，把这个对应关系通过一个map存放好
<?xml version="1.0" encoding="UTF-8" ?>
<RMIMapping>
    <Mapping interface="rmi.Main.IDoSomething" impl="rmi.Main.DoSomethingImpl"></Mapping>
</RMIMapping>

public class RMIService implements Runnable{
    private Socket socket;

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

    @Override
    public void run() {
        try {
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            //获得方法的全名
            String fullmethod = dis.readUTF();
            //参数封装的gson字符串
            String arguGson = dis.readUTF();

			//MethodInformation 是对方法的一个封装，包括方法所在类，方法名，变量的类型（暂时用String来表示类型）
            MethodInformation methodInformation = new MethodInformation(fullmethod);
            RMIDefinition definition = RMIFactory.getDefinition(methodInformation.getClassName());

            String[] argTypes = methodInformation.getArgTypes();
            //获得变量类型
            Class<?>[] parameterTypes = getParameterTypes(argTypes);
            //获得变量具体的值
            Object[] argValues = getArgValues(arguGson, parameterTypes);

            Class klass = definition.getKlass();
            Object obj = definition.getObj();
            Method method = klass.getDeclaredMethod(methodInformation.getMethodName(),parameterTypes);
            //反射调用对应方法
            Object res = method.invoke(obj, argValues);

            Type returnType = method.getGenericReturnType();
            //返回执行结果
            dos.writeUTF(RMIServer.gson.toJson(res,returnType));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    private Class<?>[] getParameterTypes(String[] argTypes){
        if(argTypes == null || argTypes.length <= 0){
            return new Class[]{};
        }

        Class<?>[] types = new Class[argTypes.length];
        for(int i = 0;i < argTypes.length;i++){
            types[i] = MecType.toType(argTypes[i]);
        }

        return types;
    }

    private Object[] getArgValues(String arguGson, Class<?>[] parameterTypes){
        Object[] args = new Object[parameterTypes.length];
        ArgumentMaker argumentMaker = new ArgumentMaker(arguGson);

        for (int i = 0;i < args.length;i++) {
            args[i] = argumentMaker.getValue("arg"+i,parameterTypes[i]);
        }
        return args;
    }
Server完整代码

用到了线程池，对于每一个解析程序都用一个线程new RMIService（）完成。RMIService便是上面解析和返回的过程。

package rmi.core;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class RMIServer implements Runnable{
    public static int DEFAULT_PORT = 54187;
    public static Gson gson = new GsonBuilder().create();
    private ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
            10, 120,
            5000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());

    private ServerSocket serverSocket;
    private int port;
    private volatile boolean goon;

    public RMIServer() {
        this.port = RMIServer.DEFAULT_PORT;
        this.goon = false;
    }

    public RMIServer(int port) {
        this();
        this.port = port;
    }

    public void startup(){
        try {
            if(null == this.serverSocket && !this.goon) {
                this.serverSocket = new ServerSocket(port);
                this.goon = true;
                new Thread(this,"RMIServer").start();
            }
        } catch (IOException e) {
        }
    }

    public void shutdown(){
        try {
            if(this.serverSocket != null && this.goon) {
                this.serverSocket.close();
                this.goon = false;
                this.serverSocket = null;
            }
        } catch (IOException e) {
            this.serverSocket = null;
        }
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }


    @Override
    public void run() {
        while(this.goon){
            try {
                Socket client = this.serverSocket.accept();
                threadPool.execute(new RMIService(client));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}
客户端完整代码
package rmi.core;

import com.mec.util.ArgumentMaker;
import com.mec.util.proxy.IMethodInvoker;
import com.mec.util.proxy.MecProxy;
import com.mec.util.proxy.MethodInvokerNotSetException;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.net.Socket;

public class RMIClient {
    public static String DEFAULT_IP = "127.0.0.1";
    public static int PORT = 54187;

    private Socket socket;
    private String ip;
    private int port;

    private MecProxy mecProxy;

    public RMIClient() {
        this.mecProxy = new MecProxy();
        this.ip = RMIClient.DEFAULT_IP;
        this.port = RMIClient.PORT;
    }

    public RMIClient(String ip, int port){
        this();
        this.ip = ip;
        this.port = port;
    }

    /**
     * 获取远程代理对象
     * @param klass 要代理的接口
     * @param <T>
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws MethodInvokerNotSetException
     */
    public <T> T getProxy(Class<?> klass) throws InstantiationException, IllegalAccessException
            , MethodInvokerNotSetException {
        this.startup();
        mecProxy.setMethodInvoker(new IMethodInvoker() {
            @Override
            public Object invoke(Object o, Method method, Object[] args) throws IllegalAccessException, InvocationTargetException {
                Object result = null;
                DataOutputStream dos = null;
                DataInputStream dis = null;
                try {
                    dos = new DataOutputStream(socket.getOutputStream());
                    dis = new DataInputStream(socket.getInputStream());

                    //先发送方法的全名
                    dos.writeUTF(method.toString());

                    //在把参数包装在ArgumentMaker内发送其Gson字符串
                    ArgumentMaker argumentMaker = new ArgumentMaker();
                    Class<?>[] parameterTypes = method.getParameterTypes();
                    for(int i = 0; i < parameterTypes.length;i++){
                        argumentMaker.add("arg"+i, args[i]);
                    }
                    dos.writeUTF(argumentMaker.toString());

                    Type type = method.getReturnType();
                    String res = dis.readUTF();
                    result = RMIServer.gson.fromJson(res, type);
                } catch (IOException e) {
                    if(dos != null){
                        try {
                            dos.close();
                        } catch (IOException ex) {
                        }
                    }
                    if(dis != null){
                        try {
                            dis.close();
                        } catch (IOException ex) {
                        }
                    }
                    if(socket != null){
                        try {
                            socket.close();
                        } catch (IOException ex) {
                        }
                    }

                }

                return result;
            }
        });

        return mecProxy.getProxy(klass);
    }

    private void startup(){
        try {
            if(null == this.socket) {
                this.socket = new Socket(ip, port);
            }
        } catch (IOException e) {
            this.socket = null;
        }
    }

    private void shutdown(){
        try {
            this.socket.close();
            this.socket = null;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String getIp() {
        return ip;
    }

    public int getPort() {
        return port;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public void setPort(int port) {
        this.port = port;
    }

}

框架怎么用

  1. 在服务器端配置接口对应的实现类（xml文件中）
  2. 服务器设置port，启动服务器
  3. 客户端配置服务器的ip和port
  4. 通过getProxy（）方法，传入接口类型，获得代理类
  5. 调用代理类其中的方法
public class TestForClient {
    public static void main(String[] args) {
        RMIClient client = new RMIClient();
        client.setIp("localhost");
        client.setPort(54185);
        try {
            IDoSomething proxy = client.getProxy(IDoSomething.class);
            String res = proxy.doSomething(1,2);
            System.out.println(res);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (MethodInvokerNotSetException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class TestForServer {
    public static void main(String[] args) {
        RMIServer server = new RMIServer();
        RMIFactory.scanMapping("/RMIMapping.xml");

        server.setPort(54185);
        server.startup();
    }
}

和java自带框架的区别

基本看了一下java实现的RMI，是根据一个约定的字符串获得服务器上真是存在的对象引用，然后调用这个对象中的方法。比我自己完成的，省去了参数传递和解析的过程。但是感觉内部还是会去传递参数，因为是俩个不同的jvm上的。对象都是不一样的，没有深究，只是猜测。

夜影鱼叉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
QtRO (分布式RPC)
05-11
QtRO（分布式RPC）是一种基于网络的远程过程调用（RPC）框架，它允许不同的应用程序在分布式环境中相互通信，仿佛它们是在同一台计算机上运行。RPC使得客户端可以通过调用远程服务器上的方法来执行功能，而无需关心...
分布式RPC系统框架实战教程
10-19
Dubbo+Zookeeper分布式RPC系统框架实战教程，课程内容从分布式系统技术知识点教学，Dubbo四大组件，Zookeeper，Dubbo源码解析，分布式系统技术图谱，分布式RPC系统框架全面解读。
sessionlistener中sessioncreated中的输出没有被执行
qq_36358746的博客
05-15 1476
今天复习HTTPSessionListener，做了个小练习，发现了一些问题。 练习为：首先创建一个listener，里面输出一下基本信息，然后jsp执行，看listener输出的信息。（因为访问jsp的时候jsp会翻译成servlet，默认调用session方法，但是访问HTML和servlet就不会调用，所以通过访问jsp来看是否创建了session） 截图如下： MyHttpSessionListener中内容如下： web.xml内容如下： 出现的问题就是： 我除了第一次在console中见到了
session不执行也不报错
01-01 1288
昨天发现了一个很奇怪的问题，就是用session的方法后没有效果，但是也不报错， 但是有些方法却又能执行，最后发现bean中的transaction aop有问题   改完后       原来service包里的类虽然继承impl包里的类，但是transaction aop是不继承的，但是之前运行一直没发现？ 最好先把   com.yuxuan.listener.InitialA
sessionCreated(Ljavax/servlet/http/HttpSessionEvent；)V错误解决方案
qq_42301302的博客
03-23 1041
今天拉了一个项目启动，运行一切正常，但是所有请求都会报一个错误，错误不影响程序运行，但是影响调试找错误，于是在网上找了很多方法都说指定tomcat版本8.3.5，但是指定又会报另一个错误。 1.错误截图 2.解决方案 删除jdk下的/jre/lib/ext的servlet-api.jar，可能存在占用，先关闭java的进程 3.总结 删除后一切正常，猜测是pom文件引入的包中，包含依赖servlet-api.jar的包，jre又有一个servlet-api.jar，导致执行的时候读取到两个不同版本的se
sessionCreated一直调用
jacke121的专栏
04-18 5414
sessionCreated一直调用
关于sessionCreated()在项目启动时自动调用多次的解决
m0_56471030的博客
05-05 398
众所周知，sessionCreated方法是用来监听HttpSession对象创建的，每当有新的HttpSession对象创建时，该方法自动被执行。在index.jsp中加入 禁用掉当前静态页面的会话功能就ok了。这样保证只在getSession创建HttpSession时，才调用sessionCreated方法并执行相关代码。但当我启动项目时，直接显示调用了三次sessionCreated方法。
dubbo分布式系统Rpc调用框架
03-21
《Dubbo分布式系统RPC调用框架深度解析》 在当今的互联网时代，分布式系统的构建已经成为企业级应用的常态。作为一款高性能、轻量级的RPC（远程过程调用）框架，Dubbo在分布式领域的影响力不可小觑。本文将深入探讨...
RPC框架原理与实现
01-27
总结来说，RPC框架的核心在于简化分布式系统中的通信，通过服务注册与发现、序列化、服务扫描、服务调用以及服务发现机制，实现高效、可靠的远程调用。理解这些组件的工作原理对于设计和优化自己的RPC框架至关重要。
基于Java的Thunder分布式RPC框架设计源码
最新发布
05-26
Nepxion Thunder是一个基于Java的分布式RPC框架，集成了Netty、Hessian、Kafka、ActiveMQ、Tibco、Zookeeper、Redis、Spring Web MVC、Spring Boot和Docker等技术。它支持多协议、多组件和多序列化，为开发者提供了...
mina框架入门
qq_36594703的博客
09-08 492
Apache Mina Server是一个网络通信应用框架，它主要是对基于TCP/IP、UDP/IP协议栈的通信框架，MiNAk可以帮助我们开发高性能高扩展性的网络通信应用，Mina提供了事件驱动，异步操作的编程模型，学习本文档，需要你已掌握JAVA IO、JAVA NIO、JAVASocket、JAVA 线程及并发库(java.util.concurrent.*)的知识，mina同时提供了网络通
vue 在进入某一个页面的时候，created方法不执行，----亲测，通俗易懂
热门推荐
梁同学与Android
09-29 1万+
今天在写vue项目的时候遇到了这样一个问题当我点击某一个二级菜单的时候会进入到相应的页面，但是这个页面的created方法不执行 代码如下： data(){ return{ uploadData: { userId: '123', } } }, methods: { resetEditFrom() { this.editForm = {} }, created() { console.log("come in...
解决JSP无法使用session.getAttribute()
Hello_super的博客
07-19 2190
session | getAttribute()
【Java框架】手写实现简单的微服务之RMI框架
weixin_45500506的博客
02-01 422
文章目录Ⅰ什么是RMIⅡRMI框架需求分析（一）准备工作：使用哪种代理ⅢRMI框架的实现（一）实现思路（二）RMI服务器启动前准备工作a. RMIBeanDefinitionb. RMIBeanFactoryc. RMIBeanFactoryBuilder（三）RMI服务器端a. RMIServerb. RMIServerWorker（四）RMI客户端a. RMIClientⅣ 后记和收获（一）RMI的诡异及其犀利之处（二）收获 Ⅰ什么是RMI   Remote Method Invoke（远程方法调用）。
Session设置失效（转帖备忘）
acmr
04-29 200
    在一般系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不...
"分布式RPC框架Apache Dubbo演进过程与软件架构
Dubbo是一个分布式的RPC框架，它基于高性能的Netty通讯框架，能够支持多种协议，并提供高效的服务调用。Dubbo的服务治理能力非常强大，通过注册中心来实现动态的服务发现和配置。其中Zookeeper就是Dubbo常用的注册...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值