Netty 简单示例

逆流丶石头

已于 2023-03-22 16:28:47 修改

阅读量124

点赞数

文章标签： java spring mybatis

于 2023-03-15 13:11:09 首次发布

本文链接：https://blog.csdn.net/hn_lzh2014/article/details/129446117

版权

POM:

       <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.25.Final</version>
        </dependency>

NettyServer:

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

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        
        // 创建两个线程组 boosGroup 和 workerGroup
        // bossGroup 只处理连接请求， workerGroup 与客户端业务处理
        // 两者皆是无限循环
        EventLoopGroup boosGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 创建服务器端的启动对象，配置启动参数
            ServerBootstrap bootstrap = new ServerBootstrap();

            // 使用链式编程进行设置
            bootstrap.group(boosGroup, workerGroup) // 设置两个线程组
                    .channel(NioServerSocketChannel.class) // 使用NioServerSocketChannel 作为服务器通道实现
                    .option(ChannelOption.SO_BACKLOG, 128) // 设置线程队列等待连接的个数
                    .childOption(ChannelOption.SO_KEEPALIVE, true)  // 设置保持活动连接状态
                    .childHandler(new ChannelInitializer<SocketChannel>() { // 创建一个通道初始化对象（匿名对象）
                        // 给pipeline 设置处理器
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyServerHandler());
                        }
                    });     // 给我们的workerGroup 的 EventLoop 对应的管道设置处理器

            System.out.println("...... 服务器 is ready ...");

            // 启动服务器,绑定一个端口并且同步，生成一个 channelFuture 对象
            ChannelFuture cf = bootstrap.bind(9527).sync();

            // 对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } finally {
            boosGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

NettyServerHandler:


import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;


