Netty核心技术（三）

已于 2023-09-04 20:47:11 修改
阅读量72 收藏
点赞数
分类专栏： Netty 文章标签： qt 开发语言
于 2023-09-04 20:34:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63634909/article/details/132575840
版权

文章目录

一、Google Protobu

1.1 编码和解码的基本介绍

  1. 编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据时就需要解码
  2. codec(编解码器) 的组成部分有两个：decoder(解码器)和 encoder(编码器)。encoder 负责把业务数据转换成字节码数据，decoder 负责把字节码数据转换成业务数据
    在这里插入图片描述

1.2 Netty 本身的编码解码的机制和问题分析

  1. Netty 自身提供了一些 codec(编解码器)
  2. Netty 提供的编码器
    StringEncoder，对字符串数据进行编码
    ObjectEncoder，对 Java 对象进行编码
    …
  3. Netty 本身自带的 ObjectDecoder 和 ObjectEncoder 可以用来实现 POJO 对象或各种业务对象的编码和解码，底层使用的仍是 Java 序列化技术 , 而 Java 序列化技术本身效率就不高，存在如下问题：
    无法跨语言
    序列化后的体积太大，是二进制编码的 5 倍多。
    序列化性能太低
    解决方案：Google 的 Protobu

1.3 Protobuf

  1. Protobuf 基本介绍和使用示意图
    在这里插入图片描述
  2. Protobuf 是 Google 发布的开源项目，全称 Google Protocol Buffers，是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC[远程过程调用 remote procedure call ] 数据交换格式 。
  3. Protobuf 是以 message 的方式来管理数据的
  1. 使用 protobuf 编译器能自动生成代码，Protobuf 是将类的定义使用.proto 文件进行描述。说明，在 idea 中编写 .proto 文件时，会自动提示是否下载 .ptotot 编写插件. 可以让语法高亮。
  2. 然后通过 protoc.exe 编译器根据.proto 自动生成.java 文件

1.4 Protobuf 快速入门案例1

编写程序，使用 Protobuf 完成如下功能

  1. 客户端可以发送一个 Student PoJo 对象到服务器 (通过 Protobuf 编码)
  2. 服务端能接收 Student PoJo 对象，并显示信息(通过 Protobuf 解码)

创建一个Student.proto文件，文件内容如下

syntax = "proto3"; //版本
option java_outer_classname = "StudentPOJO";//生成的外部类名，同时也是文件名
//protobuf 使用 message 管理数据
message Student { //会在 StudentPOJO 外部类生成一个内部类 Student， 他是真正发送的 POJO 对象
	int32 id = 1; // Student 类中有 一个属性 名字为 id 类型为 int32(protobuf 类型) 1 表示属性序号，不是值
	string name = 2;
}

下载protoc.exe文件，将Student.proto复制到protoc.exe一个目录下，然后在这个目录下打开cmd输入protoc.exe --java_out=. Student.proto，这样就会生成StudentPOJO.java文件
还得引入protobuf的依赖

 <dependency>
       <groupId>com.google.protobuf</groupId>
       <artifactId>protobuf-java</artifactId>
       <version>3.6.1</version>
 </dependency>

客户端代码没什么变化
客户端自定义处理器变化的地方
**加粗样式**
服务端代码
在这里插入图片描述
服务端自定义处理器
在这里插入图片描述

1.5 Protobuf 快速入门实例2

  1. 编写程序，使用 Protobuf 完成如下功能
  2. 客户端可以随机发送 Student PoJo/ Worker PoJo 对象到服务器 (通过 Protobuf 编码)
  3. 服务端能接收 Student PoJo/ Worker PoJo 对象(需要判断是哪种类型)，并显示信息(通过 Protobuf 解码)

proto文件代码内容

syntax="proto3"; //版本
option optimize_for = SPEED; // 加快解析
option java_package="com.miao.netty.proto"; //指定生成到哪个包下
option java_outer_classname="MyDataInfo"; // 外部类名, 文件名

