手写RPC基于netty

最新推荐文章于 2022-10-15 12:04:57 发布
最新推荐文章于 2022-10-15 12:04:57 发布
阅读量237 收藏 1
点赞数
分类专栏： Java 文章标签： netty 手写rpc rpc 基于netty 自定义rpc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yl_hahha/article/details/95595681
版权

什么是rpc？
RPC，即 Remote Procedure Call（远程过程调用），调用远程计算机上的服务，就像调用本地服务一
样，相当于你new对象，然后对象点方法 object.tostring()一样一样滴，jvm帮你调用 ，帮你取指译码执行等，rpc其实是本地创建代理，代理分为静态与动态（jdk与cglib，dubbo是另一种字节码）。

rpc实现步骤

  1. 服务消费方（client）调用以本地调用方式调用服务；
  2. client stub 接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
  3. client stub 找到服务地址，并将消息发送到服务端；
  4. server stub 收到消息后进行解码；
  5. server stub 根据解码结果调用本地的服务；
  6. 本地服务执行并将结果返回给 server stub；
  7. server stub 将返回结果打包成消息并发送至消费方；
  8. client stub 接收到消息，并进行解码；
  9. 服务消费方得到最终结果。

与其他rpc框架相比 ，我们框架缺少什么？
例如 我们缺少路由（标签路由，脚本路由，条件路由），重试（根据配置重试次数，然后for循环等），负载均衡（随机，hash一致性，轮训），注册中心（我们采用相当与直连）等。
关于netty
文章给出详细注解，算是入门级别，可以详细看下，与我们传统编程的区别，编码解码都是netty默认的
我们给出代码
github地址：https://github.com/ylha/rpcdemo.git
https://github.com/ylha/rpcclient1
server端

package com.test;

import java.io.Serializable;

/**
 * serversub
 */
public class ClassInfo implements Serializable {
    /**
     * 序列化id
     */
    /**
     * 服务端存根就是根据收到的请求信息执行相应的业务逻辑调用并把结果返回客户端
     */
    private static final long serialVersionUID = -7821682294197810003L;

    private String className;//类名

    private String methodName;//返回值

    private Class<?>[] types; //参数类型

    private Object[] objects; //参数列表

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public String getClassName() {
        return className;
    }

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

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Class<?>[] getTypes() {
        return types;
    }

    public void setTypes(Class<?>[] types) {
        this.types = types;
    }

    public Object[] getObjects() {
        return objects;
    }

    public void setObjects(Object[] objects) {
        this.objects = objects;
    }
}

服务端接口

package com.test;
/**
 * 接口
 */
public interface HelloRPC {
    String hello(String name);
}

服务端实现类

 package com.test;


/**
 * 接口实现类
 * @author admin
 */
public class HelloRpcImpl implements HelloRPC {
    @Override
    public String hello(String name) {
        return "hello,myGirlFriend" + "=====>>>>" + name;
    }
}

处理器 InvokeHandler

package com.test;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.reflections.Reflections;

import java.lang.reflect.Method;
import java.util.Set;

public class InvokeHandler extends ChannelInboundHandlerAdapter {
    /**
     * 触发读事件，重写读取消息的方法，
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ClassInfo classInfo = (ClassInfo) msg;

        Object clazz = Class.forName(getImplClassName(classInfo)).newInstance();
        Method method = clazz.getClass().getMethod(classInfo.getMethodName(), classInfo.getTypes());
        //通过反射调用实现类的方法
        Object result = method.invoke(clazz, classInfo.getObjects());
        ctx.writeAndFlush(result);
    }

    /**
     * 获取实现类，调用实现类方法， 写回response
     */
    private String getImplClassName(ClassInfo classInfo) throws ClassNotFoundException {

        String interfacePath = "com.test";

        int lastDot = classInfo.getClassName().lastIndexOf(".");
        String interfaceName = classInfo.getClassName().substring(lastDot);


        Class<?> aClass = Class.forName(interfacePath + interfaceName);

        Reflections reflections = new Reflections(interfacePath);

        //得到某接口下的所有实现类
        Set<Class<?>> ImplClassSet = (Set<Class<?>>) reflections.getSubTypesOf(aClass);
        if (ImplClassSet.size() == 0) {
            System.out.println("未找到实现类");
            return null;
        } else if (ImplClassSet.size() > 1) {
            System.out.println("找到多个实现类，未明确使用哪一个");
            return null;
        } else {
            //把集合转换为数组
            Class[] classes = ImplClassSet.toArray(new Class[0]);
            return classes[0].getName();//得到实现类的名字
        }

    }
}

