Netty实战(一) Discard服务器

一、Discard协议介绍

Discard协议是这个世界上最简单的协议。它是一个会丢弃，从客户端接收到的所有数据，并没有任何响应的协议。

想要实现DISCARD协议，我们只需要做一件事情，那就是忽略所有接收到的数据。

二、编码实战

2.1使用Netty来实现处理I/O事件

package io.netty.example.discard;

import io.netty.buffer.ByteBuf;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * Handles a server-side channel.
 */
public class DiscardServerHandler extends ChannelInboundHandlerAdapter { // (1)

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) { // (2)
        // Discard the received data silently.
        ((ByteBuf) msg).release(); // (3)
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { // (4)
        // Close the connection when an exception is raised.
        cause.printStackTrace();
        ctx.close();
    }
}

1. DiscardServerHandler 继承了 ChannelInboundHandlerAdapter
   

• ChannelInboundHandlerAdapter提供了供我们重写的各种各样的事件处理方法
  现在我们只需要继承ChannelInboundHandlerAdapter就可以了，而不是我们自己 去实现handler接口

2. 重写 channelRead()方法，无论何时从客户端接收到新的数据的时候，此方法都会被调用。在当前的示例下，接收消息的类型是ByteBuf
   

3. 为了实现DISCARD协议，我们在channelRead()方法中忽略了接收到的数据。ByteBuf
   通过调用release()方法进行了释放操作。
   通常情况下channelRead()方法是按照以下的方式来实现的

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    try {
        // Do something with msg
    } finally {
        ReferenceCountUtil.release(msg);
    }
}

4. exceptionCaught()方法，通常由Netty所产生的一个I/O错误，或处理者在处理事件的时候抛出一个异常的时候被调用。
   在大多数情况下，这个异常捕获应该记录到日志中，并且在这里关闭和异常相关的channel。
   举例，我们可以在关闭连接前发送一个错误响应代码。

2.2 写一个DiscardServer并在main()方法中调用

package io.netty.example.discard;
    
import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
    
/**
 * Discards any incoming data.
 */
public class DiscardServer {
    
    private int port;
    
    public DiscardServer(int port) {
        this.port = port;
    }
    
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap(); // (2)
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class) // (3)
             .childHandler(new ChannelInitializer() { // (4)
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ch.pipeline().addLast(new DiscardServerHandler());
                 }
             })
             .option(ChannelOption.SO_BACKLOG, 128)          // (5)
             .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)
    
            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(port).sync(); // (7)
    
            // Wait until the server socket is closed.
            // In this example, this does not happen, but you can do that to gracefully
            // shut down your server.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new DiscardServer(port).run();
    }
}

1. NioEventLoopGroup
   是一个多线程事件循环处理的I/O操作。Netty提供了各种各样的EventLoopGroup
   来实现不同类型的传输。
   在这里我们实现了服务器方面的应用，因此将会使用两个EventLoopGroup。
   第一个，我们称作为'boss'，接收进来的连接
   第二个，我们称作为'worker,'一旦boss接受了这个连接并把该连接注册到了worker之后，就处理接受到的传输连接。
   有多个线程被使用，并且它们怎样映射到创建的Channel
   s，依赖于EventLoopGroup的实现，并且可以通过构造来对它进行配置

2. ServerBootstrap
   是建立服务器的一个帮助类。我们可以使用Channel直接的设置这个服务器。 然后，请注意这是一个枯燥的过程，并且在大多数情况下你不需要这么做。

3. 这里我们指定使用NioServerSocketChannel
   类去实例化一个新的Channel，来接收进来的连接。

4. 这里指定的处理者总是评估新接受的Channel。ChannelInitializer
   是一个指定的处理者，去帮助用户配置一个新的Channel。
   这是最有可能的，我们想要去配置ChannelPipeline关于新的Channel，通过添加处理者，列如DiscardServerHandler 来实现我们的网络应用程序。
   当应用程序变得复杂的时候，很有可能我们将添加更多的管道处理器，最终这个匿名类(ChannelInitializer)会被提取成为一个顶级类。

5. 我们也可以在Channel 实现的时候指定一些参数。
   当前我们正在写一个TCP/IP服务器，因此我们可以设置一些socket的可选参数。
   列如tcpNoDelay和keepAlive。

6.你注意到option()和childOptionl了么？
option()是关于NioServerSocketChannel
接受进来的连接的。
childOption()是关于Channel
s被接受通过这个父类的 ServerChannel

在当前情况下是 NioServerSocketChannel
。

7.剩下的就是我们绑定端口开启这个服务器了。这里我们默认绑定所有网卡的8080端口在这台机器上，你现在也可以调用多次bind()方法，来绑定不同的地址

作为以上的步骤，我们就结束了使用Netty完成的第一个服务器