//protobuf 可以使用 message 管理其他的 message
message MyMessage {
  //定义一个枚举类型
  enum DataType {
    StudentType = 0; //在 proto3 要求 enum 的编号从 0 开始
    WorkerType = 1;
  }
  //用 data_type 来标识传的是哪一个枚举类型
  DataType data_type = 1;
  //表示每次枚举类型最多只能出现其中的一个, 节省空间
  oneof dataBody {
    Student student = 2;
    Worker worker = 3;
  }
}

message Student {
  int32 id = 1;//Student 类的属性
  string name = 2; //
}
message Worker {
  string name=1;
  int32 age=2;
}

客户端
在这里插入图片描述
客户端自定义处理器
在这里插入图片描述
服务端
在这里插入图片描述
服务端自定义处理器
在这里插入图片描述

二、Netty 编解码器和 handler 的调用机制

2.1 基本说明

  1. netty的组件设计：Netty的主要组件有Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe等
  2. ChannelHandler充当了处理入栈和出栈数据的应用程序逻辑的容器。例如：实现ChannelInboundHandler接口或ChannelInboundHandlerAdapter，你就可以接收入栈事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时，也可以从CHannelInboundHandler冲刷数据。业务逻辑通常卸载一个或者多个ChannelInboundHandler中。ChannelOutboundHandler原理一样，只不过它是用来处理出栈数据的
  3. CHannelPipeline提供了ChannelHandler链的容器，以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出栈的，即客户端发送服务端的数据会通过pipeline中的一系列ChannelOutboundHandler，并被这些Handler处理，反之则称为入栈的
    在这里插入图片描述

2.2 编码解码器

  1. 当 Netty 发送或者接受一个消息的时候，就将会发生一次数据转换。入站消息会被解码：从字节转换为另一种格式（比如 java 对象）；如果是出站消息，它会被编码成字节。
  2. Netty 提供一系列实用的编解码器，他们都实现了 ChannelInboundHadnler 或者 ChannelOutboundHandler 接口。在这些类中，channelRead 方法已经被重写了。以入站为例，对于每个从入站 Channel 读取的消息，这个方法会被调用。随后，它将调用由解码器所提供的 decode()方法进行解码，并将已经解码的字节转发给 ChannelPipeline中的下一个 ChannelInboundHandler。

2.3 解码器-ByteToMessageDecoder

  1. 关系继承图
    在这里插入图片描述

  2. 由于不可能知道远程节点是否会一次性发送一个完整的信息，tcp 有可能出现粘包拆包的问题，这个类会对入站数据进行缓冲，直到它准备好被处理.

  3. 一个关于 ByteToMessageDecoder 实例分析
    在这里插入图片描述
    在这里插入图片描述

不论解码器 handler 还是 编码器 handler 即接收的消息类型必须与待处理的消息类型一致，否则该 handler 不会被执行
在解码器 进行数据解码时，需要判断 缓存区(ByteBuf)的数据是否足够 ，否则接收到的结果会期望结果可能不一致

2.4 解码器-ReplayingDecoder

  1. public abstract class ReplayingDecoder extends ByteToMessageDecoder
  2. ReplayingDecoder 扩展了 ByteToMessageDecoder 类，使用这个类，我们不必调用 readableBytes()方法。参数 S指定了用户状态管理的类型，其中 Void 代表不需要状态管理
  3. 应用实例：使用 ReplayingDecoder 编写解码器
public class MyByteToLongDecoder2 extends ReplayingDecoder<Void> {
	@Override
	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
		System.out.println("MyByteToLongDecoder2 被调用");
		//在 ReplayingDecoder 不需要判断数据是否足够读取，内部会进行处理判断
		out.add(in.readLong());
	}
}
  1. ReplayingDecoder 使用方便，但它也有一些局限性：
    • 并 不 是 所 有 的 ByteBuf 操 作 都 被 支 持 ， 如 果 调 用 了 一 个 不 被 支 持 的 方 法 ， 将 会 抛 出 一 个UnsupportedOperationException。
    • ReplayingDecoder 在某些情况下可能稍慢于 ByteToMessageDecoder，例如网络缓慢并且消息格式复杂时，消息会被拆成了多个碎片，速度变慢

