netty

Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。

Netty是基于nio的，它封装了jdk的nio，让我们使用起来更加方法灵活。

特点

高性能：

• 线程模型：通过多线程Reactor反应器模式，在应用层实现异步非阻塞（异步事件驱动）架构，用最少的资源做更多的事。
• 内存零拷贝：尽量减少不必要的内存拷贝，实现了更高效率的传输。
• 内存池设计：申请的内存可以重用，主要指直接内存。内部实现是用一颗二叉查找树管理内存分配情况。 （具体请参考尼恩稍后的手写内存池）
• 对象池设计：Java对象可以重用，主要指Minior GC非常频繁的对象，如ByteBuffer。并且，对象池使用无锁架构，性能非常高。 （具体请参考尼恩稍后的手写对象池）
• mpsc无锁编程：串形化处理读写, 避免使用锁带来的性能开销。
• 高性能序列化协议：支持 protobuf 等高性能序列化协议。

BIO、NIO和AIO的区别

BIO：一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理。线程开销大。BIO是面向流的 BIO的各种流是阻塞的。BIO的Stream是单向的。
伪异步IO：将请求连接放入线程池，一对多，但线程还是很宝贵的资源。

NIO：一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。NIO是面向缓冲区的。 而NIO是非阻塞的。而NIO的channel是双向的。

AIO：一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，

 

NIO的特点：事件驱动模型、单线程处理多任务、非阻塞I/O，I/O读写不再阻塞，而是返回0、基于block的传输比基于流的传输更高效、更高级的IO函数zero-copy、IO多路复用大大提高了Java网络应用的可伸缩性和实用性。基于Reactor线程模型。

在Reactor模式中，事件分发器等待某个事件或者可应用或个操作的状态发生，事件分发器就把这个事件传给事先注册的事件处理函数或者回调函数，由后者来做实际的读写操作。如在Reactor中实现读：注册读就绪事件和相应的事件处理器、事件分发器等待事件、事件到来，激活分发器，分发器调用事件对应的处理器、事件处理器完成实际的读操作，处理读到的数据，注册新的事件，然后返还控制权。

springboot集成netty

 

/**
 * netty服务端启动加载配置
 */
@Component
public class NettybootServerInitConfig implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        /**
         * 启动WebSocketServer 服务使用netty实现
         */
        new WebSocketServer().start();
    }
}

 

自定义server

bossGroup 和 workerGroup 是两个线程池, 它们默认线程数为 CPU 核心数乘以 2，bossGroup 用于接收客户端传过来的请求，接收到请求后将后续操作交由 workerGroup 处理。

public class WebSocketServer {
    public void start() {
        // 一个主线程组
        NioEventLoopGroup mainGroup = new NioEventLoopGroup();
        //一个工作线程组
        NioEventLoopGroup subGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(mainGroup, subGroup)
                    //设置队列大小
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .channel(NioServerSocketChannel.class)
                    // 两小时内没有数据的通信时,TCP会自动发送一个活动探测数据报文
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    //添加自定义初始化处理器
                    .childHandler(new WsServerInitialzer());
            ChannelFuture channelFuture = serverBootstrap.bind(8082).sync();
            channelFuture.channel().closeFuture().sync();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭主线程组
            mainGroup.shutdownGracefully();
            //关闭工作线程组
            subGroup.shutdownGracefully();
        }
    }
}

 

配置处理器

我们自定义一个类 WsServerInitialzer 继承 ChannelInitializer 并实现其中的 initChannel方法。

ChannelInitializer 继承 ChannelInboundHandlerAdapter，用于初始化 Channel 的 ChannelPipeline。通过 initChannel 方法参数 ch 得到 ChannelPipeline 的一个实例。

当一个新的连接被接受时， 一个新的 Channel 将被创建，同时它会被自动地分配到它专属的 ChannelPipeline。

public class WsServerInitialzer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {

        ChannelPipeline pipeline = ch.pipeline();
        //websocket基于http协议，所以需要http编解码器

