使用Netty实现一套分布式RPC服务

最新推荐文章于 2023-09-01 13:30:40 发布
最新推荐文章于 2023-09-01 13:30:40 发布
阅读量570 收藏
点赞数
分类专栏： Netty 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pjh88/article/details/119568267
版权

写在前面

Netty作为一个异步事件驱动的网络应用框架，可以用于快速开发可维护的高性能服务器和客户端。国内著名的RPC框架Dubbo底层使用的是Netty作为网络通信的。本篇文章我们来探索一下RPC框架的本质以及使用Netty来实现一个简单地RPC框架。

什么是RPC

概述

RPC（Remote Procedure Call）— 远程过程调用，是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程

两个或多个应用程序都分布在不同的服务器上，它们之间的调用都像是本地方法调用一样(如图)

在这里插入图片描述

RPC与Socket的关系

通过上面的描述，好像RPC与Socket非常像，都是调用远程的方法，都是client/server模式。但是值得注意的是，RPC并不等同于Socket。Socket是RPC经常采用的通信手段之一，RPC是在Socket的基础上实现的，它比socket需要更多的网络和系统资源。除了Socket，RPC还有其他的通信方法，比如：http、操作系统自带的管道等技术来实现对于远程程序的调用。微软的Windows系统中，RPC就是采用命名管道进行通信。需要了解Socket相关概念的，可以参考之前的这篇文章golang socket编程。

调用方法的三种姿势

本地方法调用

本地方法调用使我们开发中最常见的，如下定义一个方法：

public String sayHello(String name) {
    return "hello, " + name;
}

只需要传入一个参数，调用sayHello方法就可以得到一个输出，入参、出参以及方法体都在同一个进程空间中，这就是本地方法调用

Socket通信

那有没有办法实现不同进程之间通信呢？调用方在进程A，需要调用方法B，但是方法B在进程B中。

在这里插入图片描述

最容易想到的实现方式

就是使用Socket通信，使用Socket可以完成跨进程调用，我们需要约定一个进程通信协议，来进行传参，调用函数，出参。写过Socket应该都知道，Socket是比较原始的方式，我们需要更多的去关注一些细节问题，比如参数和函数需要转换成字节流进行网络传输，也就是序列化操作，然后出参时需要反序列化。

假如RPC就是让我们在客户端直接使用Socket远程调用，那无疑是个灾难。所以有没有什么简单方法，让我们的调用方不需要关注细节问题，让调用方像调用本地函数一样，只要传入参数，调用方法，然后坐等返回结果就可以了呢？而这个诉求的解决方案就是RPC框架——为使用方屏蔽底层网络通信的细节。

RPC框架

RPC框架就是用来解决上面的问题的，它能够让调用方像调用本地函数一样调用远程服务，底层通讯细节对调用方是透明的，将各种复杂性都给屏蔽掉，给予调用方极致体验。

在这里插入图片描述

当server需要对方法内实现修改时，client完全感知不到，不用做任何变更。这种方式在跨部门，跨公司合作的时候是非常方便的。

常见的RPC框架

常见的 RPC 框架有: 比较知名的如阿里的Dubbo、google的gRPC、Go语言的rpcx、Apache的thrift， Spring 旗下的 Spring Cloud。

在这里插入图片描述

RPC基本调用流程图

在这里插入图片描述

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. 服务消费方(client)得到结果

小结：RPC 的目标就是将 2-8 这些步骤都封装起来，用户无需关心这些细节，可以像调用本地方法一样即可完成远程服务调用。

RPC调用过程存中需要关注的技术细节

前面就已经说到RPC框架，可以让调用像调用本地函数一样调用远程服务。原理就是RPC框架屏蔽Socket通信的相关细节，使调用方可以向调用本地方法一样调用远程方法。

在使用的时候，调用方是直接调用本地函数，传入相应参数，其他细节它不用管，至于通讯细节交给RPC框架来实现。实际上RPC框架采用代理类的方式，具体来说是动态代理的方式，在运行时动态创建新的类，也就是代理类，在该类中实现通讯的细节问题，比如与服务端的连接、参数序列化、结果反序列化等。