2.5 其它编解码器

  1. LineBasedFrameDecoder：这个类在 Netty 内部也有使用，它使用行尾控制字符（\n 或者\r\n）作为分隔符来解析数据。
  2. DelimiterBasedFrameDecoder：使用自定义的特殊字符作为消息的分隔符。
  3. HttpObjectDecoder：一个 HTTP 数据的解码器
  4. LengthFieldBasedFrameDecoder：通过指定长度来标识整包消息，这样就可以自动的处理黏包和半包消息。

2.6 Log4j 整合到 Netty

  1. 在 Maven 中添加对 Log4j 的依赖 在 pom.xml
<dependency>
	<groupId>log4j</groupId>
	<artifactId>log4j</artifactId>
	<version>1.2.17</version>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-api</artifactId>
	<version>1.7.25</version>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-log4j12</artifactId>
	<version>1.7.25</version>
	<scope>test</scope>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-simple</artifactId>
	<version>1.7.25</version>
	<scope>test</scope>
</dependency>
  1. 配置 Log4j , 在 resources/log4j.properties
log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%p] %C{1} - %m%n

三、TCP 粘包和拆包 及解决方案

3.1 TCP 粘包和拆包基本介绍

  1. TCP是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一承兑的socket，因此，发送端为了将多个发给接收端的包，更有效的发给对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样做虽然提高了效率，但是接收端就难于分辨出完成的数据报了，因为面向流的通信是无消息保护边界的
  2. 由于TCP无消息保护边界，需要在接收端处理消息边界问题，也就是我们所说的粘包和拆包问题
  3. TCP粘包和拆包图解
    在这里插入图片描述
    假设客户端分别发送了两个数据包 D1 和 D2 给服务端，由于服务端一次读取到字节数是不确定的，故可能存在以下四种情况：
  1. 服务端分两次读取到了两个独立的数据包，分别是 D1 和 D2，没有粘包和拆包
  2. 服务端一次接受到了两个数据包，D1 和 D2 粘合在一起，称之为 TCP 粘包
  3. 服务端分两次读取到了数据包，第一次读取到了完整的 D1 包和 D2 包的部分内容，第二次读取到了 D2 包的剩余内容，这称之为 TCP 拆包
  4. 服务端分两次读取到了数据包，第一次读取到了 D1 包的部分内容 D1_1，第二次读取到了 D1 包的剩余部分内容 D1_2

3.2 TCP 粘包和拆包现象实例

客户端和服务端的代码就用之前TCP的代码
客户端自定义处理器

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;

public class MyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private int count;
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //使用客户端发送10条数据 hello,server 编号
        for(int i= 0; i< 10; ++i) {
            ByteBuf buffer = Unpooled.copiedBuffer("hello,server " + i, Charset.forName("utf-8"));
            ctx.writeAndFlush(buffer);
        }
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        String message = new String(buffer, Charset.forName("utf-8"));
        System.out.println("客户端接收到消息=" + message);
        System.out.println("客户端接收消息数量=" + (++this.count));

    }

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

服务器端自定义处理器

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;
import java.util.UUID;

public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf>{
    private int count;

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

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {

        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        //将buffer转成字符串
        String message = new String(buffer, Charset.forName("utf-8"));

        System.out.println("服务器接收到数据 " + message);
        System.out.println("服务器接收到消息量=" + (++this.count));

        //服务器回送数据给客户端, 回送一个随机id ,
        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString() + " ", Charset.forName("utf-8"));
        ctx.writeAndFlush(responseByteBuf);

    }
}

在这里插入图片描述