        pipeline.addLast(new HttpServerCodec());
        //添加对于读写大数据流的支持
        pipeline.addLast(new ChunkedWriteHandler());
        //对httpMessage进行聚合  聚合成FullHttpRequest或FullHttpResponse
        pipeline.addLast(new HttpObjectAggregator(1024*64));
        //===================增加心跳===================
        //如果是读写空闲  不处理
        pipeline.addLast(new IdleStateHandler(8,10,12));
        //自定义空闲状态检测
        pipeline.addLast(new HeartBeatHandler());

        /*
         * websocket 服务器处理的协议 ，用于指定给客户端连接访问的路由 :/ws
         * 本handler 会帮你处理一些繁重的复杂的事
         * 会帮你处理握手动作 ：handshaking （close，ping，pong）ping+pong=心跳
         * 对于websocket来讲， 都是以frams进行传输的不同的数据类型对应的frames也不同
         * */
        pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));

        //自定义handler
//        pipeline.addLast(new MyWebsocketHandler());

        pipeline.addLast(new MyChannelHandler());

    }
}

 

对于自定义的 ChannelHandler， 一般会继承 Netty 提供的SimpleChannelInboundHandler类，并且对于 Http 请求我们可以给它设置泛型参数为 HttpOjbect 类，然后覆写 channelRead0 方法，在 channelRead0 方法中编写我们的业务逻辑代码，此方法会在接收到服务器数据后被系统调用。

 

@Slf4j
public class MyWebsocketHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
    private static ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("已创建WebSocket链接：{}", ctx.channel().remoteAddress());
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        String text = msg.text();
        sendAllMessages(ctx,text);
        log.info("收到消息：{}  {}",text , ctx.channel().remoteAddress());
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        log.info("加入连接：{}", ctx.channel().id().asLongText());
        channels.add(ctx.channel());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        log.info("断开链接的ID {}", ctx.channel().id().asLongText());
        channels.remove(ctx.channel());

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.info("出现异常 {}  {}", ctx.channel().id().asLongText(),cause);
        channels.remove(ctx.channel());
        ctx.channel().closeFuture();
    }


    //给每个人发送消息,除发消息人外
    private void sendAllMessages(ChannelHandlerContext ctx, String msg) {
        for (Channel channel : channels) {
            if (!channel.id().asLongText().equals(ctx.channel().id().asLongText())) {
                channel.writeAndFlush(new TextWebSocketFrame(JSON.toJSONString(msg)));
            }
        }
    }

    //给每个人发送消息,除发消息人外
    private void sendMessages(String msg) {
        for (Channel channel : channels) {
            channel.writeAndFlush(new TextWebSocketFrame(JSON.toJSONString(msg)));
        }
    }

}

处理Websocket心跳

//处理心跳
public class HeartBeatHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleState state = ((IdleStateEvent) evt).state();
            if (state == IdleState.READER_IDLE) {
                System.out.println("进入读空闲。。。");
            }else if(state == IdleState.WRITER_IDLE){
                System.out.println("进入写空闲。。。");
            }else if(state == IdleState.ALL_IDLE){
                //关闭无用的channel 以防资源浪费
                Channel channel = ctx.channel();
                channel.close();
            }
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }
}

 

同时处理http和websocket

Netty 的设计中把 Http 请求分为了 HttpRequest 和 HttpContent 两个部分，HttpRequest 主要包含请求头、请求方法等信息，HttpContent 主要包含请求体的信息。

public class MyChannelHandler extends SimpleChannelInboundHandler<Object> {

