netty(2)---搭建一个简单服务器

说明:本篇博客是基于学习慕课网有关视频教学。效果:当用户访问:localhost:8088 后 服务器返回 “hello netty”;

一、服务端线程模型

下面的做法是服务端监听线程和 IO 线程分离，类似于 Reactor 的多线程模型，它的工作原理图如下(盗的图）：



这里netty版本是4.1.25

    <dependency>

            <groupId>io.netty</groupId>

            <artifactId>netty-all</artifactId>

            <version>4.1.25.Final</version>

    </dependency>

二、主程序类

/**

 * @Description: 实现客户端发送一个请求，服务器会返回 hello netty

 */

public class HelloServer {

    public static void main(String[] args) throws Exception {

        // 定义一对线程组

        // 主线程组, 用于接受客户端的连接，但是不做任何处理，跟老板一样，不做事

        EventLoopGroup bossGroup = new NioEventLoopGroup();

        // 从线程组, 老板线程组会把任务丢给他，让手下线程组去做任务

        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {

            // netty服务器的创建, 辅助工具类，用于服务器通道的一系列配置

            ServerBootstrap serverBootstrap = new ServerBootstrap();

            serverBootstrap.group(bossGroup, workerGroup)           //绑定两个线程组

                           .channel(NioServerSocketChannel.class)   //指定NIO的模式

                           .childHandler(new HelloServerInitializer()); // 子处理器，用于处理workerGroup

            // 启动server，并且设置8088为启动的端口号，同时启动方式为同步

            ChannelFuture channelFuture = serverBootstrap.bind(8088).sync();

            // 监听关闭的channel，设置位同步方式

            channelFuture.channel().closeFuture().sync();

        } finally {

            //退出线程组

            bossGroup.shutdownGracefully();

            workerGroup.shutdownGracefully();

        }

    }

}

上面这段代码展示了服务端的一个基本步骤：

(1)、 初始化用于Acceptor的主"线程池"以及用于I/O工作的从"线程池"；

(2)、 初始化ServerBootstrap实例， 此实例是netty服务端应用开发的入口；

(3)、 通过ServerBootstrap的group方法，设置（1）中初始化的主从"线程池"；

(4)、 指定通道channel的类型，由于是服务端，故而是NioServerSocketChannel；

(5)、 设置ServerSocketChannel的处理器

(6)、 设置子通道也就是SocketChannel的处理器， 其内部是实际业务开发的"主战场"

(8)、 配置子通道也就是SocketChannel的选项

(9)、 绑定并侦听某个端口

三、子处理器 HelloServerInitializer类

/**

 * @Description: 初始化器，channel注册后，会执行里面的相应的初始化方法

 */

public class HelloServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override

    protected void initChannel(SocketChannel channel) throws Exception {

        // 通过SocketChannel去获得对应的管道

        ChannelPipeline pipeline = channel.pipeline();

        // 通过管道，添加handler

        // HttpServerCodec是由netty自己提供的助手类，可以理解为拦截器

        // 当请求到服务端，我们需要做解码，响应到客户端做编码

        pipeline.addLast("HttpServerCodec", new HttpServerCodec());

        // 添加自定义的助手类，返回 "hello netty~"

        pipeline.addLast("customHandler", new CustomHandler());

    }

}

子处理器也可以通过内部方法来实现的。

b.group(group).channel(NioServerSocketChannel.class)

              .childHandler(new ChannelInitializer<SocketChannel>() {

                @Override

                protected void initChannel(SocketChannel socketChannel) throws Exception {

                    //这里进行方法实现.......

                    socketChannel.pipeline().addLast(serverHandler);

                }

            });

四、自定义助手类 CustomHandler类

/**

 * 创建自定义助手类

 */

// SimpleChannelInboundHandler: 对于请求来讲，其实相当于[入站，入境]

public class CustomHandler extends SimpleChannelInboundHandler<HttpObject> {

    @Override

    protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg)

            throws Exception {

        // 获取channel

        Channel channel = ctx.channel();

        if (msg instanceof HttpRequest) {

            // 显示客户端的远程地址

            System.out.println(channel.remoteAddress());

            // 定义发送的数据消息

            ByteBuf content = Unpooled.copiedBuffer("Hello netty~", CharsetUtil.UTF_8);

            // 构建一个http response

            FullHttpResponse response =

                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,

                            HttpResponseStatus.OK,

                            content);

            // 为响应增加数据类型和长度

            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");

            response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());

            // 把响应刷到客户端

            ctx.writeAndFlush(response);

        }

    }

    /**

     * 上面的方法是必须重写的,因为是父类定义的抽象方法。

     *

     * 下面的方法是一些 助手类的执行顺序

     */

    @Override

    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {

        System.out.println("channel。。。注册");

        super.channelRegistered(ctx);

    }

    @Override

    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {

        System.out.println("channel。。。移除");

        super.channelUnregistered(ctx);

    }

    @Override

    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        System.out.println("channel。。。活跃");

        super.channelActive(ctx);

    }

    @Override

    public void channelInactive(ChannelHandlerContext ctx) throws Exception {

        System.out.println("channel。。。不活跃");

        super.channelInactive(ctx);

    }

    @Override

    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

        System.out.println("channeld读取完毕。。。");

        super.channelReadComplete(ctx);

    }

    @Override

    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

        System.out.println("用户事件触发。。。");

        super.userEventTriggered(ctx, evt);

    }

    @Override

    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {

        System.out.println("channel可写更改");

        super.channelWritabilityChanged(ctx);

    }

    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

        System.out.println("补货到异常");

        super.exceptionCaught(ctx, cause);

    }

    @Override

    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {

System.out.println("助手类添加");

        super.handlerAdded(ctx);

    }

    @Override

    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {

        System.out.println("助手类移除");

        super.handlerRemoved(ctx);

    }

}

##五、启动主类 进行测试

后台完整输出

六、客户端线程模型

相比于服务端，客户端的线程模型简单一些，它的工作原理如下：

代码如下

  EventLoopGroup group = new NioEventLoopGroup();

         try {

             Bootstrap b = new Bootstrap();

             b.group(group) // 注册线程池

              .channel(NioSocketChannel.class) // 使用NioSocketChannel来作为连接用的channel类

              .remoteAddress(new InetSocketAddress(this.host, this.port)) // 绑定连接端口和host信息

              .handler(new ChannelInitializer<SocketChannel>() { // 绑定连接初始化器

                        @Override

                        protected void initChannel(SocketChannel ch) throws Exception {

                                     //这里放入自定义助手类

                                     ch.pipeline().addLast(new EchoClientHandler());

                                 }

                             });

             ChannelFuture cf = b.connect().sync(); // 异步连接服务器

             cf.channel().closeFuture().sync(); // 异步等待关闭连接channel

         } finally {

             group.shutdownGracefully().sync(); // 释放线程池资源

         }

     }

客户端的开发步骤和服务端都差不多：

(1)、 初始化用于连接及I/O工作的"线程池"；

(2)、 初始化`Bootstrap`实例， 此实例是netty客户端应用开发的入口；

(3)、 通过Bootstrap的group方法，设置（1）中初始化的"线程池"；

(4)、 指定通道channel的类型，由于是客户端，故而是`NioSocketChannel`；

(5)、 设置SocketChannel的选项；

(6)、 设置SocketChannel的处理器， 其内部是实际业务开发的"主战场"；

(7)、 连接指定的服务地址；

相比于服务端很明显的区别在于

（1），客户端只需要创建一个 EventLoopGroup，因为它不需要独立的线程去监听客户端连接，也没必要通过一个单独的客户端线程去连接服务端。Netty 是异步事件驱动的 NIO 框架，它的连接和所有 IO 操作都是异步的，因此不需要创建单独的连接线程。

（2）服务端引导类ServerBootstrap,而客户端引导是Bootstrap进行开发的，不过它们都需要通过group属性指定EventLoopGroup， 因为是开发NIO程序，所以我们选择NioEventLoopGroup。

如果一个人充满快乐，正面的思想，那么好的人事物就会和他共鸣，而且被他吸引过来。同样，一个人老带悲伤，倒霉的事情也会跟过来。

                                                      ——在自己心情低落的时候，告诫自己不要把负能量带给别人。（大校11）