网络I/o编程模型15 netty的核心组件

一 netty的核心组件

1.1 bootstrapserver

1.netty中Bootstrap类是客户端程序的启动引导类，serverBootstrap是服务端启动引导类。

常见的方法有：

public ServerBootstrap group(EventLoopGroup parentGroup,EventLoopGroup childrenGroup)://该方法用于服务器端，用来设置两个EventLoop

public B group(EventLoopGroup group) //该方法用于客户端，用来设置一个EventLoop
public B channel(Class<? extends C> channelClass) //该方法用来设置一个服务器端的通道实现。
public<T> B option(ChannelOption 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) //该方法用于客户端，用来连接服务器端

1.2 Future，channelFuture

netty中所有的IO操作都是异步的，不能立刻得知消息是否被正确处理。但是可以通过Future和channelFutures，他们可以注册一个监听，当操作执行成功或失败时，监听就会自动触发注册的监听事件。
常见的方法有：
Channel channel(); 返回当前正在执行IO操作的通道。
ChannelFuture sync(); 等待异步操作执行完毕。

1.3 channel

1.通过channel可获得当前网络连接的通道状态，获得网络连接的配置参数
2.channel提供异步的网络I/O操作(如建立连接、对写、绑定端口)、异步调用意味着任何I/O调用都将立即返回，并且不保证在调用结束时所有请求的I/O操作已经完成。调用立即返回一个ChannelFuture实例，通过注册监听器到ChannelFuture上，可以收到操作成功，失败等消息的通知。
3.常用的channel类：
NioSocketchannel   异步的客户端TCP连接
NioServerSocketChannel  异步的服务器端Tcp Socket连接。
NioDatagramChannel  异步的udp连接
nioSctpchannel  异步的客户端sctp连接
NioSctpSeverChannel ：异步的sctp服务器端连接，这些涵盖了udp，tcp以及网络io，文件io等。

1.4 selector

netty基于selector对象实现I/O多路复用，通过selector一个线程可以监听多个连接的channel事件；
当向一个selector中注册channel后，selector内部的机制就可以自动不断地查询，这些注册的channel是否已有就绪的I/O事件，这样程序就可以很简单的使用一个高效地管理多个channel。

1.5 channelHandler

channelHandler是一个接口，自定义的子类实现其接口，处理I/O事件。并将其转发到channelPipeline(业务处理链)中的下一个处理程序。

1.channelInboundHandler  用于处理入站I/O事件。
2.channelOutboundHandler 用于处理出站I/O操作。
3.ChannelInboundHandlerAdapter 用于处理入站I/O事件。
4.channelOutboundHanlerAdapter 用于处理出站I/O操作。
5.channelDuplexHandler  用于处理入站和出站事件。
我们经常需要自定义一个handler类去继承channelinboundHandlerAdapter，然后通过重写相应方法实现业务逻辑。
重写：  channelRegistered();channelUnregistered(),channelActive(),channelRead();

1.6 channelPipeline

channelPipeline是保存channelHandler的list，用于处理或者拦截channel的入站事件和出站事件的操作。
channelePipeLine是一种高级形式的拦截过滤器模式，使用用户可以完全控制事件的处理方式，以及channel中各个channelHandler如何相互交互。
在netty中每个channel都有且既有一个channelPipeline与之对应。关系图如下

一个channel包含了一个channelPipeline，而channelpipeline中又维护了一个由channelhandlercontext组成的双向链表，并且每个channelhandlercontext中又关联着一个channelhandler。

channelhandler》channelhandlercontext》channelpipeline> channel

入站事件和出站事件是一个双向链表中，

入站事件会从链表中head往后传递到最后一个入站的handler，

出站事件则会从链表的tail往前传递到最前一个出站的handler，两种类型的hanler互不干扰。

常用API方法：
channelPipeline.addFirst(ChannelHandler ....handlers) 把一个业务处理类(handler)添加到链表中第一个位置
channelPipeline.addLast(channelHandler ... handlers)  把一个业务处理类(handler) 添加到链表中的最后一个位置。 

1.7 channelhandlercontext

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

channelFuture close()  //关闭通道
channelOutboundInvoker  flush() ,刷新
channelFuture writeAndFlush(Object msg) 将数据写入到channelpipeline中(下一个channnelhandler开始处理，也就出站)