    // 用于记录和管理所有客户端的channle
    private Channel outboundChannel;
    private static ChannelGroup clients = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    /**
     * 打开链接
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("websocket::::::::::: active");
        super.channelActive(ctx);
    }

    /**
     * 获取客户端的channle，添加到ChannelGroup中
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("websocket::::::::::: add");
        clients.add(ctx.channel());
    }

    /**
     * 从ChannelGroup中移除channel
     */
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("websocket::::::::::: Removed");
    }

    /**
     * 销毁channel
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("websocket::::::::::: destroyed");
        if (clients != null) {
            closeOnFlush(outboundChannel);
        }
    }

    /**
     * 关闭释放channel
     * @param ch
     */
    static void closeOnFlush(Channel ch) {
        if (ch != null && ch.isActive()) {
            ch.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush();
    }


    /**
     * 异常捕获
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        System.err.println("出错了");
        cause.printStackTrace();
        ctx.close();
    }

    /**
     * 路由
     * 对http，websocket单独处理
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof FullHttpRequest) {// 如果是HTTP请求，进行HTTP操作
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        } else if (msg instanceof WebSocketFrame) {// 如果是Websocket请求，则进行websocket操作
            handleWebSocketFrame(ctx, (WebSocketFrame) msg);
        }
    }

    /**
     * 对http请求的处理
     */
    private void handleHttpRequest(ChannelHandlerContext ctx, final FullHttpRequest msg) {
        String c = "qwerqwer56qewr645qwe";
        // 1.设置响应
        FullHttpResponse resp = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
                HttpResponseStatus.OK,
                Unpooled.copiedBuffer(JSONObject.toJSONString(c), CharsetUtil.UTF_8));

        resp.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=UTF-8");

        // 2.发送
        // 注意必须在使用完之后，close channel
        ctx.writeAndFlush(resp).addListener(ChannelFutureListener.CLOSE);
    }

    /**
     * 对socket请求的处理
     */
    private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame msg) {
        // 获取客户端传输过来的消息
        String content = msg.toString();
        System.out.println("websocket：：：  接受到的数据：" + content);
        clients.writeAndFlush(new TextWebSocketFrame("[服务器在]" + LocalDateTime.now() + "接受到消息, 消息为：" + content));

    }
    private void response(ChannelHandlerContext ctx, Object c) {

        // 1.设置响应
        FullHttpResponse resp = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
                HttpResponseStatus.OK,
                Unpooled.copiedBuffer(JSONObject.toJSONString(c), CharsetUtil.UTF_8));

        resp.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=UTF-8");

        // 2.发送
        // 注意必须在使用完之后，close channel
        ctx.writeAndFlush(resp).addListener(ChannelFutureListener.CLOSE);
    }
}

常用API

Bootsrap

1.引导

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

2.常见方法:

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

Future，ChannelFuture

1.引导

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

2.常见方法:

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

Channel

1.Netty网络通信的组件，能够执行网络IO操作
2.通过Channel 可获得当前网络连接的通道的状态
3.通过Channel 可获得网络连接的配置参数
4.Channel 提供异步的网络IO操作（如建立连接，读写，绑定端口），异步调用意味着任何IO调用都将立即返回，并且不保证在调用结束时所请求的IO操作都已完成
5.调用立即返回一个ChannelFuture实例，通过注册监听器到ChannelFuture上，可以IO操作成功，失败或取消时回调通知调用方
6.支持关联IO操作与对应的处理程序
7.不同协议，不同的阻塞类型的连接都有不同的Channel 类型与之对应
常用的Channel类型：
NioSocketChannel 异步客户端 TCP Socket连接
NioServerScoketChannel 异步的服务器端TCP Socket连接。
NioDataGramChannel 异步的UDP连接
NioSctpChannel 异步的客户端Sctp连接
NioSctpServerChannel 异步的Sctp服务器端连接，这些通道涵盖了UDP和TCP网络IO以及文件IO

Selector

1.Netty基于Selector对象实现IO多路复用，通过Selector一个线程可以监听多个连接的Channel事件
2.当向一个Selector中注册Channel后，Selector内部的机制就可以自动不断的查询（Select）这些注册的Channel是否有已就绪的IO时间，这样程序就可以很简单地使用一个线程高效的管理多个Channel

ChannelHandler以及实现类

1.是一个接口，处理IO事件或者拦截IO操作，并将其转发到其ChannelPipeline中的下一个处理程序
2.ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类
3.ChannelHandler 及其实现类的图

ChannelInboundHandler 用于处理入站IO事件
ChannelOutboundHandler 处理出站的IO操作
适配器:
ChannelInboundHandlerAdapter 用于处理入站IO事件.
ChannelOutboundHandlerAdapter 用于处理出站IO操作.
ChannelDuplexHandler 用于处理入站和出站事件.
ChannelPipeline 提供了ChannelHandler链的容器，以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出站的，即客户端发送给服务器的数据会通过pipeline中的一系列ChannelOutboundHandler，并被这些Handler处理，反之则成为入站
4.我们经常需要自定义handler类取继承 ChannelInboundHandlerAdapter，然后通过重写相应的方法实现业务逻辑，我们接下来看看一般都需要重写哪些方法:
channelActive 通道就绪事件
channelRead 通道读取事件
channelReadComplete 数据读取完毕事件.

