Netty核心API介绍

 

ChannelHandler及其实现类

ChannelHandler接口定义了许多事件处理的方法，我们可以通过重写这些方法实现具体的业务逻辑。

其中ChannleInboundHandlerAdapter和ChannelOutboundHandlerAdapter是最常使用的类，我们经常需要自定义一个Handler去继承ChannelInboundHandlerAdatper，然后重写相应的业务逻辑：

• public void channelActive(ChannelHandlerContext ctx),通道就绪事件
• public void channelRead(ChannelHandlerContext ctx, Object msg), 通道读取数据事件
• public void channelReadComplete(ChannelHandlerContext ctx), 数据读取完毕事件
• public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)，通道发生异常事件

pipline和ChannelPipeline

ChannelPipeLine是一个Handler的集合，它负责处理和拦截inbound或者outbound的事件和操作，相当于一个贯穿Netty的链。

• ChannelPipeline addFirst(ChannelHandler... handlers)，把一个业务处理类(handler)添加到链中的第一个位置。
• ChannelPipeline addLast(ChannelHandler... handlers)，把一个业务处理类添加到链中的最后一个位置。

ChannelHandlerContext

这是事件处理器上下文对象，Pipeline链中的实际处理节点。每个处理节点ChannelHandlerContext中包含一个具体的时间处理器ChannelHandler，同时ChannelHandlerContext中也绑定了对应的pipeline和Channel的信息，方便对ChannelHandler进行调节。常用的方法如下：

• ChannelFuture close().关闭通道(相关连的channel）
• ChannelOutboundInvoker flush()，刷新
• ChannelFuture writeAndFlush(Object msg)，将数据写到ChannelPipeline中当前ChannelHandler的下一个ChannelHandler开始处理(出站)

ChannelOption

Netty在创建Channel实例后，一般都需要设置ChannelOption参数。ChannelOption是Socket的标准参数，而非Netty独创的。常用的参数配置有：

1. ChannelOption.SO_BACKLOG 设置等待队列的大小

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

2. ChannelOption.SO_KEEPLIVE，一直保持连接状态。

ChannelFuture

在Netty中所有的I/O操作都是异步的，I/O的调用会直接返回，调用者并不能立刻获得结果，但是可以通过ChannelFuture来获取I/O操作的处理状态，类似于java.io.nio + java.util.Current。

• Channel channel()，返回当前正在进行IO操作的通道
• ChannelFuture sync()，等待异步操作执行完毕

EventLoopGroup和其实现类NioEventLoopGroup[单个线程]

EventLoopGroup是一组EventLoop的抽象，Netty为了更好的利用多核CPU资源，一般会有多个EventLoop同时工作，每个EventLoop维护着一个Selector实例。

EventLoopGroup提供next接口，可以从组里面按照一定规则获取其中一个EventLoop来处理任务。在Netty服务器端编程中，我们一般都需要提供两个EventLoopGroup，例如：BossEventLoopGroup和WorkerEventLoopGroup。

通常一个服务端口即一个ServerSocketChannel对应一个Selector和一个EventLoop线程。BossEventLoop负责接收客户端的连接并将SocketChannel交给WorkerEventLoopGroup来进行IO处理。

BossEventLoopGroup 通常是一个单线程的 EventLoop， EventLoop 维护着一个注册了ServerSocketChannel 的 Selector 实例， BossEventLoop 不断轮询 Selector 将连接事件分离出来，通常是 OP_ACCEPT 事件， 然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup，
WorkerEventLoopGroup 会由 next (实现了Iterable接口)选择其中一个 EventLoopGroup 来将这个 SocketChannel 注册到其维护的 Selector 并对其后续的 IO 事件进行处理。
常用方法如下：

• public NioEventLoopGroup()，构造方法
• public Future<?> shutownGracefully(), 断开连接，关闭线程【在结束的时候调用】

ServerBootstrap和Bootstrap【启动的时候配置】

serverBootstrap是Netty中的服务器端启动助手，通过它可以完成服务器端的各种配置；Bootstrap是Netty中的客户端助手，通过它可以完成服务端的各种配置；Bootstrap是Netty中的客户端启动助手，通过它可以完成客户端的各种配置。

• 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, T value)，用来给ServerChannel添加配置
  public<T> ServerBootstrap childOption(ChannelOption<T> childOption, T value)，用来给接收到的通道添加配置
• public ServerBootstrap childHandler(ChannelHandler childHandler)，该方法用来设置业务处理类(自定义的handler
• public ChannelFuture bind(int inetPort)，该方法用于服务器端，用来设置占用的端口号
• public ChannelFuture connect(String inetHost, int inetPort)，该方法用于客户端，用来连接服务器

实例：

服务器端

public class NettyServer {
    public static void main(String[] args) throws Exception{
        //1. 创建一个线程组：接收客户端连接
        EventLoopGroup bossGroup =new NioEventLoopGroup();
        //2. 创建一个线程组：处理网络操作
        EventLoopGroup workerGroup =new NioEventLoopGroup();
        //3. 创建服务器端启动助手来配置参数
        ServerBootstrap b=new ServerBootstrap();
        b.group(bossGroup,workerGroup) //4.设置两个线程组
         .channel(NioServerSocketChannel.class) //5.使用NioServerSocketChannel作为服务器端通道的实现
         .option(ChannelOption.SO_BACKLOG,128) //6.设置线程队列中等待连接的个数
         .childOption(ChannelOption.SO_KEEPALIVE,true) //7.保持活动连接状态
         .childHandler(new ChannelInitializer<SocketChannel>() {  //8. 创建一个通道初始化对象
             public void initChannel(SocketChannel sc){   //9. 往Pipeline链中添加自定义的handler类
                 sc.pipeline().addLast(new NettyServerHandler());
             }
         });
        System.out.println("......Server is ready......");
        ChannelFuture cf=b.bind(9999).sync();  //10. 绑定端口 bind方法是异步的  sync方法是同步阻塞的
        System.out.println("......Server is starting......");

        //11. 关闭通道，关闭线程组
        cf.channel().closeFuture().sync(); //异步
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

客户端

//网络客户端
public class NettyClient {
    public static void main(String[] args) throws  Exception{

        //1. 创建一个线程组
        EventLoopGroup group=new NioEventLoopGroup();
        //2. 创建客户端的启动助手，完成相关配置
        Bootstrap b=new Bootstrap();
        b.group(group)  //3. 设置线程组
         .channel(NioSocketChannel.class)  //4. 设置客户端通道的实现类
         .handler(new ChannelInitializer<SocketChannel>() {  //5. 创建一个通道初始化对象
             @Override
             protected void initChannel(SocketChannel socketChannel) throws Exception {
                 socketChannel.pipeline().addLast(new NettyClientHandler()); //6.往Pipeline链中添加自定义的handler
             }
         });
        System.out.println("......Client is  ready......");

        //7.启动客户端去连接服务器端  connect方法是异步的   sync方法是同步阻塞的
        ChannelFuture cf=b.connect("127.0.0.1",9999).sync();

        //8.关闭连接(异步非阻塞)
        cf.channel().closeFuture().sync();

    }
}

Unpooled类

这是Netty提供的一个专门用来操作缓冲区的工具类，常用方法如下：

pulic static ByteBuf copiedBuffer(CharSequence string, Charset charsht), 通过给定的数据和字符编码返回一个ByteBuf对象(类似于NIO中的ByteBuffer对象)

 //数据读取完毕事件
    public void channelReadComplete(ChannelHandlerContext ctx){
        ctx.writeAndFlush(Unpooled.copiedBuffer("就是没钱",CharsetUtil.UTF_8));
    }
.