1.8  channeloption

1.在netty创建channel实例后，一般都需要设置channeloption参数，
常用api
channeloption.so_backlog :对应TCP/IP协议listen函数中的backlog参数，用来初始化服务器可连接队列大小。服务器端处理客户端请求是顺序处理的，所以同一时间只能处理一个客户端连接。
多个客户端来的时候，服务端将不能处理处理客户端连接请求放在队列中等待处理，backlog参数制定队列的大小。
channeloption.so_keepalive : 一直保持连接活动状态。

1.9  EventLoopGroup

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

BossEventLoopGroup通常是一个单线程的EventLoop，EventLoop维护着一个注册了ServerSocketChannel的select实例。BossEventLoop不断轮询selector将连接事件分离出来。
通常是op_accept事件，然后将接收到的socketchannel交给workerEventLoopGroup。
WorkerEventLoopGroup会由next选择其中一个EventLoop来将这个SocketChannel注册到其维护的selector上，并对其后续IO事件进行处理。

 常见Api
public NioEventLoopGroup()： 构造方法
public Future<?> shutdownGracefully()  断开连接，关闭线程。

1.10  unpooled类

netty提供一个专门用来操作缓存区的的工具类。ByteBuf对象，类似Nio中的ByteBuffer对象，但有区别。
public static ByteBuf copiedBuffer(CharSequence str,Charset charset);

在netty的buffer中，不需要进行flip反转操作，底层维护了rederindex和writerindex的操作；
通过readerindex和writerindex和capacity，将buffer分成3个区域
0-> readerindex 已经读取的区域
readerindex -> writerindex 可读的区域
writerindex -> capacity  可写的区域

1.代码

package com.ljf.netty.netty.unpooled;

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

/**
 * @ClassName: ByteBufTest
 * @Description: TODO
 * @Author: liujianfu
 * @Date: 2022/06/05 14:28:38
 * @Version: V1.0
 **/
public class ByteBufTest {
    public static void main(String[] args) {
        ByteBuf  bb= Unpooled.buffer(10);
        for(int k=0;k<10;k++){
            bb.writeByte(k);
        }
        /**
         在netty的buffer中，不需要进行flip反转操作，底层维护了rederindex和writerindex的操作；
         通过readerindex和writerindex和capacity，将buffer分成3个区域
         0-> readerindex 已经读取的区域
         readerindex -> writerindex 可读的区域
         writerindex -> capacity  可写的区域
         */
        System.out.println("capacity:"+bb.capacity());
        System.out.println("遍历方式一:");
        for(int m=0;m<bb.capacity();m++){
            System.out.println("m:"+bb.getByte(m));
        }
        System.out.println("遍历方式二:");
        for(int n=0;n<bb.capacity();n++){
            System.out.println("n:"+bb.readByte());
        }
        System.out.println("");
    }
}

结果：

 2.代码

package com.ljf.netty.netty.unpooled;

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

import java.nio.charset.Charset;

/**
 * @ClassName: ByteBufferTest2
 * @Description: TODO
 * @Author: liujianfu
 * @Date: 2022/06/05 14:44:38
 * @Version: V1.0
 **/
public class ByteBufferTest2 {
    public static void main(String[] args) {
        ByteBuf byteBuf= Unpooled.copiedBuffer("hello,beijing", Charset.forName("utf-8"));
        if(byteBuf.hasArray()){//true
            byte[] content=byteBuf.array();
            //将content转成字符串
            System.out.println(new String(content,Charset.forName("utf-8")));
            System.out.println("byteBuf:"+byteBuf);
            System.out.println("偏移量:"+byteBuf.arrayOffset());
            System.out.println("可读区域:"+byteBuf.readerIndex());
            System.out.println("可写区域:"+byteBuf.writerIndex());
            System.out.println("容量:"+byteBuf.capacity());
            System.out.println("huoq:"+byteBuf.getByte(0));
            int len=byteBuf.readableBytes();
            System.out.println("len:"+len);
            for(int k=0;k<len;k++){
                System.out.println(""+(char)byteBuf.getByte(k));
            }
               System.out.println(""+byteBuf.getCharSequence(4,6,Charset.forName("utf-8")));
        }
    }
}

结果：