Java实现简单的RPC框架

最新推荐文章于 2024-05-28 17:41:33 发布
最新推荐文章于 2024-05-28 17:41:33 发布
阅读量1.4k 收藏 8
点赞数 1
分类专栏： RPC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012637358/article/details/88795055
版权

1、RPC简介

RPC，全称为Remote Procedure Call，即远程过程调用，它是一个计算机通信协议。它允许像调用本地服务一样调用远程服务。它可以有不同的实现方式。如RMI(远程方法调用)、Hessian、Http invoker等。另外，RPC是与语言无关的。
RPC示意图

2、Java实现RPC框架

2.1、实现技术方案
 下面使用比较原始的方案实现RPC框架，采用Socket通信、动态代理与反射与Java原生的序列化。
2.2、RPC框架架构

RPC架构分为三部分：

1）服务提供者，运行在服务器端，提供服务接口定义与服务实现类。

2）服务中心，运行在服务器端，负责将本地服务发布成远程服务，管理远程服务，提供给服务消费者使用。

3）服务消费者，运行在客户端，通过远程代理对象调用远程服务。

3、 具体实现
在这里插入图片描述
服务接口定义类
HelloProvider.java

package org.rpc.provider;

/**   
 * @ClassName:  HelloProvider   
 * @Description:TODO(对外提供接口)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:12:59   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */
public interface HelloProvider {
   String sayHello(String name);
   Person getPerson(String name);
}

公共网络通信类
NetModel.java

/**  
 * All rights Reserved, Designed By www.tydic.com
 * @Title:  NetModel.java   
 * @Package org.rpc.provider   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: Jimu
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:14:05   
 * @version V1.0 
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 */
package org.rpc.provider;
import java.io.Serializable;
import java.util.Arrays;
/**   
 * @ClassName:  NetModel   
 * @Description:TODO(公共网络通信类，通过序列化该类,将客户端调用接口、方法、参数、参数类型封装，然后服务端反序列化,再通过反射,调取相应实现类的方法。)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:14:05   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */
 
public class NetModel implements Serializable{


    private static final long serialVersionUID = 1L;

    private String className; //接口名

    private String method; //方法名

    private  Object[] args ; //参数

    private String[] types; //参数类型

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    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;
    }


    public String[] getTypes() {
        return types;
    }

    public void setTypes(String[] types) {
        this.types = types;
    }

    @Override
    public String toString() {
        return "NetModel [className=" + className + ", method=" + method + ", args=" + Arrays.toString(args)
                + ", types=" + Arrays.toString(types) + "]";
    }
}

序列化工具类
SerializeUtils.java

/**  
 * All rights Reserved, Designed By www.tydic.com
 * @Title:  SerializeUtils.java   
 * @Package org.rpc.provider   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: Jimu
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:14:22   
 * @version V1.0 
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 */
package org.rpc.provider;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**   
 * @ClassName:  SerializeUtils   
 * @Description:TODO(序列化工具类)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:14:22   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */
public class SerializeUtils {

    /**
     * 序列化
     * @param object
     * @return
     * @throws IOException
     */
    public static byte[] serialize(Object object) throws IOException {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        ObjectOutputStream outputStream = new ObjectOutputStream(os);
        outputStream.writeObject(object);
        outputStream.flush();
        byte[] byteArray = os.toByteArray();    
        outputStream.close();
        os.close();
        return byteArray;
    }
    /**
     * 反序列化
     * @param buf
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static Object deSerialize(byte[] buf) throws IOException, ClassNotFoundException {
        ByteArrayInputStream is = new ByteArrayInputStream(buf);
        ObjectInputStream inputStream = new ObjectInputStream(is);
        Object object =  inputStream.readObject();
        inputStream.close();
        is.close();
        return object;
    }
}

测试实体类
Person.java

/**  
 * All rights Reserved, Designed By www.tydic.com
 * @Title:  Person.java   
 * @Package org.rpc.provider   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: Jimu
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:13:51   
 * @version V1.0 
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 */
package org.rpc.provider;
import java.io.Serializable;

/**   
 * @ClassName:  Person   
 * @Description:TODO(测试实体类)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:13:51   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */
//普通公共bean
public class Person implements Serializable{