除了上述动态代理，还需要约定一个双方通信的协议格式，规定好协议格式，比如请求方法的类名、请求的方法名、请求参数的数据类型，请求的参数等，这样根据格式进行序列化后进行网络传输，然后服务端收到请求对象后按照指定格式进行解码，这样服务端才知道具体该调用哪个方法，传入什么样的参数。

刚才又提到网络传输，RPC框架重要的一环也就是网络传输，服务是部署在不同主机上的，如何高效的进行网络传输，尽量不丢包，保证数据完整无误的快速传递出去？实际上，就是利用我们今天的主角——Netty，Netty是一个高性能的网络通讯框架，它足以胜任我们的任务。

前面说了这么多，再次总结下一个RPC框架需要重点关注哪几个点：

  • 动态代理
  • 通信协议
  • 序列化
  • 网络传输

当然一个优秀的RPC框架需要关注的不止上面几点，只不过本篇文章旨在做一个简易的RPC框架，理解了上面关键的几点就够了

在这里插入图片描述

实操自己实现一个简单版的RPC

需求说明

dubbo 底层使用了 Netty 作为网络通讯框架，要求用 Netty 实现一个简单的 RPC 框架 模仿 dubbo，消费者和提供者约定接口和协议，消费者远程调用提供者的服务，提供者返回一个字符串，消费者打印提供者返回的数据。底层网络通信使用 Netty 4.1.20

涉及说明

创建一个接口，定义抽象方法。用于消费者和提供者之间的约定。 创建一个提供者，该类需要监听消费者的请求，并按照约定返回数据。 创建一个消费者，该类需要透明的调用自己不存在的方法，内部需要使用 Netty 请求提供者返回数据

服务调用流程说明

  1. 服务消费方(client)以本地调用方式调用服务
  2. client stub 接收到调用后负责将方法、参数等封装成能够进行网络传输的消息体
  3. client stub 将消息进行编码并发送到服务端
  4. server stub 收到消息后进行解码
  5. server stub 根据解码结果调用本地的服务
  6. 本地服务执行并将结果返回给
  7. server stub server stub 将返回导入结果进行编码并发送至消费方
  8. client stub 接收到消息并进行解码
  9. 服务消费方(client)得到结果

RPC 的目标就是将 2-8 这些步骤都封装起来，用户无需关心这些细节，可以像调用本地方法一样即可完成远程服务调用。

代码实现

公共接口实现

//这个是接口，是服务提供方和 服务消费方都需要
public interface HelloService {

    String hello(String mes);
}

服务提供方实现接口

public class HelloServiceImpl implements HelloService {

    private static int count = 0;
    //当有消费方调用该方法时， 就返回一个结果
    @Override
    public String hello(String mes) {
        System.out.println("收到客户端消息=" + mes);
        //根据mes 返回不同的结果
        if(mes != null) {
            return "你好客户端, 我已经收到你的消息 [" + mes + "] 第" + (++count) + " 次";
        } else {
            return "你好客户端, 我已经收到你的消息 ";
        }
    }
}

服务提供方的相关代码

NettyServer
public class NettyServer {


    public static void startServer(String hostName, int port) {
        startServer0(hostName,port);
    }

    //编写一个方法，完成对NettyServer的初始化和启动

    private static void startServer0(String hostname, int port) {

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {

            ServerBootstrap serverBootstrap = new ServerBootstrap();

            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                                      @Override
                                      protected void initChannel(SocketChannel ch) throws Exception {
                                          ChannelPipeline pipeline = ch.pipeline();
                                          pipeline.addLast(new StringDecoder());
                                          pipeline.addLast(new StringEncoder());
                                          pipeline.addLast(new NettyServerHandler()); //业务处理器

                                      }
                                  }

                    );

            ChannelFuture channelFuture = serverBootstrap.bind(hostname, port).sync();
            System.out.println("服务提供方开始提供服务~~");
            channelFuture.channel().closeFuture().sync();

        }catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}
NettyServerHandler
//服务器这边handler比较简单
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取客户端发送的消息，并调用服务
        System.out.println("msg=" + msg);
        //客户端在调用服务器的api 时，我们需要定义一个协议
        //比如我们要求 每次发消息是都必须以某个字符串开头 "HelloService#hello#你好"
        if(msg.toString().startsWith(ClientBootstrap.providerName)) {

            String result = new HelloServiceImpl().hello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
            ctx.writeAndFlush(result);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}