3.3 TCP 粘包和拆包解决方案

  1. 使用自定义协议 + 编解码器 来解决
  2. 关键就是要解决 服务器端每次读取数据长度的问题, 这个问题解决，就不会出现服务器多读或少读数据的问题，从而避免的 TCP 粘包、拆包

看一个具体的实例

  1. 要求客户端发送 5 个 Message 对象, 客户端每次发送一个 Message 对象
  2. 服务器端每次接收一个 Message, 分 5 次进行解码， 每读取到 一个 Message , 会回复一个 Message 对象 给客户端，发一个收一个

MessageProtocol

package com.miao.netty.protocoltcp;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 16:52
 */

//协议包
public class MessageProtocol {
    private int len;
    private byte[] content;

    public int getLen() {
        return len;
    }

    public void setLen(int len) {
        this.len = len;
    }

    public byte[] getContent() {
        return content;
    }

    public void setContent(byte[] content) {
        this.content = content;
    }
}

MyClientHandler

package com.miao.netty.protocoltcp;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 16:54
 */
//传递的数据是一个协议包
public class MyClientHandler extends SimpleChannelInboundHandler<MessageProtocol> {

    private int count;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //客户端一启动就向服务端发送10条数据
        for(int i = 0;i < 10;i++){
            String mes = "你好，世界";
            //得到信息的字节数组和长度
            byte[] content = mes.getBytes(Charset.forName("utf-8"));
            int length = content.length;

            //创建协议包对象
            MessageProtocol messageProtocol = new MessageProtocol();
            messageProtocol.setContent(content);
            messageProtocol.setLen(length);
            ctx.writeAndFlush(messageProtocol);
        }
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol messageProtocol) throws Exception {
        int len = messageProtocol.getLen();
        byte[] content = messageProtocol.getContent();
        System.out.println("客户端接收信息如下");
        System.out.println("内容：" + new String(content, Charset.forName("utf-8")));
        System.out.println("客户端接收信息数量：" + (++this.count));
    }

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

MyClient

package com.miao.netty.protocoltcp;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:09
 */
public class MyClient {
    public static void main(String[] args) {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try{
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new MyClientInitializer());

            ChannelFuture channelFuture = bootstrap.connect("localhost", 7000).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally{
            group.shutdownGracefully();
        }
    }
}

MyClientInitializer

package com.miao.netty.protocoltcp;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:01
 */
public class MyClientInitializer extends ChannelInitializer<SocketChannel> {
        @Override
        protected void initChannel(SocketChannel ch) throws Exception {

            ChannelPipeline pipeline = ch.pipeline();
            pipeline.addLast(new MyMessageEncoder()); //加入编码器
            pipeline.addLast(new MyMessageDecoder()); //加入解码器
            pipeline.addLast(new MyClientHandler());
        }
}

MyMessageDecoder

package com.miao.netty.protocoltcp;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ReplayingDecoder;

import java.util.List;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:02
 */
public class MyMessageDecoder extends ReplayingDecoder<Void> {


    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> out) throws Exception {
        System.out.println("MyMessageDecoder被调用");
        int length = byteBuf.readInt();
        //得到二进制字节数组
        byte[] content = new byte[length];
        byteBuf.readBytes(content);
        //封装成MessageProtocol对象，放入out，传递给下一个handler业务处理
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLen(length);
        messageProtocol.setContent(content);
        out.add(messageProtocol);
    }
}

MyMessageEncoder

package com.miao.netty.protocoltcp;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:07
 */
public class MyMessageEncoder extends MessageToByteEncoder<MessageProtocol> {
    @Override
    protected void encode(ChannelHandlerContext ctx, MessageProtocol msg, ByteBuf out) throws Exception {
        System.out.println("MyMessageEncoder encode 方法被调用");
        out.writeInt(msg.getLen());
        //将消息包转换成缓存中的字节  --> 解码
        out.writeBytes(msg.getContent());
    }
}

MyServer

