1.Netty框架入门

最新推荐文章于 2023-08-05 22:09:55 发布

余生的观澜

最新推荐文章于 2023-08-05 22:09:55 发布

阅读量371

点赞数

分类专栏：网络编程

本文链接：https://blog.csdn.net/qq_25310669/article/details/88143425

版权

网络编程专栏收录该内容

22 篇文章 3 订阅

订阅专栏

文章目录

Netty框架入门
关于bytebuf对象的释放问题

Netty框架入门

首先声明在学习的过程中参考了netty5的user guide。在此非常感谢netty的贡献者社区。在本篇博客中，将会基于netty5实现最简单的读取和发送数据的功能。代码中有一些自己的理解，以注释形式给出。
参考手册地址：http://ifeve.com/netty5-user-guide/

客户端代码

package netty;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
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;

import java.io.UnsupportedEncodingException;

/**
 * @Auther: ；李泽
 * @Date: 2019/3/4 22:05
 * @Description:
 */
public class NettyClient {
    public static void main(String[] args) throws InterruptedException, UnsupportedEncodingException {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(eventLoopGroup)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        //这里面的是接受服务器端反馈时，才会触发的handler
                        socketChannel.pipeline().addLast(new ClientHandler());
                    }
                });
        ChannelFuture channelFuture1 = bootstrap.connect("127.0.0.1",8080).sync();
        //客户端发送数据，借用netty的buffer转化工具
        channelFuture1.channel().writeAndFlush(Unpooled.copiedBuffer("李泽".getBytes("utf-8")));

        //可以理解为阻塞在这
        channelFuture1.channel().closeFuture().sync();
        eventLoopGroup.shutdownGracefully();
    }
}

客户端业务handler

package netty;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.ReferenceCountUtil;

/**
 * @Auther: ；李泽
 * @Date: 2019/3/4 22:05
 * @Description:
 */
public class ClientHandler extends ChannelHandlerAdapter {
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
        cause.printStackTrace();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //super.channelRead(ctx, msg);
        try {
            //获得反馈过来的信息，转化为bytebuffer，这个对象是netty封装的，不是原生的。
            ByteBuf buffer = (ByteBuf)msg;
            //创建一个空间，从buffer中拿出数据
            byte[] bytes = new byte[buffer.readableBytes()];
            buffer.readBytes(bytes);
            //打印输出
            String resp = new String(bytes,"utf-8");
            System.out.println("resp = " + resp);
            //buffer.release();
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }
}

服务端代码

package netty;

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;

/**
 * @Auther: ；李泽
 * @Date: 2019/3/4 22:04
 * @Description:
 */
public class NettyServer {
    private int port;

    public NettyServer(int port) {
        this.port = port;
    }

    public void run() throws Exception {
        /*
        NioEventLoopGroup 是用来处理I/O操作的多线程事件循环器，Netty提供了许多不同的EventLoopGroup的实现用来处理不同传
        输协议。在这个例子中我们实现了一个服务端的应用，因此会有2个NioEventLoopGroup会被使用。第一个经常被叫做‘boss’，
        用来接收进来的连接。第二个经常被叫做‘worker’，用来处理已经被接收的连接，一旦‘boss’接收到连接，就会把连接信
        息注册到‘worker’上。如何知道多少个线程已经被使用，如何映射到已经创建的Channels上都需要依赖于EventLoopGroup的
        实现，并且可以通过构造函数来配置他们的关系。
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            /*
            ServerBootstrap 是一个启动NIO服务的辅助启动类。你可以在这个服务中直接使用Channel，但是这会是一个复杂的处
            理过程，在很多情况下你并不需要这样做。
             */
            ServerBootstrap b = new ServerBootstrap();
            //给启动器配置两个线程组
            b.group(bossGroup, workerGroup)
                    //这里我们指定使用NioServerSocketChannel类来举例说明一个新的Channel如何接收进来的连接。
                    .channel(NioServerSocketChannel.class)
                    /*
                    这里的事件处理类经常会被用来处理一个最近的已经接收的Channel。ChannelInitializer是一个特殊的处理类，
                    他的目的是帮助使用者配置一个新的Channel。也许你想通过增加一些处理类比如ServerHandler来配置一
                    个新的Channel或者其对应的ChannelPipeline来实现你的网络程序。当你的程序变的复杂时，可能你会增加更多
                    的处理类到pipline上，然后提取这些匿名类到最顶层的类上。
                     */
                    .childHandler(new ChannelInitializer <SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ServerHandler());
                }
            })
            /*
            你可以设置这里指定的通道实现的配置参数。我们正在写一个TCP/IP的服务端，因此我们被允许设置socket的参
            数选项比如tcpNoDelay和keepAlive。
             */
            /*
              SO_BACKLOG参数解释：服务器端的内核模块维护有两个队列，我们称之为A，B。
              客户端向服务器端connect的时候，会发送带有SYN标志的包，称之为第一次握手。
              服务器收到客户端发来的SYN时，向客户端发送SYN_ACk确认，称之为第二次握手。
              此时TCP内核模块把客户端连接加入到A队列中，然后服务器收到客户端发来的ACK时，称之为第三次握手
              TCP内核把客户端连接从A队列移动到B队列，连接完成，应用程序的accept被触发，产生返回值。
              也就是说accept从B队列中取出完成三次握手的连接。
              A，B的队列的长度之和是BACKLOG，若AB队列之和大于BACKLOG时，新连接会被tcp内核拒绝。
              所以，如果BACKLOG过小，可能会出现accept速度跟不上，AB满了，导致新连接无法接入。
              需要注意的是：BACKLOG对支持的连接数并无影响，影响的只是还没被accept取出的连接。
             */
             .option(ChannelOption.SO_BACKLOG, 128)
             /*
             你关注过option()和childOption()吗？option()是提供给NioServerSocketChannel用来接收进来的连接。childOption()
             是提供给由父管道ServerChannel接收到的连接，在这个例子中也是NioServerSocketChannel。
              */
             /*
               保持连接不断开
              */
              .option(ChannelOption.SO_KEEPALIVE, true);

            // 绑定并且启动服务来接受到来的请求
            ChannelFuture f = b.bind(port).sync(); // (7)

            // 在服务关闭之前都会等待
            // 在这个例子中这是不会发生的, 但是你也可以写上这个来做到完美
            // 关闭你的服务.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new NettyServer(port).run();
    }
}