ServerBootstrp：启动服务
//ServerBootstrap 会启动一个服务提供者，就是 NettyServer
public class ServerBootstrap {
    public static void main(String[] args) {

        //代码代填..
        NettyServer.startServer("127.0.0.1", 7000);
    }
}

服务消费方代码

NettyClient
public class NettyClient {

    //创建线程池
    private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    private static NettyClientHandler client;
    private int count = 0;

    //编写方法使用代理模式，获取一个代理对象

    public Object getBean(final Class<?> serivceClass, final String providerName) {

        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class<?>[]{serivceClass}, (proxy, method, args) -> {

                    System.out.println("(proxy, method, args) 进入...." + (++count) + " 次");
                    //{}  部分的代码，客户端每调用一次 hello, 就会进入到该代码
                    if (client == null) {
                        System.out.println("Handler为空");
                        initClient();
                    }
                    System.out.println("Handler不为空");

                    //设置要发给服务器端的信息
                    //providerName 协议头 args[0] 就是客户端调用api hello(???), 参数
                    client.setPara(providerName + args[0]);

                    //
                    return executor.submit(client).get();

                });
    }

    public NettyClient() {
        initClient();
    }

    //初始化客户端
    private static void initClient() {
        client = new NettyClientHandler();
        //创建EventLoopGroup
        NioEventLoopGroup group = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY, true)
                .handler(
                        new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ChannelPipeline pipeline = ch.pipeline();
                                pipeline.addLast(new StringDecoder());
                                pipeline.addLast(new StringEncoder());
                                pipeline.addLast(client);
                            }
                        }
                );

        try {
            bootstrap.connect("127.0.0.1", 7000).sync();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
NettyClientHandler
public class NettyClientHandler extends ChannelInboundHandlerAdapter implements Callable {

    private ChannelHandlerContext context;//上下文
    private String result; //返回的结果
    private String para; //客户端调用方法时，传入的参数


    //与服务器的连接创建后，就会被调用, 这个方法是第一个被调用(1)
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(" channelActive 被调用  ");
        context = ctx; //因为我们在其它方法会使用到 ctx
        System.out.println("初始化ctx....");
        System.out.println(ctx);
    }

    //收到服务器的数据后，调用方法 (4)
    //
    @Override
    public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println(" channelRead 被调用  ");
        result = msg.toString();
        notify(); //唤醒等待的线程
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }

    //被代理对象调用, 发送数据给服务器，-> wait -> 等待被唤醒(channelRead) -> 返回结果 (3)-》5
    @Override
    public synchronized Object call() throws Exception {
        System.out.println(" call1 被调用  ");
        context.writeAndFlush(para);
        //进行wait
        wait(); //等待channelRead 方法获取到服务器的结果后，唤醒
        System.out.println(" call2 被调用  ");
        return  result; //服务方返回的结果

    }
    //(2)
    void setPara(String para) {
        System.out.println(" setPara  ");
        this.para = para;
    }
}
ClientBootStrap
public class ClientBootstrap {


    //这里定义协议头
    public static final String providerName = "HelloService#hello#";

    public static void main(String[] args) throws  Exception{

        //创建一个消费者
        NettyClient customer = new NettyClient();

        //创建代理对象
        HelloService service = (HelloService) customer.getBean(HelloService.class, providerName);

        for (int i = 0; i < 3; i++) {
            Thread.sleep(2 * 1000);
            //通过代理对象调用服务提供者的方法(服务)
            String res = service.hello("你好 dubbo~");
            System.out.println("调用的结果 res= " + res);
        }
    }
}

测试