package com.miao.netty.protocoltcp;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

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

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

        try {

            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new MyServerInitializer()); //自定义一个初始化类


            ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();
            channelFuture.channel().closeFuture().sync();

        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

MyServerHandler

package com.miao.netty.protocoltcp;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;
import java.util.UUID;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:12
 */
public class MyServerHandler extends SimpleChannelInboundHandler<MessageProtocol> {
    private int count;

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

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol messageProtocol) throws Exception {
        int len = messageProtocol.getLen();
        byte[] content = messageProtocol.getContent();
        System.out.println();
        System.out.println();
        System.out.println("服务器收到信息如下");
        System.out.println("内容：" + new String(content, Charset.forName("utf-8")));
        System.out.println("服务器接收到信息包数量：" + (++this.count));

        //回复信息
        String responseContentMsg = UUID.randomUUID().toString();
        byte[] responseContent = responseContentMsg.getBytes("utf-8");
        int length = responseContent.length;
        //构建一个协议包
        MessageProtocol messageProtocol1 = new MessageProtocol();
        messageProtocol1.setLen(length);
        messageProtocol1.setContent(responseContent);
        ctx.writeAndFlush(messageProtocol1);

    }
}

MyServerInitializer

package com.miao.netty.protocoltcp;


import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;


public class MyServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        pipeline.addLast(new MyMessageDecoder());//解码器
        pipeline.addLast(new MyMessageEncoder());//编码器
        pipeline.addLast(new MyServerHandler());
    }
}

结果
在这里插入图片描述

四、用Netty实现dubbo RPC

4.1 RPC基本介绍

  1. RPC（Remote Procedure Call）：远程过程调用，是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。（我可以用别人写好的东西，自己就不用去写了）
  2. 两个或多个应用程序都分布在不同的服务器上，它们之间的调用都像是本地方法调用一样(如图)
    在这里插入图片描述
    3） 常见的 RPC 框架有: 比较知名的如阿里的Dubbo、google的gRPC、Go语言的rpcx、Apache的thrift，Spring旗下的 Spring Cloud
  3. 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这些步骤都封装起来，用户无需关心这些细节，可以像调用本地方法一样即可完成远程服务调用

4.2 用Netty自己实现dubbo RPC

需求说明

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

设计说明

  1. 创建一个接口，定义抽象方法。用于消费者和提供者之间的约定。
  2. 创建一个提供者，该类需要监听消费者的请求，并按照约定返回数据。
  3. 创建一个消费者，该类需要透明的调用自己不存在的方法，内部需要使用 Netty 请求提供者返回数据
  4. 开发的分析图
    在这里插入图片描述
    跟之前的相比只是多了个接口HelloService，然后有个接口实现类HelloServiceImpl，然后就是消费方Client得到代理对象HelloServiceImpl，再去调用HelloService的方法
    HelloService
package com.miao.netty.rpc;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:53
 */
//服务提供方和 服务消费方都需要的接口
public interface HelloService {
    String hello(String mes);
}

HelloServiceImpl

package com.miao.netty.rpc;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:57
 */
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 "你好客户端，我已经收到你的消息";
        }
    }
}

NettyClientHandler

package com.miao.netty.rpc;

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(); //唤醒等待的线程  继续执行call方法
    }

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

NettyClient

package com.miao.netty.rpc;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
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.Proxy;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 18:12
 */
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) {
                        initClient();
                    }

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

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

                });
    }

    //初始化客户端
    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();
        }
    }
}

ClientBootstrap

package com.miao.netty.rpc;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 17:51
 */
public class ClientBootstrap {
    //定义协议头
    public static final String providerName = "HelloService#hello#";

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

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

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

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

NettyServerHandler

package com.miao.netty.rpc;

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

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

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取客户端发送的消息，并调用服务
        System.out.println("msg=" + msg + "haha");
        //客户端在调用服务器的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();
    }
}

NettyServer

package com.miao.netty.rpc;


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

    }
}

ServerBootstrap

package com.miao.netty.rpc;