netty服务端

 package com.test;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

/**
 * 参考博文 https://www.jianshu.com/p/ce5a73093916
 */
public class NettyServerTest {
    private int port;

    /**
     * 端口号
     *
     * @param port
     */
    public NettyServerTest(int port) {
        this.port = port;
    }

    public void start() {
        /**
         * 1.基于netty写的rpc，首先我们应该了解  jdk1.4中的nio ，然后我们看netty 会相对容易一些，nio中涉及的组件有 buffer，channel，selector
         * 2.bossGroup中的每个eventLoop（事件循环）会维护一个selector和taskQueue，负责处理客户端请求和内部任务，如ServerSocketChannel注册和ServerSocket绑定等。
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        //真正干活的eventloop
        EventLoopGroup workGrop = new NioEventLoopGroup();
        ServerBootstrap b = new ServerBootstrap();
        //Java NIO中的 ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。
        //设置 EventLoopGroup，其提供了用
        //于处理Channel 事件的EventLoop
        b.group(bossGroup, workGrop).channel(NioServerSocketChannel.class).
                //　ChannelOption.SO_BACKLOG对应的是tcp/ip协议listen函数中的backlog参数，函数listen(int socketfd,int backlog)用来初始化服务端可连接队列
                        option(ChannelOption.SO_BACKLOG, 128).childOption(ChannelOption.SO_KEEPALIVE, true)
                //绑定端口号
                /*handler() 方法和 childHandler() 方法之间的区别是：前者所
                添加的 ChannelHandler 由接受子 Channel 的 ServerChannel 处理，而
                childHandler() 方法所添加的 ChannelHandler 将由已被接受的子 Channel
                处理，其代表一个绑定到远程节点的套接字
                */
                .localAddress(port).childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
                /*
                 *
                 * <pre>
                 *                                                 I/O Request
                 *                                            via {@link Channel} or
                 *                                        {@link ChannelHandlerContext}
                 *                                                      |
                 *  +---------------------------------------------------+---------------+
                 *  |                           ChannelPipeline         |               |
                 *  |                                                  \|/              |
                 *  |    +---------------------+            +-----------+----------+    |
                 *  |    | Inbound Handler  N  |            | Outbound Handler  1  |    |
                 *  |    +----------+----------+            +-----------+----------+    |
                 *  |              /|\                                  |               |
                 *  |               |                                  \|/              |
                 *  |    +----------+----------+            +-----------+----------+    |
                 *  |    | Inbound Handler N-1 |            | Outbound Handler  2  |    |
                 *  |    +----------+----------+            +-----------+----------+    |
                 *  |              /|\                                  .               |
                 *  |               .                                   .               |
                 *  | ChannelHandlerContext.fireIN_EVT() ChannelHandlerContext.OUT_EVT()|
                 *  |        [ method call]                       [method call]         |
                 *  |               .                                   .               |
                 *  |               .                                  \|/              |
                 *  |    +----------+----------+            +-----------+----------+    |
                 *  |    | Inbound Handler  2  |            | Outbound Handler M-1 |    |
                 *  |    +----------+----------+            +-----------+----------+    |
                 *  |              /|\                                  |               |
                 *  |               |                                  \|/              |
                 *  |    +----------+----------+            +-----------+----------+    |
                 *  |    | Inbound Handler  1  |            | Outbound Handler  M  |    |
                 *  |    +----------+----------+            +-----------+----------+    |
                 *  |              /|\                                  |               |
                 *  +---------------+-----------------------------------+---------------+
                 *                  |                                  \|/
                 *  +---------------+-----------------------------------+---------------+
                 *  |               |                                   |               |
                 *  |       [ Socket.read() ]                    [ Socket.write() ]     |
                 *  |                                                                   |
                 *  |  Netty Internal I/O Threads (Transport Implementation)            |
                 *  +-------------------------------------------------------------------+
                 * </pre>
                 */
                ChannelPipeline channelPipeline = socketChannel.pipeline();
                //编码器
                channelPipeline.addLast("encoder", new ObjectEncoder())
                        //解码器
                        .addLast("decoder", new ObjectDecoder(Integer.MAX_VALUE, ClassResolvers.cacheDisabled(null)))

                        /**
                         *  //ChannelInboundHandler——处理入站数据以及各种状态变化；
                         * //ChannelOutboundHandler——处理出站数据并且允许拦截所有的操作。
                         * 业务逻辑处理
                         */
                        .addLast(new InvokeHandler());
            }
        });

        ChannelFuture future = null;
        try {
            //绑定端口
            future = b.bind(port).sync();
            System.out.println("......准备好了么？......");
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            //优雅关闭
            bossGroup.shutdownGracefully();
            workGrop.shutdownGracefully();
        }

    }

    public static void main(String[] args) {
        new NettyServerTest(9999).start();
    }
}

