Netty——四

最新推荐文章于 2024-10-08 15:07:49 发布
最新推荐文章于 2024-10-08 15:07:49 发布
阅读量56 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57836635/article/details/130292299
版权
文章介绍了RPC的基本概念，包括其作为远程过程调用的作用以及常见的RPC框架。接着详细描述了RPC的调用流程，从服务消费方发起请求到服务提供方处理并返回结果。文章的重点在于，通过Netty构建了一个简单的RPC框架，模拟了Dubbo的RPC调用，包括定义公共接口、实现服务提供者、消费者以及利用Netty进行网络通信的各个步骤。
摘要由CSDN通过智能技术生成

十一、用Netty自己实现dubbo RPC

1、RPC基本介绍

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

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

    image-20230301221855994

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

    image-20230301221927036

2、RPC调用流程

RPC调用流程图

image-20230301221955196

术语说明：在RPC 中， Client 叫服务消费者，Server 叫服 务提供者

PRC调用流程说明

  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 这些步骤都封装起来，用户无需关心这些细节，可以像调 用本地方法一样即可完成远程服务调用。

3、自己实现 dubbo RPC(基于Netty)

需求说明

  1. dubbo 底层使用了 Netty 作为网络通讯框架，要求用 Netty 实现一个简单的 RPC 框 架

  2. 模仿 dubbo，消费者和提供者约定接口和协议，消费者远程调用提供者的服务，提供 者返回一个字符串，消费者打印提供者返回的数据。底层网络通信使用 Netty 4.1.20

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

dubbo RPC 思路分析图：

image-20230305224019821

代码实现

公共接口：

package com.lxg.netty.dubborpc.publicinterface;


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

    String hello(String mes);

}

实现类：

package com.lxg.netty.dubborpc.provider;

import com.lxg.netty.dubborpc.publicinterface.HelloService;

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 "你好客户端，我已经收到你的消息";
        }
    }
}

服务器端：

package com.lxg.netty.dubborpc.netty;


import io.netty.bootstrap.ServerBootstrap;
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.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

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 bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            //给pipeline设置处理器
                            pipeline.addLast(new StringDecoder()); //解码器
                            pipeline.addLast(new StringEncoder()); //编码器
                            pipeline.addLast(new NettyServerHandler()); //自定义的处理器
                        }
                    });
            ChannelFuture channelFuture = bootstrap.bind(hostname, port).sync();
            System.out.println("服务提供方开始提供服务~~");
            channelFuture.channel().closeFuture().sync();

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

    }
}

服务器端handler：

package com.lxg.netty.dubborpc.netty;

import com.lxg.netty.dubborpc.customer.ClientBootstrap;
import com.lxg.netty.dubborpc.provider.HelloServiceImpl;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

//服务器这边的handler比较简单
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
    //读取数据实际(这里我们可以读取客户端发送的消息)
    /*
    1. ChannelHandlerContext ctx:上下文对象, 含有 管道pipeline , 通道channel, 地址
    2. Object msg: 就是客户端发送的数据 默认Object
    */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取客户端发送的消息，并调用服务
        System.out.println("msg=" + msg);
        //客户端在调用服务器的api时，我们需要定义一个协议
        //比如我们要求每次发消息都必须以某个字符串开头 "我来啦#你好呀#"
        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();
    }
}

服务器端启动器：

package com.lxg.netty.dubborpc.provider;

import com.lxg.netty.dubborpc.netty.NettyServer;

//ServerBootstrap 启动一个服务提供者，就是NettyServer
public class ServerBootstrap {


    public static void main(String[] args) {
        //创建一个服务提供者，发布服务
        NettyServer.startServer("127.0.0.1",7005);
    }
}

客户端：

package com.lxg.netty.dubborpc.netty;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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<?> serviceClass, final String providerName){
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class<?>[]{serviceClass}, (proxy, method, args) -> {
                    System.out.println("(proxy, method, args) 进入....." + (++count) + " 次");
                    //客户端在调用服务器api 时，我们会去调用 invoke 方法
                    if(client == null){
                        initClient();
                    }
                    //设置要发给服务器端的信息
                    //providerName 协议头 args[0]就是客户端调用api hello(??)时传入的参数
                    client.setPara(providerName + args[0]);

                    //返回值
                    return executor.submit(client).get();
                });
    }

    //初始化客户端
    private static void initClient() throws Exception {
        client = new NettyClientHandler();
        //创建EventLoopGroup
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            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); //加入自己的处理器
                        }
                    });
            bootstrap.connect("127.0.0.1", 7005).sync();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

客户端handler：

package com.lxg.netty.dubborpc.netty;

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

import java.util.concurrent.Callable;

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

    }

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

    //发生异常后，关闭通道(5)
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }

    //被代理对象调用，发送数据给服务器，-> wait -> 等待被唤醒(channelRead) -> 返回结果(3)
    @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;
    }

}

客户端启动器：

package com.lxg.netty.dubborpc.customer;

import com.lxg.netty.dubborpc.netty.NettyClient;
import com.lxg.netty.dubborpc.publicinterface.HelloService;

public class ClientBootstrap {

