Netty编码实战与Channel生命周期
本次将搭建一个最简单的Hello Netty服务器，并且通过这个简单的示例了解了Channel的生命周期。最后将基于Netty搭建一个Websocket网页聊天小程序，可以使用户在Web浏览器或者移动端浏览器进行消息的收发，来深入体会一下使用Netty编码NIO服务器是多么便捷。
Hello Netty服务器
- 构建一对主从线程组
- 定义服务器启动类
- 为服务器设置Channel
- 设置处理从线程池的助手类初始化器
- 监听启动和关闭服务器
1、构建主从线程组与服务启动类
首先新建一个Maven工程，引入Netty的依赖，我引入的依赖如下：
1<dependencies>
2 <dependency>
3 <groupId>io.netty</groupId>
4 <artifactId>netty-all</artifactId>
5 <version>4.1.50.Final</version>
6 </dependency>
7</dependencies>
2、设置Channel初始化器
每一个channel由多个handler共同组成管道(pipeline)
3、开始编写自定义的助手类
然后接下来启动服务器，通过Postman访问一下http://localhost:8080得到如下结果：
如果直接在浏览器端访问的话会打印两次客户端远程地址，因为浏览器默认还访问了http://localhost:8080/favicon.ico，或者使用在Linux环境下使用curl进行测试也是可以的。
探究Channel生命周期
我们通过重写下图所示的方法来研究一下Channel的生命周期（IDEA快捷键 Ctrl + O）：
重写完成之后的CustomHandler如下：
1public class CustomHandler extends SimpleChannelInboundHandler<HttpObject> {
2 protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
3 // 获取Channel
4 Channel channel = ctx.channel();
5 if(msg instanceof HttpRequest) {
6 // 显示客户端的远程地址
7 System.out.println(channel.remoteAddress());
8 // 数据Copy至缓冲区(定义发送的数据消息)
9 ByteBuf content = Unpooled.copiedBuffer("<h1>Hello Netty</h1>", CharsetUtil.UTF_8);
10 // 构建一个Http Response
11 FullHttpResponse response = new DefaultFullHttpResponse(
12 HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);
13 // 为响应增加一个数据类型和长度
14 response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text.plain");
15 response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
16 // 把响应刷到客户端
17 ctx.writeAndFlush(response);
18 }
19 }
20
21 @Override
22 public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
23 System.out.println("Channel-注册");
24 super.channelRegistered(ctx);
25 }
26
27 @Override
28 public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
29 System.out.println("Channel-移除");
30 super.channelUnregistered(ctx);
31 }
32
33 @Override
34 public void channelActive(ChannelHandlerContext ctx) throws Exception {
35 System.out.println("Channel-活跃");
36 super.channelActive(ctx);
37 }
38
39 @Override
40 public void channelInactive(ChannelHandlerContext ctx) throws Exception {
41 System.out.println("Channel-不活跃（断开了）");
42 super.channelInactive(ctx);
43 }
44
45 @Override
46 public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
47 System.out.println("Channel-读取数据完毕");
48 super.channelReadComplete(ctx);
49 }
50
51 @Override
52 public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
53 System.out.println("用户事件触发");
54 super.userEventTriggered(ctx, evt);
55 }
56
57 @Override
58 public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
59 System.out.println("Channel-可写更改");
60 super.channelWritabilityChanged(ctx);
61 }
62
63 @Override
64 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
65 System.out.println("捕获到异常");
66 super.exceptionCaught(ctx, cause);
67 }
68
69 @Override
70 public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
71 System.out.println("助手类添加");
72 super.handlerAdded(ctx);
73 }
74
75 @Override
76 public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
77 System.out.println("助手类移除");
78 super.handlerRemoved(ctx);
79 }
80}
通过Curl访问控制台打印如下：
为什么要用CURL而不是浏览器或者PostMan呢？因为我们使用了HTTP1.1的版本，支持长连接，而且默认是开启状态，所以看不到Channel不活跃断开的状态，所以才使用CURL来访问。
网页版的WebSocket聊天室
1、Netty 服务器编码
Netty 服务器启动类WSServe.java如下：
1import io.netty.bootstrap.ServerBootstrap;
2import io.netty.channel.ChannelFuture;
3import io.netty.channel.EventLoopGroup;
4import io.netty.channel.nio.NioEventLoopGroup;
5import io.netty.channel.socket.nio.NioServerSocketChannel;
6
7public class WSServer {
8 public static void main(String[] args) throws Exception {
9 EventLoopGroup bossGroup = new NioEventLoopGroup();
10 EventLoopGroup workerGroup = new NioEventLoopGroup();
11
12 try{
13 ServerBootstrap serverBootstrap = new ServerBootstrap();
14 serverBootstrap.group(bossGroup, workerGroup)
15 .channel(NioServerSocketChannel.class)
16 .childHandler(new WSServerInitializer());
17
18 ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
19 channelFuture.channel().closeFuture().sync();
20 } finally {
21 bossGroup.shutdownGracefully();
22 workerGroup.shutdownGracefully();
23 }
24 }
25}
接下来是Channel初始化器WSServerInitializer.java
1import io.netty.channel.ChannelInitializer;
2import io.netty.channel.ChannelPipeline;
3import io.netty.channel.socket.SocketChannel;
4import io.netty.handler.codec.http.HttpObjectAggregator;
5import io.netty.handler.codec.http.HttpServerCodec;
6import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
7import io.netty.handler.stream.ChunkedWriteHandler;
8
9public class WSServerInitializer extends ChannelInitializer<SocketChannel> {
10 @Override
11 protected void initChannel(SocketChannel socketChannel) throws Exception {
12 ChannelPipeline pipeline = socketChannel.pipeline();
13 // WebSocket基于Http协议，添加Http编解码器
14 pipeline.addLast(new HttpServerCodec());
15
16 // 添加对写大数据流的支持
17 pipeline.addLast(new ChunkedWriteHandler());
18
19 // 对Http Message进行聚合，聚合成FullHttpRequest或FullHttpResponse
20 // 几乎在Netty中的编程都会使用到此Handler
21 pipeline.addLast(new HttpObjectAggregator(1024 * 64));
22
23 //-------------------- 以上是用于支持HTTP协议 ----------------------
24
25 // WebSocket服务器处理的协议，并且指定给客户端链接访问的路由
26 // 使用此Handler会直接帮你处理握手动作（Close、Ping、Pong）
27 // 对于WebSocket，都是以帧进行传输的，不同数据对应的帧也不同
28 pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));
29
30 // 自定义的Handler
31 pipeline.addLast(new ChatHandler());
32 }
33}
最后是自定义的Handler，ChatHandler.java
1import io.netty.channel.Channel;
2import io.netty.channel.ChannelHandlerContext;
3import io.netty.channel.SimpleChannelInboundHandler;
4import io.netty.channel.group.ChannelGroup;
5import io.netty.channel.group.DefaultChannelGroup;
6import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
7import io.netty.util.concurrent.GlobalEventExecutor;
8
9import java.time.LocalDateTime;
10
11// 对于WebSocket，都是以帧进行传输的，不同数据对应的帧也不同 -> TextWebSocketFrame
12// TextWebSocketFrame是WebSocket专门用于处理文本的对象，Frame是消息的载体
13public class ChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
14
15 // 用于记录和管理所有客户端的Channel
16 private static ChannelGroup clients = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
17
18 @Override
19 protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
20 // 从客户端获取到的消息内容
21 String content = msg.text();
22 System.out.println("接收到的数据：" + content);
23 String message = "[服务器收到消息] " + LocalDateTime.now() + "消息为:" + content;
24 for(Channel channel: clients){
25 //channel.writeAndFlush(content); ERROR 不能直接传String，而是TextWebSocketFrame载体
26 channel.writeAndFlush(new TextWebSocketFrame(message));
27 }
28
29 // 下面这种方式与For循环一致
30 //clients.writeAndFlush(new TextWebSocketFrame(message));
31 }
32
33
34 @Override
35 public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
36 Channel channel = ctx.channel();
37 // 当客户端打开链接后，获取客户端的Channel并且添加Channel至ChannelGroup中进行管理
38 clients.add(channel);
39 }
40
41 @Override
42 public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
43 // 当触发handlerRemoved,ChannelGroup会自动移除客户端的Channel
44 System.out.println("客户端断开, Channel对应的长ID：" + ctx.channel().id().asLongText());
45 System.out.println("客户端断开, Channel对应的短ID：" + ctx.channel().id().asShortText());
46 }
47}
2、前端JavaScript编码
下面是前端需要用到的WebSocket API：
1<html>
2 <head>
3 <meta charset="utf-8" />
4 <title></title>
5 </head>
6 <body>
7 <div>发送消息</div>
8 <input type="text" id="msgContent"/>
9 <input type="button" onclick="CHAT.chat()" value="发送"/>
10
11 <div>接收消息</div>
12 <div id="receiveMsg" style="background-color: darkturquoise;"></div>
13 <script type="application/javascript">
14 window.CHAT = {
15 socket: null,
16 init: function(){
17 if(window.WebSocket){
18 CHAT.socket = new WebSocket("ws://127.0.0.1:8080/ws");
19 CHAT.socket.onopen = function(){
20 console.log('连接建立成功...');
21 },
22 CHAT.socket.onclose = function(){
23 console.log('连接建立关闭...');
24 },
25 CHAT.socket.onerror = function(){
26 console.log('连接建立发生错误...');
27 },
28 CHAT.socket.onmessage = function(e){
29 console.log('收到消息...' + e.data);
30 var receiveMsg = document.getElementById('receiveMsg');
31 var html = receiveMsg.innerHTML;
32 receiveMsg.innerHTML = html + "<br/>" + e.data;
33 }
34 }else{
35 alert('不支持WebSocket');
36 }
37 },
38 chat: function(){
39 var msg = document.getElementById("msgContent");
40 CHAT.socket.send(msg.value);
41 }
42 }
43 CHAT.init();
44 </script>
45 </body>
46</html>
3、效果展示
Netty编码的小总结
首先是流程，先新建主从线程组，编写启动类，因为Netty官方推荐的模式也是主从线程模型。接下来是编写Channel初始化器，继承自ChannelInitializer，Channel注册后会执行里面的相应的初始化方法，通过Channel获取管道，然后添加需要的Handler，最后添加自己的自定义的Handler来处理请求。