客户端

package com.test;

import java.io.Serializable;

/**
 * serversub
 */
public  class  ClassInfo implements Serializable {
    /**
     * 序列化id
     */
    /**
     * 客户端存根的作用是把请求的参数以约定的通讯协议打包好发送给服务端然后解析服务端返回消息
     */
    private String className;//类名

    private String methodName;//返回值

    private Class<?>[] types; //参数类型

    private Object[] objects; //参数列表


    public String getClassName() {
        return className;
    }

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

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Class<?>[] getTypes() {
        return types;
    }

    public void setTypes(Class<?>[] types) {
        this.types = types;
    }

    public Object[] getObjects() {
        return objects;
    }

    public void setObjects(Object[] objects) {
        this.objects = objects;
    }
}

客户端接口

package com.test;

public interface HelloRPC {
    String hello(String s);
}

客户端代理类

package com.test;


import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

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

public class NettyRpcProxy {
    public static Object createProxy(final Class target) {
        return Proxy.newProxyInstance(target.getClassLoader(),new Class[]{target}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //封装ClassInfo
                ClassInfo classInfo = new ClassInfo();
                classInfo.setClassName(target.getName());
                classInfo.setMethodName(method.getName());
                classInfo.setObjects(args);
                classInfo.setTypes(method.getParameterTypes());
                //开始用Netty发送数据
                EventLoopGroup workerGroup = new NioEventLoopGroup();
                final ResultHandler resultHandler = new ResultHandler();
                Bootstrap b = new Bootstrap();
                b.group(workerGroup).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        //编码器
                        pipeline.addLast("encoder", new ObjectEncoder())
                                //解码器,构造方法第一个参数设置二进制的最大字节数,第二个参数设置具体使用哪个类解析器
                                .addLast("decoder", new ObjectDecoder(Integer.MAX_VALUE, ClassResolvers.cacheDisabled(null)))
                                //客户端业务处理类
                                .addLast("handler", resultHandler);
                    }
                });
                ChannelFuture future = b.connect("127.0.0.1", 9999).sync();
                //发送请求数据
                future.channel().writeAndFlush(classInfo).sync();
                future.channel().closeFuture().sync();
                return resultHandler.getResponse();
            }
        });
    }

    public static void main(String[] args) {
        HelloRPC helloRPC = (HelloRPC) NettyRpcProxy.createProxy(HelloRPC.class);
        System.out.println(helloRPC.hello("RPC"));
    }
}

结果处理器