Pipeline 和 ChannelPipeline

ChannelPipeline是一个重点:
1.ChannelPipeline 是一个handler的集合，它负责处理和拦截 inbound 或者outbound 的时间和操作，相当于一个贯穿netty的链。
2. ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及Channel中各个的 ChannelHandler如何相互交互。
3. 在netty中，每个Channel都有且仅有一个ChannelPipeline 与之对应，它们的组成关系如下:
一个Channel包含了一个Channelpipeline，而Channnel中维护了一个由ChannelHandlerContext组成的双向链表，并且每个ChannelHandlerContext中又关联着一个ChannelHandler。
入站事件和出站事件在一个双向链表中，入站事件会从链表head往后传递到最后一个入站的handler，出站事件会从链表tail往前传递到最前一个出站的handler，两种类型的handler互不干扰。
关系图如下:

4.常用方法:
ChannelPipeline addFirst（ChannelHandler…handlers），把一个业务处理类添加到链中的第一个位置。
addLast（ChannelHandler…handlers）,把一个业务处理类添加到链中的最后一个位置。

ChannelHandlerContext

1.保存Channel相关的所有上下文信息，同时关联一个Channel对象
2.即ChannelHandlerContext 中包含一个具体的事件处理器 ChannelHandler，同时 ChannelHandlerContextv中也绑定了对应的 pipeline 和 channel信息，方便对 channelHandler 进行调用
3. 常用方法
ChannelFuture close（） 关闭通道
==ChannelOutboundInvoker flush（）==刷新
==ChannelFuture writeAndFlush() ==将数据写到ChannelPipeline中当前ChannelHandler 的下一个ChannelHandler 开始处理(出站)

ChannelOption

1.Netty 在创建 Channel实例后，一般都需要设置ChannelOption参数
ChannelOption.SO_BACKLOG
对应TCP/IP歇息listen 函数中的backlog参数，用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接，多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog参数指定了队列的大小
ChannelOption.SO_KEEPALIVE
一直保持连接活动状态

EventLoopGroup 和其实现类NioEventLoopGroup

1 . EventLoopGroup 是一组 EventLoop 的抽象，Netty为了更好的利用多核CPU资源，一般会有多个EventLoop 同时工作，每个EventLoop维护着一个Selector实例。
2. EventLoopGroup 提供next接口，可以从组里面按照一定规则获取其中一个EventLoop来处理任务，在netty服务器编程中，我们一般都需要提供两个EventLoopGroup，例如：BossEventLoopGroup,WorkerEventLoopGroup
3. 通常一个服务器端口即一个 ServerSocketChannel对应一个Selector和一个EventLoop线程。BossEventLoop负责接收客户端的连接并将 SocketChannel 交给WorkerEventLoopGroup 来进行IO处理。
BossEventLoopGroup 通常是一个单线程的 EventLoop，EventLoop维护着一个注册了 SeverSocketChannel的Selector 实例 BossEventLoop 不断轮询 Selector 将连接事件分离出来。
通常是OP_ACCEPT事件，然后将接收到的SocketChannel交给WorkerEventLoopGroup
WorkerEventLoopGroup 会由next 选择其中一个个 EventLoopGroup 来将这个 SocketChannel注册到其维护的selector 并对其后续的IO事件进行处理
4.常用方法:
Future<?> shutdownGracefully 断开连接，关闭线程。

Unpooled类

1 . Netty 提供一个专门用来操作缓冲区(即Netty的数据容器)的工具类
2 . 常用方法如下：
==static ByteBuf copiedBuffer(CharSequence string, Charset charset) == 通过给定的数据和字符编码返回一个ByteBuf对象（类似于NIO中的ByteBuffer，但有区别）

ByteBuf

ByteBuf 里维护着readerIndex和writeIndex，当往byteBuf里添加数据的时候，writeIndex的值就会加一