/**
 * @author miaoyuhuai
 * @creat 2023-09-04 20:08
 */
public class ServerBootstrap {
    public static void main(String[] args) {
        NettyServer.startServer("127.0.0.1", 7000);
    }
}

结果
在这里插入图片描述

myh930
关注
专栏目录
Netty核心技术及源码剖析.pptx
08-15
Netty核心技术及源码剖析
尚硅谷Netty核心技术及源码剖析1
08-03
《尚硅谷Netty核心技术及源码剖析1》 在当今的软件开发中，Netty作为一个高性能、异步事件驱动的网络应用框架，被广泛应用于多种领域。本章将对Netty进行详细介绍，并探讨其在实际场景中的应用。 1.1 本课程学习...
Netty 核心技术介绍
Jarvis's Blog
04-16 634
原生NIO 存在的问题 1). NIO 的库类和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等 2). 需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，你需要对多线程和网络编程非常熟悉，才能编写出高质量 NIO 程序 3). 开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等 4). JDK NI
Netty核心技术
weixin_38074756的博客
10-01 552
Netty核心技术 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录Netty核心技术前言一、Netty介绍和应用场景1.介绍2. Netty的应用场景二、JAVA的BIO1.介绍2.应用实例1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学
Netty核心技术六--Netty核心模块组件
qq_31745863的博客
06-17 764
Bootstrap 意思是引导，一个 Netty 应用通常由一个Bootstrap 开始，**主要作用是配置整个 Netty 程序，串联各个组件**，Netty 中 **Bootstrap 类是客户端程序的启动引导类**，**ServerBootstrap 是服务端启动引导类**
Netty核心技术十--Netty 核心源码剖析
qq_31745863的博客
07-11 1091
每当ServerSocket创建一个新的连接，就会创建一个Socket，对应的就是目标客户端。每一个新创建的Socket 都将会分配一个全新的 ChanneIPipeline(以下简称 pipeline)每一个ChannelPipeline内部都含有多个ChannelHandlerContext(以下简称 Context)他们一起组成了双向链表，这些Context 用于包装我们调用addLast 方法时添加的ChannelHandler (以下简称handler)关系图。
Netty核心技术NIO介绍
散步的博客
05-27 1577
Netty的介绍： Netty 是由 JBOSS 提供的一个 Java 开源框架，现为 Github上的独立项目。 Netty 是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可 靠性的网络 IO 程序。 Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下 的大量数据持续传输的应用。 Netty本质是一个NIO框架，适用于服务器通讯相关的多种应用场景 要透彻理解Netty ， 需要先学习 NIO ， 这样我们才能阅读 Netty 的源码。
Netty核心技术五--Netty高性能架构设计
qq_31745863的博客
06-04 855
1. 基于 I/O 复用模型：**多个连接共用一个阻塞对象**，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有连接。当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理Reactor 对应的叫法: 1. `反应器模式` 2. `分发者模式(Dispatcher)` 3. `通知者模式(notifier)` 2. 基于线程池复用线程资源：不必再为每个连接创建线程，**将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。**
Netty核心及源码分析
hzz19943305823的博客
09-04 641
1）Java BIO 就是传统的java io 编程，其相关的类和接口在java.io2) BIO 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户端连接服务器）3）BIO方式用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，程序简单易理解。
深入剖析 Netty 核心原理
2401_84664550的博客
08-20 836
Netty 是一个基于 Java NIO 技术的网络应用框架，它提供了一套简洁而强大的 API，用于构建高性能、可扩展的网络应用程序。Netty 具有异步非阻塞、事件驱动、高度可定制等特点，能够轻松应对高并发、大流量的网络通信场景。
六、Netty核心技术之TaskQueue自定义任务
猿小许的博客
11-04 653
一、Netty模型 Netty主要基于主从Reactor多线程模型（如图）做了一定的改进，其中主从Reactor多线程模型有多个Reactor 上图解析???? 1、Netty抽象出两组线程池BossGroup专门负责接收客户端的连接，WorkGroup专门负责网络的读写 2、BossGroup和WorkGroup类型都是NioEventLoopGroup 3、NioEventLoopGroup相当于一个事件循环组，这个组合含有多个事件循环，每一个事件循环是NioEventLoop 4、NioEvent
尚硅谷Netty核心技术及源码剖析PPT1
08-03
【Netty介绍与核心概念】 Netty是由JBoss提供，现为GitHub上的独立项目，它是一个专注于高性能、高可靠性的Java网络应用框架。Netty基于事件驱动和异步非阻塞I/O模型，使得它在处理高并发网络通信时表现出色。Netty...
Netty笔记源码资料.rar
05-13
1.Netty 是由 JBOSS 提供的一个 Java 开源框架，现为 Github 上的独立项目。 2.Netty 是一个 异步的、 基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络 IO 程序。
qt QFontDialog详解
ckg3824278的博客
11-05 321
QFontDialog 是 Qt 框架中的一个对话框类，用于选择字体。它提供了一个可视化的界面，允许用户选择所需的字体以及相关的属性，如字体样式、大小、粗细等。用户可以通过对话框中的选项进行选择，并实时预览所选字体的效果。QFontDialog 继承自 QDialog，是创建字体选择对话框的标准方式。
qt QEvent详解
ckg3824278的博客
11-04 467
QEvent是Qt框架中事件机制的基础类。在Qt中，事件是由底层窗口系统（如Windows、Linux的X11、macOS的Cocoa等）生成的，Qt的主事件循环（QCoreApplication::exec()）负责从事件队列中获取这些事件，并将它们转换为QEvent对象，然后发送给相应的QObject对象进行处理。QEvent类是所有事件类的基类，它包含了事件的基本信息，如事件类型、是否已被接受等。Qt通过QEvent类及其子类来实现各种事件的处理，如鼠标事件、键盘事件、定时器事件等。
qt QFile详解
ckg3824278的博客
11-05 371
QFile类是Qt框架中用于读取和写入文本和二进制文件资源的I/O工具类。它继承自QFileDevice类，后者又继承自QIODevice类。QFile类提供了一个接口，允许开发者以二进制模式或文本模式对文件进行读写操作。默认情况下，QFile假定文件内容为二进制，即不对文件中的字节执行任何转换。QFile类既可以单独使用，也可以与QTextStream或QDataStream类结合使用，以提高文件读写的效率和便利性。
Qt菜单功能实现
最新发布
propor的专栏
11-07 222
Qt菜单功能
如何使用 QStyledItemDelegate 自定义 Qt 的视图项代理
填坑之路
11-05 432
在 Qt 中，QStyledItemDelegate 为开发者提供了一个灵活的方式来控制视图项的外观和编辑行为。本文将详细讲解如何通过继承 QStyledItemDelegate 来定制项的绘制、编辑控件以及交互行为，并通过实例展示如何在 QTableView 中应用这些自定义功能。
Qt中时间戳转化为时间
weixin_51883798的博客
11-06 341
GMT（格林威治标准时间，Greenwich Mean Time）是一个时间标准，它以通过英国伦敦格林威治的子午线上的平均太阳时作为参考。GMT是以前国际上广泛使用的时间标准，现在已被协调世界时（UTC，Coordinated Universal Time）所取代，但在日常交流中GMT仍然被广泛使用。在日期和时间表示法中，"T"是一个分隔符，用于将日期部分和时间部分明确区分开来。GMT最早由英国铁路使用，后来在1884年的国际经度会议上被采纳为国际时间标准。
深入解析Netty：核心技术与源码分析
"Netty核心技术及源码剖析" Netty是一个高度优化且广泛使用的网络应用程序框架，专注于提供高效、可靠的网络编程解决方案。它由JBoss提供，现在是GitHub上的独立项目，支持Java平台。Netty的核心特性是其异步、事件...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值