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

最新推荐文章于 2021-11-08 17:31:56 发布

a8892117

最新推荐文章于 2021-11-08 17:31:56 发布

阅读量195

点赞数

原文链接：http://www.cnblogs.com/qdhxhz/p/10073367.html

版权

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）

转载于:https://www.cnblogs.com/qdhxhz/p/10073367.html