    //这里定义协议头
    public static final String providerName = "我来啦#你好呀#";

    public static void main(String[] args) throws InterruptedException {
        //创建一个消费者
        NettyClient customer = new NettyClient();

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

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

    }
}
不想写不喜欢的代码
关注
Netty——源码解析
weixin_43415481的博客
05-13 1470
JAVA后端开发知识总结（持续更新…） Netty—— 文章目录Netty——零、前言一、Netty服务器启动源码 零、前言 在 io.netty.example 包下，有很多 Netty 源码案例，可以用来分析。 一、Netty服务器启动源码 源码需要剖析到 Netty 中调用 doBind 方法，追踪到 NioServerSocketChannel 的 doBind。 同时要 Debug 程序到 NioEventLoop 类的 run 方法，无限循环，在服务器端运行。 ...
Netty——简单Dubbo实现
weixin_43415481的博客
05-15 375
JAVA后端开发知识总结（持续更新…） Netty—— 文章目录Netty——一、RPC 一、RPC RPC（Remote Procedure Call）：远程过程调用，是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。 两个或多个应用程序分布在不同的服务器上，但它们之间的调用都像是在本地方法调用一样。 RPC调用流程： RPC 的目标是将 2 - 8 步都封装起来： 服务消费方（client）以本地调用方式调用服务.
【Netty】一、高性能NIO通信框架Netty-快速入门
weixin_43333483的博客
10-22 1185
一、高性能NIO通信框架Netty-快速入门，组件介绍，样例工程
Netty——基本使用介绍
2401_84048149的博客
05-13 735
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
初识Netty——Netty的特性
m0_60649266的博客
05-25 617
对于NIO,的SocketChannel，在非阻塞模式下，它会直接返回连接结果，如果没有连
接成功，也没有发生IO异常，则需要将SocketChannel 注册到 Selector上监听连接结果。如果已经连接超时，但
是服务端仍然没有返回 TCP握手应答，则关闭连接，如果在超时期限内处理完成连接操作，则取消连接超时定时任务。用于客户端的登录、握手和安全认证，一旦链路建立成功，就将链路注册到后端 subReactor线程池的I/O线程上，由I/O线程负责后续的I/O操作。用于接收客户端请求的线程池职责如下。
Netty——自定义处理器
保暖透气大裤衩LeoLee的博客
02-22 524
概述 根据消息的流向，处理器可以分为入站处理器和出站处理器，也存在既是出站处理器又是入站处理器的情况，但是不建议这么做。 出站处理器 顶层为ChannelInboundHandler 入站处理器 顶层为ChannelOutboundHandler 在处理消息数据时的各种编解码器，本质上都是处理器：无论我们向网络中写入的数据是什么类型（int、char、String、二进制等），其都是以字节流的形式进行的。所以，数据由原本的形式转换为字节流的操作称为编码（encode），将数据由字节流转换为
初识Netty——I/O技术简介
m0_60649266的博客
05-25 956
步骤四：判断是否连接成功，如果连接成功，则直接注册读状态位到多路复用器中，
如果当前没有连接成功（异步连接，返回 false，说明客户端已经发送 sync 包，服务端没
有返回 ack 包，物理链路还没有建立)步骤十二:对 ByteBuffer 进行编解码，如果有半包消息接收缓冲区 Reset，继续读取
后续的报文，将解码成功的消息封装成 Task，投递到业务线程池中，进行业务逻辑编排。步骤六:多路复用器监听到有新的客户端接入，处理新的接入请求，完成 TCP 三次
握手，建立物理链路，示例代码如下。
Netty——入门
weixin_44623055的博客
04-22 2080
1、概述 1.1、Netty是什么 Netty是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端。 1.2、Netty的地位 Netty在Java网络应用框架中的地位就好比Spring框架在JavaEE开发中的地位。以下的框架都使用了Netty，因为它们有网络通信要求： Cassandra - nosql数据库 Spark - 大数据分布式计算框架 Hadoop - 大数据分布式存储框架 RocketMQ - ali开源的消息队列 ElasticSea
Netty——ChannelHandlerContext
吴声子夜歌的博客
06-15 5489
ChannelHandlerContext接口 ChannelHandlerContext 代表了 ChannelHandler 和 ChannelPipeline 之间的关 联，每当有 ChannelHandler 添加到 ChannelPipeline 中时，都会创建 ChannelHandler- Context。ChannelHandlerContext 的主要功能是管理它所关联的 ChannelHandler 和在 同一个 ChannelPipeline 中的其他 ChannelHandler 之
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 915
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 342
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 699
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1013
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 511
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
优先级队列详解
最新发布
2301_79083481的博客
10-08 744
讲解了优先级队列的使用和模拟实现
Java内存布局
阿呆的专栏
10-01 836
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java中的break、continue和return语句
weixin_73230994的博客
10-05 367
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty入门教程：简单易用的高性能NIO框架
"Netty——基本使用介绍" Netty是一个高性能、异步事件驱动的网络应用程序框架，主要用于快速开发可维护的高性能协议服务器和客户端。它极大地简化了网络编程，包括TCP和UDP套接字服务器的各种复杂特性。Netty的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值