/**
 * 1. 自定义一个Handler 需要继承Netty 规定好的某个 HandlerAdapter, 这时才能称为一个Handler
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    //

    /**
     * 读取数据事件（可以读取客户端发送的消息）
     * @param ctx 上下文对象， 含有 管道pipeline, 通道channel, 地址
     * @param msg 客户端发送的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx = " + ctx);

        // 将msg 转成一个byteBuffer, ByteBuf 是 Netty 提供的，不是 NIO 的 ByteBuffer
        ByteBuf buf = (ByteBuf) msg;

        System.out.println("客户端发送消息是：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址:" + ctx.channel().remoteAddress());
    }

    /**
     * 读取数据完毕
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

        // write +  flush 将数据写入缓存，并刷新
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello, Netty", CharsetUtil.UTF_8));
    }

    /**
     * 处理异常，一般是需要关闭通道
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

NettyClient:

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

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

        // 客户端需要一个事件循环组
        EventLoopGroup group = new NioEventLoopGroup();

        // 客户端的启动对象，使用 BootStrap
        Bootstrap bootstrap = new Bootstrap();
        try {
            // 设置相关参数
            bootstrap.group(group) // 设置线程组
                    .channel(NioSocketChannel.class)  // 设置客户端通道的实现类（反射）
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyClientHandler());  // 加入自己的处理器
                        }
                    });

            System.out.println("客户端 ok..");

            // 启动客户端去连接服务器端, channelFuture 涉及到 netty的异步模型
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9527).sync();

            // 给关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        }finally {
            group.shutdownGracefully();
        }
    }
}

NettyClientHandler:


import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;


public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    /**
     * 当通道就绪时就会触发该方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client: " + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello, server", CharsetUtil.UTF_8));
    }

    /**
     * 当通道有读取事件时，会触发
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;

        System.out.println("服务器回复的消息：" + byteBuf.toString(CharsetUtil.UTF_8));

        System.out.println("服务器的地址：" + ctx.channel().remoteAddress());
    }

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

说明：

Netty 抽象出两组线程池，BossGroup 专门负责接收客户端连接，WorkerGroup 专门负责网路读写操作
NioEventLoop 表示一个不断循环执行处理任务的线程，每个 NioEventLoop 都有一个 selector, 用于监听绑定在其上的 socket 网络通道
NioEventLoop 内部采用串行化设计，从消息的读取->解码->处理->编码->发送，始终由 IO 线程 NioEventLoop 负责

NioEventLoopGroup 下包含多个NioEventLoop
每个NioEventLoop 包含有一个Selector, 一个TaskQueue
每个 NioEventLoop 的Selector上可以注册监听多个NioChannel
每个NioChannel 只会绑定在唯一的NioEventLoop上
每个NioChannel 都绑定有一个自己的ChannelPipeline

Bootstrap和ServerBootstrap:

Bootstrap 意思是引导，一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件， Netty 中 Bootstrap 类是客户端程序的启动引导类， ServerBootstrap 是服务端启动引导类

方法	说明
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup)	该方法用于服务器端，用来设置两个 EventLoop
public B group(EventLoopGroup group)	该方法用于客户端，用来设置一个 EventLoop
public B channel(Class<? extends C> channelClass)	该方法用来设置一个服务器端的通道实现
public<T> B option(ChannelOption<T> option,Tvalue)	用来给 ServerChannel 添加配置
public <T>ServerBootstrap childOption(ChannelOption<T> childOption, Tvalue)	用来给接收到的通道添加配置
public ServerBootstrap handler(ChannelHandler childHandler)	应用bossgroup
public ServerBootstrap childHandler(ChannelHandler childHandler)	该方法用来设置业务处理类 (自定义的 handler)，应用workgroup
public ChannelFuture bind(int inetPort)	该方法用于服务器端，用来设置占用的端口号
public ChannelFuture connect(String inetHost,int inetPort)	该方法用于客户端，用来连接服务器端

Future和ChannelFuture:

Netty 中所有的 I/O 操作都是异步的，不能立刻得知消息是否被正确处理。但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过 Future 和 ChannelFutures，他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事件

方法	说明
Channel channel()	返回当前正在进行 I0 操作的通道
ChannelFuture sync()	等待异步操作执行完毕

Channel:

Netty 网络通信的组件，能够用于执行网络 I/O 操作
通过 Channel 可获得当前网络连接的通道的状态
通过 Channel 可获得网络连接的配置参数（例如接收缓冲区大小）
Channel 提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成
调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture上，可以 I/O 操作成功、失败或取消时回调通知调用方
支持关联 I/O 操作与对应的处理程序
不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应

Channel 类型	说明
NioSocketChannel	异步的客户端 TCP Socket 连接。
NioServerSocketChannel	异步的服务器端 TCP Socket 连接
NioDatagramChannel	异步的 UDP 连接
NioSctpChannel	异步的客户端 Sctp 连接
NioSctpServerChannel	异步的 Sctp 服务器端连接，这些通道涵盖了 UDP 和 TCP 网络 I/O 以及文件 I/O

Selector：

Netty 基于Selector 对象实现 I/O 多路复用，通过 Selector 一个线程可以监听多个连接的 Channel 事件
当向一个 Selector 中注册 Channel 后，Selector 内部的机制就可以自动不断地查询（Select）这些注册的 Channel 是否有已就绪的 I/O 事件 (例如可读，可写，网络连接完成等), 这样程序就可以很简单地使用一个线程高效地管理多个 Channel

ChannelHandler 及其实现类:

ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其 ChannelPipeline （业务处理链）中的下一个处理程序
ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类
ChannelPipeline 提供了 ChannelHandler 链的容器。以客户端应用程序为例，如果事件的运动方向是客户端到服务端，那么我们称这些事件未出站，即客户端发送给服务端的数据会通过pipeline中的一系列 ChannelOutboundHandler，并被这些 Handler处理，反之则称为入站的

ChannelHandler 实现类	说明
ChannellnboundHandler	用于处理入站 I/O 事件
ChannelOutboundHandler	用于处理出站 I/O 操作。
ChannellnboundHandlerAdapter	适配器，用于处理入站 I/O 事件。
ChannelOutboundHandlerAdapter	适配器，用于处理出站 I/O 操作。
ChannelDuplexHandler	适配器，用于处理入站和出站事件。

Handler 实现的方法	说明
public void channelActive(ChannelHandlerContext ctx)	通道就绪事件
public void channellnactive(ChannelHandlerContext ctx)	通道未就绪事件
public void channelRead(ChannelHandlerContext ctx, Object msg)	通道读取数据事件
public void channelReadComplete(ChannelHandlerContext ctx)	数据读取完毕事件
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)	通道发生异常事件

Pipeline 和 ChannelPipeline：

ChannelPipeline 是一个 Handler的集合，它负责处理和拦截 inbound 或者 outbound的事件和操作，相当于一个贯穿 Netty的链（ChannelPipeline 是保存 ChannelHandler List, 用于处理或拦截Channel 的入站事件和出站操作）
ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及 Channel 中各个的ChannelHandler如何相互交互
在 Netty 中每个 Channel 都有且仅有一个ChannelPipeline 与之对应

一个 Channel 包含了一个 ChannelPipeline，而ChannelPipeline 中又维护了一个由 ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler
入站事件和出站事件在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的hander，出站事件会从链表 tail 往前传递到最前一个出站的 handler，两种类型的hander 互不干扰

方法	说明
ChannelPipeline addFirst(ChannelHandler... handlers)	把一个业务处理类(handler)添加到链中的第一个位置
ChannelPipeline addkast(ChannelHandler... handlers)	把一个业务处理类(handler)添加到链中的最后一个位置

ChannelHandlerContext:

保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象
即 ChannelHandlerContext 中包含一个具体的事件处理器 ChannelHandler，同时 ChannelHandlerContext 中也绑定了对应的pipeline 和 Channel的信息，方便对ChannelHandler进行调用

方法	说明
ChannelFuture close()	关闭通道
ChannelOutboundInvoker flush()	刷新
ChannelFuture writeAndFlush(Object msg)	将数据写到ChannelPipeline 中当前ChannelHandler 的下一个 ChannelHandler 开始处理(出站)

ChannelOption: Netty 在创建 Channel 实例后，一般都需要设置 ChannelOption参数

参数	说明
ChannelOption.SO BACKLOG	对应TCP/IP 协议 listen 函数中的 backlog 参数，用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接。多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog 参数指定了队列的大小。
ChannelOption.SO KEEPALIVE	一直保持连接活动状态

EventLoopGroup 和实现类NioEventLoopGroup:

EventLoopGroup 是一组 EventLoop 的抽象，Netty 为了更好得利用多核 CPU 资源，一般会有多个 EventLoop同时工作，每个 EventLoop 维护着一个 Selector 实例
EventLoopGroup 提供 next 接口，可以从组里面按照一定规则其中一个 EventLoop来处理任务。在 Netty 服务器端编程中，我们一般都需要提供两个 EventLoopGroup，例如 BossEventLoopGroup 和 WorkerEventLoopGroup
通常一个服务端口即一个 ServerSocketChannel 对应一个 Selector 和一个EventLoop线程。BossEventLoop 负责接收客户端的连接并将 SocketChannel 交给 WorkerEventLoopGroup 来进行I/O处理

BossGroupEventLoopGroup 通常是一个单线程的EventLoop,EventLoop 维护着一个注册了 ServerSocketChannel的 Selector 实例 BossEventLoop 不断轮询 Selector 将连续事件分离出来
通常是 OP_ACCEPT 事件，然后将接收到的 SocketChannel交给 WorkerEventLoopGroup
WorkerEventLoopGroup 会由 next 选择其中一个 EventLoop 来将这个SocketChannel 注册到其维护的 Selector 并对后续 I/O 事件进行处理

方法	说明
public NioEventLoopGroup()	构造方法
public Future<?>shutdownGracefully()	断开连接，关闭线程

Unpooled类： Netty 提供一个专门用来操作缓冲区（即 Netty 数据容器）的工具类

方法	说明
public static ByteBuf copiedBuffer(CharSequence string, Charset charset)	通过给定的数据和字符编码返回一个 ByteBuf 对象 (类似于NIO 中的 ByteBuffer 但有区别）

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;

public class NettyByteBuf {
    public static void main(String[] args) {
        // 创建对象，该对象包含一个数组arr，是一个byte[10]
        ByteBuf buffer = Unpooled.buffer(10);

        for (int i = 0; i < 10; i++) {
            buffer.writeByte(i);
        }
        System.out.println("capacity=" + buffer.capacity());
        // 在 Netty buffer中，不需要使用flip 进行反转，因为底层维护了 readerIndex 和 writerIndex
        // 通过 readerIndex 和 writerIndex 和 Capacity,将 buffer 分成三个区域
        // 0-readerIndex 已经读取的区域， readerIndex-writerIndex 可读的区域 writerIndex-capacity 可写的区域

//        for (int i = 0; i < buffer.capacity(); i++) {
//            System.out.println(buffer.getByte(i));
//        }
        
        for (int i = 0; i < buffer.capacity(); i++) {
            System.out.println(buffer.readByte());
        }
        System.out.println("执行完毕");
    }
}

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;

public class NettyByteBuf2 {
    public static void main(String[] args) {
        // 创建 ByteBuf
        ByteBuf byteBuf = Unpooled.copiedBuffer("hello, world!", CharsetUtil.UTF_8);

        // 使用相关的API
        if (byteBuf.hasArray()){
            byte[] content = byteBuf.array();
            System.out.println(new String(content, CharsetUtil.UTF_8));

            System.out.println("byteBuf=" + byteBuf);
            System.out.println(byteBuf.arrayOffset()); // 0
            System.out.println(byteBuf.readerIndex()); // 0
            System.out.println(byteBuf.writerIndex()); // 13
            System.out.println(byteBuf.capacity()); // 39

            int len = byteBuf.readableBytes(); //可读取的字节数 13
            System.out.println("len=" + len);

//            System.out.println(byteBuf.readByte());
//            len = byteBuf.readableBytes();
//            System.out.println("len=" + len); // 12

            System.out.println(byteBuf.getByte(0)); // 不会导致readerIndex 变化
            len = byteBuf.readableBytes();
            System.out.println("len=" + len); // 12

            for (int i = 0; i < len; i++) {
                System.out.println((char) byteBuf.getByte(i));
            }

            // 按照某个范围读取
            System.out.println(byteBuf.getCharSequence(0,4,CharsetUtil.UTF_8));
            System.out.println(byteBuf.getCharSequence(4,6,CharsetUtil.UTF_8));
        }
    }
}