F:\java1.8\bin\java.exe "-javaagent:F:\IDEA2020.2\IntelliJ IDEA 2020.2\lib\idea_rt.jar=53999:F:\IDEA2020.2\IntelliJ IDEA 2020.2\bin" -Dfile.encoding=UTF-8 -classpath F:\java1.8\jre\lib\charsets.jar;F:\java1.8\jre\lib\deploy.jar;F:\java1.8\jre\lib\ext\access-bridge-64.jar;F:\java1.8\jre\lib\ext\cldrdata.jar;F:\java1.8\jre\lib\ext\dnsns.jar;F:\java1.8\jre\lib\ext\jaccess.jar;F:\java1.8\jre\lib\ext\jfxrt.jar;F:\java1.8\jre\lib\ext\localedata.jar;F:\java1.8\jre\lib\ext\nashorn.jar;F:\java1.8\jre\lib\ext\sunec.jar;F:\java1.8\jre\lib\ext\sunjce_provider.jar;F:\java1.8\jre\lib\ext\sunmscapi.jar;F:\java1.8\jre\lib\ext\sunpkcs11.jar;F:\java1.8\jre\lib\ext\zipfs.jar;F:\java1.8\jre\lib\javaws.jar;F:\java1.8\jre\lib\jce.jar;F:\java1.8\jre\lib\jfr.jar;F:\java1.8\jre\lib\jfxswt.jar;F:\java1.8\jre\lib\jsse.jar;F:\java1.8\jre\lib\management-agent.jar;F:\java1.8\jre\lib\plugin.jar;F:\java1.8\jre\lib\resources.jar;F:\java1.8\jre\lib\rt.jar;D:\IDEAWorkSpace\Netty\Spring\target\classes;E:\Maven\warehouse\maven_repository\org\springframework\spring-core\5.3.1\spring-core-5.3.1.jar;E:\Maven\warehouse\maven_repository\org\springframework\spring-jcl\5.3.1\spring-jcl-5.3.1.jar;E:\Maven\warehouse\maven_repository\org\springframework\spring-beans\5.3.1\spring-beans-5.3.1.jar;E:\Maven\warehouse\maven_repository\org\springframework\spring-context\5.3.1\spring-context-5.3.1.jar;E:\Maven\warehouse\maven_repository\org\springframework\spring-aop\5.3.1\spring-aop-5.3.1.jar;E:\Maven\warehouse\maven_repository\org\springframework\spring-expression\5.3.1\spring-expression-5.3.1.jar;E:\Maven\warehouse\maven_repository\org\junit\jupiter\junit-jupiter\5.8.0-M1\junit-jupiter-5.8.0-M1.jar;E:\Maven\warehouse\maven_repository\org\junit\jupiter\junit-jupiter-api\5.8.0-M1\junit-jupiter-api-5.8.0-M1.jar;E:\Maven\warehouse\maven_repository\org\apiguardian\apiguardian-api\1.1.1\apiguardian-api-1.1.1.jar;E:\Maven\warehouse\maven_repository\org\opentest4j\opentest4j\1.2.0\opentest4j-1.2.0.jar;E:\Maven\warehouse\maven_repository\org\junit\platform\junit-platform-commons\1.8.0-M1\junit-platform-commons-1.8.0-M1.jar;E:\Maven\warehouse\maven_repository\org\junit\jupiter\junit-jupiter-params\5.8.0-M1\junit-jupiter-params-5.8.0-M1.jar;E:\Maven\warehouse\maven_repository\org\junit\jupiter\junit-jupiter-engine\5.8.0-M1\junit-jupiter-engine-5.8.0-M1.jar;E:\Maven\warehouse\maven_repository\org\junit\platform\junit-platform-engine\1.8.0-M1\junit-platform-engine-1.8.0-M1.jar;E:\Maven\warehouse\maven_repository\org\jetbrains\kotlin\kotlin-stdlib-jdk8\1.4.20\kotlin-stdlib-jdk8-1.4.20.jar;E:\Maven\warehouse\maven_repository\org\jetbrains\kotlin\kotlin-stdlib\1.4.20\kotlin-stdlib-1.4.20.jar;E:\Maven\warehouse\maven_repository\org\jetbrains\kotlin\kotlin-stdlib-common\1.4.20\kotlin-stdlib-common-1.4.20.jar;E:\Maven\warehouse\maven_repository\org\jetbrains\annotations\13.0\annotations-13.0.jar;E:\Maven\warehouse\maven_repository\org\jetbrains\kotlin\kotlin-stdlib-jdk7\1.4.20\kotlin-stdlib-jdk7-1.4.20.jar;E:\Maven\warehouse\maven_repository\io\netty\netty-all\4.1.18.Final\netty-all-4.1.18.Final.jar;E:\Maven\warehouse\maven_repository\com\alibaba\fastjson\1.2.28\fastjson-1.2.28.jar com.pjh.Example.dubborpc.customer.ClientBootstrap
channelActive 被调用  
初始化ctx....
ChannelHandlerContext(NettyClientHandler#0, [id: 0x7a836196, L:/127.0.0.1:58448 - R:/127.0.0.1:7000])
(proxy, method, args) 进入....1 次
Handler不为空
 setPara  
 call1 被调用  
 channelRead 被调用  
 call2 被调用  
调用的结果 res= 你好客户端, 我已经收到你的消息 [你好 dubbo~] 第1 次
(proxy, method, args) 进入....2 次
Handler不为空
 setPara  
 call1 被调用  
 channelRead 被调用  
 call2 被调用  
调用的结果 res= 你好客户端, 我已经收到你的消息 [你好 dubbo~] 第2 次
(proxy, method, args) 进入....3 次
Handler不为空
 setPara  
 call1 被调用  
 channelRead 被调用  
 call2 被调用  
调用的结果 res= 你好客户端, 我已经收到你的消息 [你好 dubbo~] 第3 次

msg=HelloService#hello#你好 dubbo~
收到客户端消息=你好 dubbo~
msg=HelloService#hello#你好 dubbo~
收到客户端消息=你好 dubbo~
msg=HelloService#hello#你好 dubbo~
收到客户端消息=你好 dubbo~

实操自己实现一个复杂版的RPC框架

后续更新。。。。

一只胡说八道的猴子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
实现Netty分布式解决思路
wzx7612302的博客
03-11 5039
netty分布式服务如何实现 在说nettty分布式之前，首先说下，netty是基于nio编程的，如果大家对nio不熟悉还是先看下nio相关的知识。 netty的线程模型和核心组件 1:netty的线程模型 netty通过Reactor模型基于多路复用器接收并处理用户请求（能讲就多讲一点），内部实现了两个线程池，boss线程池和work线程池，其中boss线程池的线程负责处理请求的accept事件...
netty实现自定义rpc.zip
12-26
本项目"Netty实现自定义RPC"旨在教你如何利用Netty构建自己的RPC框架。 首先，我们需要理解RPC的基本原理。RPC的核心是将远程服务调用的过程透明化，使它看起来就像是本地方法调用一样。这涉及到序列化、网络通信和...
Netty22——用Netty实现RPC
如不來的博客
03-17 1605
一、RPC介绍  RPC（Remote Procedure Call）— 远程过程调用，是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序， 而程序员无需额外地为这个交互编程。两个或多个应用程序分布在不同的服务器上，它们之间的调用像是本地方法调用一样。  常见的 RPC 框架有：阿里的Dubbo、google的gRPC、Go语言的rpcx、 Apache的thrift，以及Spring 旗下的 Spring Cloud。  在RPC 中， Client 叫服务消费者，Serv
彻底理解分布式Netty，这一篇文章就够了！
baichangping的博客
02-10 1244
彻底理解分布式Netty，这一篇文章就够了！ 转载 ...
用Netty实现RPC
专栏
07-13 679
用Netty实现RPC 一、RPC 基本介绍 RPC（Remote Procedure Call）— 远程过程调用，是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程 两个或多个应用程序都分布在不同的服务器上，它们之间的调用都像是本地方法调用一样(如图) 3） 常见的 RPC 框架有: 比较知名的如阿里的Dubbo、google 的gRPC、Go 语言的rpcx、Apache 的thrift，Spring 旗下的 Spring
基于Java的Thunder分布式RPC框架设计源码
最新发布
05-26
Nepxion Thunder是一个基于Java的分布式RPC框架，集成了Netty、Hessian、Kafka、ActiveMQ、Tibco、Zookeeper、Redis、Spring Web MVC、Spring Boot和Docker等技术。它支持多协议、多组件和多序列化，为开发者提供了...
Zookeeper实现简单的分布式RPC框架
08-10
本文将深入探讨如何利用Zookeeper实现一个简单的分布式RPC（Remote Procedure Call）框架，同时也会涉及一些基础的源码分析和实用工具的使用。 首先，我们要理解Zookeeper的角色。Zookeeper是由Apache开发的一个...
BootNettyRpc是一个采用Netty实现的Rpc框架适用于SpringBoot项目支持SpringCloud
08-07
BootNettyRpc是一个专为Spring Boot项目设计的RPC（Remote Procedure Call）框架，它利用了高性能的Netty网络库来实现高效、低延迟的远程调用。Netty是一款基于NIO（非阻塞I/O）的异步事件驱动的网络通信框架，常...
NettyRPC-master
08-02
NettyRPC可能实现了负载均衡策略，如轮询、随机、权重分配等，以确保请求均匀分布到各个服务实例。 6. **异常处理和重试机制**: 网络通信中难免会出现异常，如网络抖动、超时等。NettyRPC应包含错误处理和重试策略...
使用netty自定义rpc通信框架
08-23
利用netty4.0定义的rpc通信框架
Netty实现rpc
12-10
使用netty作为底层的通讯工具实现了一个简单的rpc工具。
Java Netty 分布式开发 框架
09-24
做Java开发，现在很多场合需要分布式应用，很多通信框架的底层实现都包含Netty技术，为了更好了解，值得有兴趣的人研究一下
Netty RPC实现
hn_lzh2014的博客
04-07 123
【代码】Netty RPC实现。
代构建高可用分布式系统的利器——Netty
weixin_30558305的博客
06-17 98
特性： 高性能，事件驱动，异步非阻塞 Java 开源框架 基于 NIO 的客户端，服务端编程框架 稳定性和伸缩性 常用于建立 TCP/IP 底层的连接，能够建立高性能的 Http 服务器。 正因为高性能、异步非阻塞等特性，很多高性能项目将其作为底层的通信基础，比如阿里的 Dubbo。 活跃的主要领域： 高性能领域 多线程并发领域 异步通信领域 IO通信 关于这块，以前看到有篇写的非常好的文...
简单RPC实现之Netty实现
热门推荐
井底之蛙
10-31 1万+
所谓RPC就是远程方法调用(Remote Process Call ),简单的来说就是通过MQ,TCP,HTTP或者自己写的网络协议来传输我要调用对方的什么接口,对方处理之后再把结果返回给我.就这么简单的一个过程。运行时,一次客户机对服务器的RPC调用,其内部操作大致有如下十步：1、调用客户端句柄；执行传送参数2、调用本地系统内核发送网络消息3、消息传送到远程主机4、服务器句柄得到消息并取得参数
SpringBoot分布式Netty集群，通过Redis发布/订阅广播
qq_38038507的博客
09-01 2566
之前做用springboot+websocket做双向通讯时，websocket的存在session无法序列化导致集群不能通过共享session来实现，后来采取了记录需要推送客户端ip,然后用http去请求web接口这个不友好的方式。当然需求只需要做扫码登录，这种方式影响也不会有什么影响。但集群问题一直没解决就在心里埋下了个种子。
手把手教你基于Netty实现一个基础的RPC框架（通俗易懂）
跟着Mic学架构
11-17 1382
阅读这篇文章之前，建议先阅读和这篇文章关联的内容。 [1]详细剖析分布式微服务架构下网络通信的底层实现原理（图解） [2][年薪60W的技巧]工作了5年，你真的理解Netty以及为什么要用吗？（深度干货） [3]深度解析Netty中的核心组件（图解+实例） [4]BAT面试必问细节：关于Netty中的ByteBuf详解 [5]通过大量实战案例分解Netty中是如何解决拆包黏包问题的? [6]基于Netty实现自定义消息通信协议（协议设计及解析应用实战） [7]全网最详细最齐全的序列化技术及深度解析与应..
由浅入深Netty简易实现RPC框架
赵广陆
05-21 576
目录 1 准备工作 2 服务器 handler 3 客户端代码第一版 4 客户端 handler 第一版 5 客户端代码 第二版 6 客户端 handler 第二版 1 准备工作 这些代码可以认为是现成的，无需从头编写练习 为了简化起见，在原来聊天项目的基础上新增 Rpc 请求和响应消息

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值