    private static final long serialVersionUID = 1L;
    private String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

服务中心
HelloServiceImpl.java

/**  
 * All rights Reserved, Designed By www.tydic.com
 * @Title:  HelloServiceImpl.java   
 * @Package org.rpc.server   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: Jimu
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:16:02   
 * @version V1.0 
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 */
package org.rpc.server;

import org.rpc.provider.HelloProvider;
import org.rpc.provider.Person;

/**   
 * @ClassName:  HelloServiceImpl   
 * @Description:TODO(接口实现类)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:16:02   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */
public class HelloServiceImpl implements HelloProvider{

	/**   
	 * <p>Title: sayHello</p>   
	 * <p>Description: </p>   
	 * @param name
	 * @return   
	 * @see org.rpc.provider.HelloProvider#sayHello(java.lang.String)   
	 */ 
	public String sayHello(String name) {
		 return "hello,"+name;
	}

	/**   
	 * <p>Title: getPerson</p>   
	 * <p>Description: </p>   
	 * @param name
	 * @return   
	 * @see org.rpc.provider.HelloProvider#getPerson(java.lang.String)   
	 */ 
	public Person getPerson(String name) {
		 Person person = new Person();
	        person.setName(name);
	        person.setAge(25);
	        return person;
	}

}

Server服务端 rpc-server
RPCServer.java

/**  
 * All rights Reserved, Designed By www.tydic.com
 * @Title:  RPCServer.java   
 * @Package org.rpc.server   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: Jimu
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:20:42   
 * @version V1.0 
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 */
package org.rpc.server;

import java.io.FileInputStream;
/**   
 * @ClassName:  RPCServer   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:20:42   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import org.rpc.provider.NetModel;
import org.rpc.provider.SerializeUtils;

//Server服务端,这里使用JDK自带的ServerSocket来进行进行,服务端收到数据后,对数据进行处理,处理完把结构返回给客户端
public class RPCServer {

    public static void main(String[] args) 
    { 
        try {
            openServer();
        } catch (Exception e) {
            e.printStackTrace();
        }   
    }
    //这个方法用来启动服务端,然后接受数据,返回处理完的结果
    public static void openServer() throws IOException  {
        ServerSocket serverSocket =  new ServerSocket(9999); 
        try { 
            System.out.println("服务开启");
            while(true) {
                Socket socket = serverSocket.accept();
                System.out.println(socket.getInetAddress()+"-connected");  
                InputStream in = socket.getInputStream();
                byte[] buf = new byte[1024];  
                in.read(buf);  
                byte[] formatDate = formatData(buf);
                OutputStream out = socket.getOutputStream();  
                out.write(formatDate);  
                socket.close();  
            }
        } catch (Exception e) {
            e.printStackTrace();
            serverSocket.close();
        }
    }
    /*这个方法用来处理接收到的数据,通过反序列化得到传过来的通信类NetModel,然后得到接口名,方法名,参数,参数类型,
    最后通过JDK反射,来调取实现类的方法,并将调取结果,序列化为byte数组,然后返回
    */
    public static byte[] formatData(byte[] bs){
        try {
            //将收到的byte数组反序列化为NetModel类型,然后通过反射调用HelloServiceImpl实现类的方法
            NetModel netModel = (NetModel)SerializeUtils.deSerialize(bs);
            String className = netModel.getClassName();
            String[] types = netModel.getTypes();
            Object[] args = netModel.getArgs();

            /*这里简单通过Map来做接口映射到实现类,从map中取
            Map<String, String> map = new HashMap<String,String>();
            map.put("org.Simple.API.HelloService", "org.Simple.S.HelloServiceImpl");
            Class<?> clazz = Class.forName(map.get(className)); 
            */ 
            //也可以把这个键值放到配置文件下，通过配置文件读取
            Class<?> clazz = Class.forName(getPropertyValue(className));
            Class<?> [] typeClazzs = null;
            if(types!=null) {
                typeClazzs = new Class[types.length];
                for (int i = 0; i < typeClazzs.length; i++) {
                    typeClazzs[i] = Class.forName(types[i]);
                }
            }
            Method method = clazz.getMethod(netModel.getMethod(),typeClazzs);
            Object object = method.invoke(clazz.newInstance(), args);
            byte[] byteArray = SerializeUtils.serialize(object);
            return byteArray;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //通过key去properties文件中取值
    public static String getPropertyValue(String key) throws IOException {
        Properties properties = new Properties();
        FileInputStream in = new FileInputStream("src/main/resources/config.properties");
        properties.load(in);
        in.close();
        return properties.getProperty(key);
    }
    }

config.properties

org.rpc.provider.HelloProvider=org.rpc.server.HelloServiceImpl

RPC客户端rpc-client
RPCClient.java

/**  
 * All rights Reserved, Designed By www.tydic.com
 * @Title:  RPCClient.java   
 * @Package org.rpc.client   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: Jimu
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:22:14   
 * @version V1.0 
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 */
package org.rpc.client;

/**   
 * @ClassName:  RPCClient   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:22:14   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import org.rpc.provider.HelloProvider;
import org.rpc.provider.SerializeUtils;


/*RPC客户端,也是用Socket与服务端进行通信*/
public class RPCClient {
      //Socket发送消息给服务端,并反序列化服务端返回的数据,返回给方法调用者
     public static Object send(byte[] bs)  {
        try {
            Socket socket = new Socket("127.0.0.1", 9999);
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write(bs);  
            InputStream in = socket.getInputStream();  
            byte[] buf = new byte[1024];
            in.read(buf);
            Object formatDate = SerializeUtils.deSerialize(buf);
            socket.close();  
            return formatDate;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //main方法,运行客户端
    public static void main(String[] args) {
        HelloProvider helloService = ProxyFactory.getInstance(HelloProvider.class);
        System.out.println("say:"+helloService.sayHello("zhangsan"));
        System.out.println("Person:"+helloService.getPerson("zhangsan"));

    }
}

ProxyFactory.java

/**  
 * All rights Reserved, Designed By www.tydic.com
 * @Title:  ProxyFactory.java   
 * @Package org.rpc.client   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: Jimu
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:23:50   
 * @version V1.0 
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 */
package org.rpc.client;

/**   
 * @ClassName:  ProxyFactory   
 * @Description:TODO(代理工厂类)   
 * @author: Jimu 
 * @email:  maker2win@163.com 
 * @date:   2019年3月25日 下午2:23:50   
 *     
 * @Copyright: 2019 www.maker-win.net Inc. All rights reserved. 
 *  
 */
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.rpc.provider.NetModel;
import org.rpc.provider.SerializeUtils;


public class ProxyFactory {

    private static InvocationHandler handler = new InvocationHandler() {

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

            NetModel netModel = new NetModel();

            Class<?>[] classes = proxy.getClass().getInterfaces();
            String className = classes[0].getName();

            netModel.setClassName(className);
            netModel.setArgs(args);
            netModel.setMethod(method.getName());

            String [] types = null; 
            if(args!=null) {
                types = new String [args.length];
                for (int i = 0; i < types.length; i++) {
                    types[i] = args[i].getClass().getName();
                }
            }
            netModel.setTypes(types);

            byte[] byteArray = SerializeUtils.serialize(netModel);
            Object send = RPCClient.send(byteArray);
            return send;
        }
    };

    @SuppressWarnings("unchecked")
    public static <T> T getInstance(Class<T> clazz) {
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), 
                new Class[]{clazz}, handler );
    }
}

启动Server服务端

在这里插入图片描述
启动RPC客户端
在这里插入图片描述

参考链接
https://www.cnblogs.com/codingexperience/p/5930752.html
https://blog.csdn.net/u013034378/article/details/80686233

寻找手艺人
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现简单的RPC
绝版丶废材的博客
10-16 628
文章目录RPC解析JavaSocket反射机制代理模式静态代理静态代理的缺点如何改进？动态代理RPC国内国外 RPC解析 什么是RPC呢？RPC（Remote Procedure Call）是指远程过程调用，也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。分布式系统各个几点...
经典Java RPC框架细讲Dubbo
weixin_62421895的博客
07-25 1421
即开发者无论是调用本地的还是远程的函数，本质上编写的调用代码基本上都是相同的。当服务越来越多，服务资源得不到合理的利用逐渐呈现出来（例如有的服务调用频率特别大，有的服务调用频率又特别小，此时应该协调出调用频率小的服务器资源给调用频率高的服务），此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。就是无法在一个进程内，甚至一个计算机内通过本地调用的方式完成的需求，比如不同的系统间的通讯，甚至不同的组织间的通讯，由于计算能力需要横向扩展，需要在多台机器组成的集群上部署应用。...
[Java] 浅析rpc的原理及所用到的基本底层技术
ToraNe的博客
11-23 1939
通过本文笔者希望我们大家都能理解rpc的本质到底是什么，这样无论是面对阿帕奇的dubbo、谷歌的gRPC亦或是老旧的SOAP，咱们都能快速的理解其到底是在干什么。 商业产品无穷无尽，唯有理解其本质才能以不变应万变。
浅谈java网络编程及RPC框架
tang_seven的博客
04-19 1046
简单总结java网络编程相关知识点，包括基于TCP协议和基于UDP协议的网络编程，同时简单总结基于TCP协议下的RPC框架的相关知识点
Netty实战 -- 使用Netty实现分布式框架Dubbo RPC
最新发布
2401_85111576的博客
05-28 693
RPC【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式，他是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。比较知名的阿里Dubbo、Google的GRPC、Go的RPCX、Apache的Thrift，SpringCloud1.1 RPC基本原理。
Java实现RPC(源码)
2301_79098684的博客
04-12 1004
远程调用时，RPC实现了调用远程服务能够像本地调用一样方便，让调用者感知不到远程调用的逻辑。
JAVA实现简单RPC框架
01-17
在这个“JAVA实现简单RPC框架”的项目中，我们将探讨如何利用Java的核心特性来构建这样的框架。以下是关键知识点的详细说明： 1. **JDK动态代理**： JDK动态代理是Java提供的一种机制，可以在运行时创建一个实现了...
Java如何实现简单的RPC框架
08-18
Java实现简单的RPC框架 Java如何实现简单的RPC框架是一个非常重要的话题， RPC全称为Remote Procedure Call，即远程过程调用，它是一个计算机通信协议。它允许像调用本地服务一样调用远程服务。它可以有不同的实现...
Java实现简单的RPC框架的示例代码
08-28
下面是一个简单的Java实现RPC框架的示例代码： 服务提供者接口定义与实现： ```java public interface HelloService { String sayHi(String name); } public class HelloServiceImpl implements HelloService { ...
RPC原理及JAVA实现
热门推荐
许保殿的博客
06-05 1万+
RPC java实例 文章包括以下两个部分： - RPC基本原理 - RPC Java实例讲解 废话不多说，现在讲讲RPC到底是什么 RPC基本原理 RPC全程Remote Procedure Call Protocol，即远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程...
最简单的JAVA RPC框架实现
05-10
不依赖任何第三方类库，自己实现一个JAVA版的最简单RPC框架。对理解dubbo，thrift原理有所帮助
自定义RPC的Java实现
06-27
自定义RPC(远程方法调用)的Java实现。
rpac后台权限管理系统
09-30
rpac 后台管理系统，附带数据库sql 文件，支持mysql,oracle,下载即运行
使用Java实现简单RPC框架
weixin_42605397的博客
02-12 513
实现简单的RPC框架需要遵循以下步骤： 定义接口：首先需要定义一个接口，其中包含所有可远程调用的方法。 服务端实现：服务端需要实现定义的接口，并通过服务端的程序来向客户端提供远程访问的服务。 客户端实现：客户端需要消息代理，用于将请求发送到服务端并接收服务端的响应。 网络通信：需要在服务端和客户端之间进行网络通信，以传递请求和响应。 Java提供了很多用于网络通信的工具，例如Java ...
轻量级分布式 RPC 框架
hanghangde的博客
04-04 729
RPC，即 Remote Procedure Call（远程过程调用），说得通俗一点就是：调用远程计算机上的服务，就像调用本地服务一样。RPC 可基于 HTTP 或 TCP 协议，Web Service 就是基于 HTTP 协议的 RPC，它具有良好的跨平台性，但其性能却不如基于 TCP 协议的 RPC。会两方面会直接影响 RPC 的性能，一是传输方式，二是序列化。众所周知，TCP 是传输层协议，H
用Java实现简单RPC
Kixuan214的博客
01-17 1185
用java实现简单实现RPC注册中心、服务发现、服务调用、共享数据、负载均衡、重试机制、服务mock...完整代码：https://github.com/kixuan/SimpleRPC。
JAVA中几种常用的RPC框架介绍
架构师的方向
04-23 1万+
点击打开链接
使用Java实现简易RPC框架
汐日南莘的博客
05-14 1953
RPC其全程为Remote Process Call，即为远程过程调用。RPC将传统的本地调用转换为调用远端的服务器的方法，给系统的处理能力和吞吐量带来了极大的提升。 随着项目的发展，业务越来越复杂，单个项目的话，会非常复杂，且不易维护，如果单个项目挂了就会导致整个系统都无法使用，但是把复杂的业务拆分为多个小业务就方便系统的维护与开发。这种情况下就会有系统之间的相互调用。当日调用量不大的时候

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值