package com.test;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class ResultHandler extends ChannelInboundHandlerAdapter {

    private Object response;

    public Object getResponse() {
        return response;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        response = msg;
        ctx.close();
    }
}
天色以渐黑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写百万并发连接的RPC框架之Netty篇
Cover_sky的博客
02-05 424
前言 前面我们已经介绍了，使用JDK原生自带的Socket门面模式手写了注册中心、远程客户端、远程服务端三个模块来构成一个RPC框架，但是性能不是很高，远远无法支撑起大型的分布式系统之间的调用，于是我们今天来分享下如何用Netty来手写RPC框架，并用它来支撑起百万并发，为了便于理解，暂时先不实现注册中心。在该项目中还跟Spring进行了整合。 结构示意图 核心组件 LengthFieldBasedFrameDecoder:解决网络传输中的粘包半包问题 KryoEncoder/Decoder:负责网络数
基于Netty手写RPC框架
Java是世界上最好的语言
04-27 1263
1. RPC 框架 什么是RPC框架？他的全称是remoto proceduer call，他旨在让我们开发者能够像调用本地服务一样调用远程服务。 最常见的就是DUBBO框架。 举一个栗子： 比如在我们的电商系统里面有一个用户服务和商品服务，然后在商品服务中有一个查询商品的接口方法，我们只需要在商品服务中暴露出一个接口，然后将其上传至maven仓库中，这样在我们的用户服务中就可以直接调用了。 RPC框架可以让我们不需要去关心网络通信的复杂细节和复杂组成，只需要聚焦业务的处理即可，所以极大降低了我们开发的门
netty学习之手写RPC框架
技术随笔
04-12 933
文章目录RPC简介RPC框架需求分析实现步骤创建API工程创建工程并导入依赖定义业务接口定义常量类创建Server工程导入依赖实现业务接口定义服务端消息处理器定义服务器类定义启动类创建client工程客户端处理类客户端动态代理类定义消费者类执行测试总结 RPC简介 RPC，Remote Procedure Call，远程过程调用，是一种通过网络从远程计算机上请求服务，而不需要了解底层网络技术的协议...
手写RPC框架项目代码解读——Netty版本
最新发布
qq_41523340的博客
10-15 1003
使用注解开发，而不是xml配置文件，好处是便捷性，操作性。 @Builder主要作用是用来生成对象，并能够进行链式赋值。 @RpcService放在服务实现类上。 @RpcReference放在服务引用上。
Netty 笔记-手写一个 RPC 程序
Java 小先
08-03 268
源代码仓库 https://github.com/zhshuixian/netty-notes RPC(Remote Proceduce Call 远程过程调用) 一般用来实现部署在不同机器上的系统之间的方法调用，使程序能够像访问本地系统资源一样，通过网络传输过去访问远端系统资源。 这里将使用 Netty 编写一个非常简单的 RPC 程序，项目大概的示意图如下： 在上一个项目的基础上，新建子项目 03-netty-rpc ,项目的依赖和 Maven 配置见 GitHub 的项目仓库。 1、Proto
Netty4.1实战-手写RPC框架.pdf
09-01
RPC是一种远程调用的通信协议，例如dubbo、thrift等，我们在互联网高并发应用开发时候都会使用到类似的服务。本专题主要通过三个章节实现一个rpc...- 手写RPC框架第二章《netty通信》 - 手写RPC框架第三章《RPC中间件》
基于netty的手写rpc框架
04-12
在本项目中，我们将基于Netty实现一个手写的RPC框架。Netty是Java领域的一个高性能、异步事件驱动的网络应用程序框架，常用于构建高效的服务器和客户端。 首先，我们需要理解RPC框架的基本组成部分： 1. **服务...
基于Netty手写Dubbo框架
05-04
基于Netty手写Dubbo,该资源包含 1、生产者向zk服务的注册，消费者发现服务。 2、RPC远程调用实现。 3、netty服务调用，对象序列化和反序列化。 4、负载均衡的简单实现 详情见博客：...
Netty核心原理剖析与RPC实践pd手抄
05-27
Netty核心原理剖析与RPC实践手抄版本，基本复刻了全部内容，如有丢失请私聊
RPC原理解析
Swordfall的博客
04-01 242
1.RPC原理解析 1.1 什么是RPC RPC(Remote Procedure Call Protocol)——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP/IP或UDP，为通信程序之间携带信息数据。RPC将原来的本地调用转变为调用远端的服务器上的方法，给系统的处理能力和吞吐量带来了近似于无限制提升...
如何用Netty写一个自己的RPC框架
01-03
netty是一个高性能高度封装的nio框架，本文实现用netty实现一个简化的rpc框架
netty实战--手写rpc框架
u014493323的博客
06-27 540
在看此篇内容时需要浏览下面内容 从零开始学netty——如何面对粘包和拆包 从零开始学netty——自定义协议 rpc简介 rpc大家大概都听说过，远程过程调用。简单来说，就是我的一个操作是远程操作的给的结果，举个例子，考试作弊，你把考题发出去了，你同学帮你做好把答案传输给你，然后你就把答...
手写基于netty的简单RPC框架
耶律妙月的博客
07-07 624
主要技术点设计： 注册中心：使用 MySQL注册服务信息 序列化手段：hessian（本想用fastjson，然而对于泛型的处理实在太麻烦了） 桩的生成方式：调用时使用模板和反射动态生成 java源代码并编译加载 通信协议：大概会用netty自带的LengthFieldBasedFrameDecoder 来处理粘包拆包吧 可插拔设计：SPI。注册中心、服务提供者都有使用到，方便后期替换不同的注册中心和服务实现类 项目基础结构： service-interface：服务模块，包含其中用到的实体类 cl
基于 Netty 手写 RPC
JAVA高级架构
05-28 518
原文地址：https://juejin.im/post/5cebcd7551882503050ed889RPC（Remote Procedure Call)，即远程过程调...
基于Netty手写的Rpc框架
zhejingyuan的专栏
09-19 707
基于Netty手写的rpc框架时序图 本项目一共分为三个模块：rpcServer、rpcClient、rpcCommon rpcCommon的依赖 <dependencies> <dependency> <groupId>io.netty</groupId> <artifactId>nett...
震惊，20岁的小伙子居然通过Netty手写了简单RPC框架
java专栏的博客
07-02 956
看我这标题，越来越觉得自己不去UC上班太浪费了，哈哈哈。。。本来这篇文章之前就要发布的，但是因为一些事情耽搁了 开始步入正题：手写RPC的简单实现 什么是RPC 常用的RPC框架有哪些 怎么实现 一丶什么是RPC 远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的思想。RPC 是一种技术思想而非一种规范或协议。 RPC 的核心功能主要有这几个部分组成...
手写Netty实现RPC接口远程调用客户端与服务器
芭蕉扇
12-21 5580
Java的IO分为BIO、NIO、AIO（NIO.2）， 其中它们分别含义是： Java BIO ： 同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。 Java NIO ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，...
手写RPC基于Netty含源码
田培融的博客
06-18 320
计划写一个RPC用于把学到的一些理论实践一下。下面记录每天干的事情和用到的知识点。 2020-06-18 项目初始化 在gitee上创建了一个项目，为什么不在github上呢？因为连接速度慢。为什么不提高一下速度呢？因为翻墙还得花钱。为什么不花钱呢？因为工资低，为什么工资低呢？因为技术太差。怎么样才能技术好呢？ 写一下RPC吧。 RPC地址 请各位START。 非常感谢。 目前用到的知识点 Java SPI。 ...
手写基于Netty的RPC框架【纯手写，超硬核】!
蛙广志
09-29 1213
写在前面 Netty作为网络编程的王者人物，写在简历上是妥妥的加分项，除了对Netty的基本使用和源码分析，这里博主提供一套基本的纯手写RPC框架，基于Netty的实战项目，写在简历上岂不美滋滋，代码食用地址 一、整体代码架构图 首先我们明白一款RPC框架需要哪些组件，以及整体的执行流程 我们需要那些组件或解决哪些问题？ 确定通讯协议，为了更好的理解RPC通讯原理，本框架使用自定义协议和Http协议两种形式 如何解决网络通讯中的拆包粘包？ 使用动态代理，使得客户端只需要调用需求的方法，在代理中获取请求信息

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值