Netty学习笔记（五）Netty 异步模型，简单实现http服务

Netty学习笔记（五）Netty 异步模型，简单实现http服务

Netty handle异步处理

当处理工作handler中有特别耗时间的任务，如果继续，则会造成任务的阻塞
可以使用异步处理，将任务提交到该channel对应的NioEventLoop的taskQueue任务执行队列中去异步执行

解决思路1：
用户程序自定义的普通任务（可加多个，按添加顺序依次执行（在同一个线程中））

解决思路2：
用户自定义定时提交任务，该任务是添加到scheduleTaskQueue中执行的

解决思路3：
非当前 Reactor 线程调用 Channel 的各种方法（根据用户标识，获取不同对应channel，调用添加至其对应的消息队列中执行）
将用户channel信息存储管理起来，在handle中得到对应channel，将任务放入对应channel的taskQueue或scheduleTaskQueue中

Netty模型总结再说明：

Netty 异步模型

基本介绍

1. 异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的组件在完成后，通过状态、通知和回调来通知调用者。
2. Netty 中的 I/O 操作是异步的，包括 Bind、Write、Connect 等操作会简单的返回一个 ChannelFuture。
3. 调用者并不能立刻获得结果，而是通过 Future-Listener 机制，用户可以方便的主动获取或者通过通知机制获得 IO 操作结果
4. Netty 的异步模型是建立在 future 和 callback 的之上的。callback 就是回调。重点说 Future，它的核心思想是：假设一个方法 fun，计算过程可能非常耗时，等待 fun返回显然不合适。那么可以在调用 fun 的时候，立马返回一个 Future，后续可以通过 Future去监控方法 fun 的处理过程(即 ： Future-Listener 机制)

Future 说明

5. 表示异步的执行结果, 可以通过它提供的方法来检测执行是否完成，比如检索计算等等.
6. ChannelFuture 是一个接口 ： public interface ChannelFuture extends Future我们可以添加监听器，当监听的事件发生时，就会通知到监听器.

链式操作示意图

在每一个handler里面都可以使用异步通信的方法返回一个监听结果（处理结果）

Future-Listener 机制

1. 当 Future 对象刚刚创建时，处于非完成状态，调用者可以通过返回的 ChannelFuture 来获取操作执行的状态，注册监听函数来执行完成后的操作。
2. 常见有如下操作

通过 isDone 方法来判断当前操作是否完成；
通过 isSuccess 方法来判断已完成的当前操作是否成功；
通过 getCause 方法来获取已完成的当前操作失败的原因；
通过 isCancelled 方法来判断已完成的当前操作是否被取消；
通过 addListener 方法来注册监听器，当操作已完成(isDone 方法返回完成)，将会通知指定的监听器；如果 Future 对象已完成，则通知指定的监听器

举例：
绑定端口是异步操作，当绑定操作处理完，将会调用相应的监听器处理逻辑

serverBootstrap.bind(port).addListener(future -> {
       if(future.isSuccess()) {
           System.out.println(newDate() + ": 端口["+ port + "]绑定成功!");
       } else{
           System.err.println("端口["+ port + "]绑定失败!");
       }
   });

相比传统阻塞 I/O，执行 I/O 操作后线程会被阻塞住, 直到操作完成；异步处理的好处是不会造成线程阻塞，线程在 I/O 操作期间可以执行别的程序，在高并发情形下会更稳定和更高的吞吐量。

netty简单实现http服务

package com.ywb.javaroad.netty.http;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @Author yangwen-bo
 * Netty 服务器在 1234 端口监听，浏览器发出请求 "http://localhost:1234/ "
 * 服务器可以回复消息给客户端 "我是服务器 " ,  并对特定请求资源进行过滤.
 *
 * 目的：Netty 可以做Http服务开发，并且理解Handler实例和客户端及其请求的关系
 */
