一、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();
}
}
- DiscardServerHandler 继承了 ChannelInboundHandlerAdapter
- ChannelInboundHandlerAdapter提供了供我们重写的各种各样的事件处理方法
现在我们只需要继承ChannelInboundHandlerAdapter就可以了，而不是我们自己 去实现handler接口
重写 channelRead()方法，无论何时从客户端接收到新的数据的时候，此方法都会被调用。在当前的示例下，接收消息的类型是ByteBuf
为了实现DISCARD协议，我们在channelRead()方法中忽略了接收到的数据。ByteBuf
通过调用release()方法进行了释放操作。
通常情况下channelRead()方法是按照以下的方式来实现的
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
try {
// Do something with msg
} finally {
ReferenceCountUtil.release(msg);
}
}
- 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<SocketChannel>() { // (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();
}
}
NioEventLoopGroup
是一个多线程事件循环处理的I/O操作。Netty提供了各种各样的EventLoopGroup
来实现不同类型的传输。
在这里我们实现了服务器方面的应用，因此将会使用两个EventLoopGroup。
第一个，我们称作为'boss'，接收进来的连接
第二个，我们称作为'worker,'一旦boss接受了这个连接并把该连接注册到了worker之后，就处理接受到的传输连接。
有多个线程被使用，并且它们怎样映射到创建的Channel
s，依赖于EventLoopGroup的实现，并且可以通过构造来对它进行配置ServerBootstrap
是建立服务器的一个帮助类。我们可以使用Channel直接的设置这个服务器。 然后，请注意这是一个枯燥的过程，并且在大多数情况下你不需要这么做。这里我们指定使用NioServerSocketChannel
类去实例化一个新的Channel，来接收进来的连接。这里指定的处理者总是评估新接受的Channel。ChannelInitializer
是一个指定的处理者，去帮助用户配置一个新的Channel。
这是最有可能的，我们想要去配置ChannelPipeline关于新的Channel，通过添加处理者，列如DiscardServerHandler 来实现我们的网络应用程序。
当应用程序变得复杂的时候，很有可能我们将添加更多的管道处理器，最终这个匿名类(ChannelInitializer)会被提取成为一个顶级类。我们也可以在Channel 实现的时候指定一些参数。
当前我们正在写一个TCP/IP服务器，因此我们可以设置一些socket的可选参数。
列如tcpNoDelay和keepAlive。
6.你注意到option()和childOptionl了么？
option()是关于NioServerSocketChannel
接受进来的连接的。
childOption()是关于Channel
s被接受通过这个父类的 ServerChannel
在当前情况下是 NioServerSocketChannel
。
7.剩下的就是我们绑定端口开启这个服务器了。这里我们默认绑定所有网卡的8080端口在这台机器上，你现在也可以调用多次bind()方法，来绑定不同的地址
作为以上的步骤，我们就结束了使用Netty完成的第一个服务器
