Netty基础学习（一）

Netty相关基础概念

1 Channel：相当于一个Socket连接，类比java nio的SocketChannel；
2 EventLoop：反应堆线程，通过非阻塞方式执行I/O任务、定时任务等，类比java nio的Selector；I/O任务和定时任务都被抽象为事件，通过eventloop线程执行；
3 EventLoopGroup：反应堆线程组成的线程池，用于提升反应堆的处理能力及可用性；
4 ChannelFuture：采用Promise模式，异步通知I/O结果；
5 ChannelPipeline：一个channel中，用于处理事件的职责链，即一条完整的数据处理流程，包括输入、输出；
6 ChannelHandler：一条ChannelPipeline中的一个环节，可以只针对特定事件进行处理，或者仅对事件进行部分处理，如数据的编解码，以便于后续环节的处理；
7 ChannelInitializer：用于初始化一个Channel；
8 Bootstrap：用于引导和简化一个Channel的初始化过程；
9 ChannelGroup：用于对一组Channel进行分类和统一管理；

Netty中实体的关系

1 一个EventLoopGroup中包含一个或者多个EventLoop；
2 一个EventLoop在其生命周期内只和一个Thread绑定，且分配给该EventLoop的所有事件都在其绑定的Thread上处理；
3 一个Channel在其生命周期内只注册于一个EventLoop；
4 一个EventLoop可以用于处理一个或者多个Channel的事件；
5 一个EventLoopGroup可以被多个Channel所共享，通过Bootstrap单独为每一个Channel新建EventLoopGroup没有必要；

Netty架构图

Netty实现一个HelloWorld

类结构图

Server.java

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;
/**
 * @ClassName Server
 * @Description
 * @Author 夕
 * @Date 2019-11-10 18:47
 * @Version V1.0
 **/
public class Server {
    public static void main(String[] args) throws Exception {
        // 1 创建线两个程组
        // 一个是用于处理服务器端接收客户端连接的
        // 一个是进行网络通信的（网络读写的）
        EventLoopGroup pGroup = new NioEventLoopGroup();
        EventLoopGroup cGroup = new NioEventLoopGroup();

        // 2 创建辅助工具类，用于服务器通道的一系列配置
        ServerBootstrap b = new ServerBootstrap();
        b.group(pGroup, cGroup)        // 绑定俩个线程组
                .channel(NioServerSocketChannel.class)        // 指定NIO的模式
                .option(ChannelOption.SO_BACKLOG, 1024)        // 设置tcp缓冲区
                .option(ChannelOption.SO_SNDBUF, 32*1024)    // 设置发送缓冲大小
                .option(ChannelOption.SO_RCVBUF, 32*1024)    // 这是接收缓冲大小
                .option(ChannelOption.SO_KEEPALIVE, true)    // 保持连接
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        // 3 在这里配置具体数据接收方法的处理
                        sc.pipeline().addLast(new ServerHandler());
                    }
                });

        // 4 进行绑定
        ChannelFuture cf1 = b.bind(8888).sync();
        // 5 等待关闭
        cf1.channel().closeFuture().sync();
        pGroup.shutdownGracefully();
        cGroup.shutdownGracefully();
    }
}

ServerHandler.java

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
/**
 * @ClassName ServerHandler
 * @Description
 * @Author 夕
 * @Date 2019-11-10 18:47
 * @Version V1.0
 **/
public class ServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server channel active... ");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, "utf-8");
        System.out.println("Server :" + body );
        String response = "进行返回给客户端的响应：" + body;
        ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("读完了");
        ctx.flush();
    }

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

Clinet.java

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
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;
/**
 * @ClassName Clinet
 * @Description
 * @Author 夕
 * @Date 2019-11-10 18:47
 * @Version V1.0
 **/
public class Client {
    public static void main(String[] args) throws Exception{
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap b = new Bootstrap();
        b.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel sc) throws Exception {
                sc.pipeline().addLast(new ClientHandler());
            }
        });

        ChannelFuture cf1 = b.connect("127.0.0.1", 8888).syncUninterruptibly();
        // 发送消息
        byte[] msg = "发送第1条测试消息".getBytes();
        cf1.channel().writeAndFlush(Unpooled.copiedBuffer(msg));

        // 等待关闭
        cf1.channel().closeFuture().sync();
        group.shutdownGracefully();
    }
}

ClientHandler.java

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;
/**
 * @ClassName ClinetHandler
 * @Description
 * @Author 夕
 * @Date 2019-11-10 18:47
 * @Version V1.0
 **/
public class ClientHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {}

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            ByteBuf buf = (ByteBuf) msg;

            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);

            String body = new String(req, "utf-8");
            System.out.println("Client :" + body );
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {}

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

首先运行Server.java，然后再运行Client.java,结果如下：