服务端业务handler

package netty;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.ReferenceCountUtil;


/**
 * @Auther: ；李泽
 * @Date: 2019/3/4 22:05
 * @Description:  继承自ChannelHandlerAdapter，这个类实现了ChannelHandler接口，ChannelHandler提供了许多事件处理
 *                的接口方法，然后你可以覆盖这些方法。现在仅仅只需要继承ChannelHandlerAdapter类而不是你自己去实
 *                现接口方法。
 */
public class ServerHandler extends ChannelHandlerAdapter {
    /**
     * 功能描述: exceptionCaught()事件处理方法是当出现Throwable对象才会被调用，即当Netty由于IO错误或者处理器在处理事件
     *           时抛出的异常时。在大部分情况下，捕获的异常应该被记录下来并且把关联的channel给关闭掉。然而这个方法的处
     *           理方式会在遇到不同异常的情况下有不同的实现，比如你可能想在关闭连接之前发送一个错误码的响应消息。
     *
     * @auther: 李泽
     * @date: 2019/3/4 22:24
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
    }
    /**
     * 功能描述: 这里我们覆盖了chanelRead()事件处理方法。每当从客户端收到新的数据时，这个方法会在收到消息时被调用，
     *           这个例子中，收到的消息的类型是ByteBuf
     *
     * @auther: 李泽
     * @date: 2019/3/4 22:23
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //super.channelRead(ctx, msg);  不注释掉会报错
        /*
           介绍一个读取事件的最佳实践：
           ByteBuf in = (ByteBuf) msg;
           try {
                // Do something with msg
                如果单纯用网络助手测试的话 发16进制，可以在这打印一下：
                    while (in.isReadable()) { // (1)
                        System.out.print((char) in.readByte());
                        System.out.flush();
                    }
                  等价于：System.out.println(in.toString(io.netty.util.CharsetUtil.US_ASCII))
            } finally {
                ReferenceCountUtil.release(msg);
            }
         */
         try {

             //获得发送过来的信息，转化为bytebuffer，这个对象是netty封装的，不是原生的。
             ByteBuf bufferRead = (ByteBuf)msg;
             //复制一份，用来响应数据
             ByteBuf bufferWrite = bufferRead.copy();
             //创建一个空间，从buffer中拿出数据
             byte[] bytes = new byte[bufferRead.readableBytes()];
             bufferRead.readBytes(bytes);
             //打印输出
             String req = new String(bytes,"utf-8");
             System.out.println("req = " + req);
             //下面的finally来释放
             //bufferRead.release();
             //给个反馈，遵循echo响应协议，发啥反馈啥,
             ctx.writeAndFlush(bufferWrite);
             //不需要释放，因为冲刷之后，自动释放了
             //bufferWrite.release();
          } finally {
             //如果上面的业务出现了反馈的代码，就不需要释放空间，冲刷了之后，就自动释放了
             ReferenceCountUtil.release(msg);
          }
    }
}

关于bytebuf对象的释放问题

对于单纯读的逻辑，读完了之后要最终使用 ReferenceCountUtil.release(msg)来释放。
对于写的逻辑，用到的bytebuf对象，netty会自动处理掉，不用手动release()，相关方法：ctx.writeAndFlush(bufferWrite)
对一个msg对象又要读取，又要写出，最好是复制一份。