public class TestHttpServer {
    public static void main(String[] args) {
        EventLoopGroup boosGroup = new NioEventLoopGroup( 1 );
        EventLoopGroup workerGroup = new NioEventLoopGroup( );

        try {
            //创建服务器启动对象
            //创建服务器端启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();

            bootstrap.group(boosGroup,workerGroup)//设置两个线程组
            .channel( NioServerSocketChannel.class )
                    .childHandler( new TestHttpInitializer() );

            ChannelFuture channelFuture = bootstrap.bind( 1234 ).sync();
            //对关闭通道进行监听
            //closeFuture当通道有关闭事件的时候，才会调用处理
            channelFuture.channel().closeFuture().sync();


        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            boosGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

package com.ywb.javaroad.netty.http;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;

import java.net.URI;

/**
 * @Author yangwen-bo
 *
 * 之前使用的是ChannelInboundHandlerAdapter
 * 这次使用SimpleChannelInboundHandler
 * ChannelInboundHandlerAdapter是ChannelInboundHandler一个简单实现，默认情况下不会做任何处理。
 * 只是简单的将操作通过fire*方法传到ChannelPipeline中的下一个ChannelHandler中让链中的下一个ChannelHandler去处理。
 * 但是需要注意的是信息经过channelRead方法处理之后不会自动释放(是因为信息不会被自动释放所以能将信息传给
 * 下一个ChannelHandler处理。)
 *
 * SimpleChannelInboundHandler支持泛型的消息处理，默认情况下消息处理完之后将会自动释放，
 * 无法提供fire*方法传递给ChannelPipeline中的下一个ChannelHandler，如果想要传递给
 * 下一个ChannelHandler需要调用ReferenceCountUtil#retain方法。
 * 继承使用此类的话需要实现 channelRead0方法
 *
 * 在Netty中客户端的Handler一般继承SimpleChannelInboundHandler抽象类，
 * 服务端Handler一般继承ChannelInboundHandlerAdapter抽象类
 *
 * HttpObject：客户端与服务器通讯的数据（被封装成的）类型
 */
public class TestHttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {

    //当有读取事件发生时，触发，读取客户端数据
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
        // 判断msg是不是httprequest请求
        if(msg instanceof HttpRequest){
            // 浏览器访问会有两次请求：
            // 一个是请求localhost到服务器一个，还有一个是浏览器请求得到一些图标信息
            // 可以根据msg的uri来进行过滤，只处理localhost一次的请求
            HttpRequest httpRequest = (HttpRequest) msg;
            URI uri = new URI( httpRequest.uri() );
            if("favicon.ico".equals( uri.getPath() )){
                System.out.println("请求路径为 ，不做处理");
                return;
            }


            System.out.println("msg的类型为："+msg.getClass());
            System.out.println("客户端地址为："+ctx.channel().remoteAddress());

            // 回复信息给客户端（浏览器）,构造http响应
            ByteBuf content = Unpooled.copiedBuffer( "我是服务器", CharsetUtil.UTF_8 );
            // 协议版本，状态码200，返回内容
            DefaultFullHttpResponse httpResponse = new DefaultFullHttpResponse( HttpVersion.HTTP_1_1, HttpResponseStatus.OK,content );
            // 设置返回头 数据类型,长度
            httpResponse.headers().set( HttpHeaderNames.CONTENT_TYPE,"text/plain" );
            httpResponse.headers().set( HttpHeaderNames.CONTENT_LENGTH,content.readableBytes() );

            // 将构建好的response对象返回
            ctx.writeAndFlush( httpResponse );
        }
    }

}

package com.ywb.javaroad.netty.http;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;

/**
 * @Author yangwen-bo
 *
 * 原先simplenetty中使用 new ChannelInitializer<SocketChannel>() {//创建一个通道初始化对象
 *                 //给pipeline设置处理器
 *                 @Override
 *                 protected void initChannel(SocketChannel ch) throws Exception {//创建一个通道测试对象
 *                     //给pipeline 设置处理器
 *                     ch.pipeline().addLast( new NettyServerHandler() );
 *                 }
 *             }
 *  现在单独提取出来
 *
 */
public class TestHttpInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        //向管道加入处理器

        //获取管道
        ChannelPipeline pipeline = ch.pipeline();
        //给管道加netty提供的编解码器 命名为MyHttpServerCodec
        //HttpServerCodec是netty提供的处理http的编码解码器
        pipeline.addLast( "MyHttpServerCodec",new HttpServerCodec() );
        // 加自定义handler
        pipeline.addLast( "MyHttpServerHandler",new TestHttpServerHandler() );

    }
}