分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow

也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

               

sigh，寫這篇部落格的時候老臉還是紅了一下，心裡還是有些唏噓的，應該算是剽竊吧，每個人的程式碼功力的確是有差距的，好在文章的標題是“一起學”，而不是開濤大神的“跟我學”系列的文章，我們還是多花點時間學習吧，感嘆無用~

最近工作比較忙，但閒暇之餘還是看了阿里的馮家春（fengjiachun）的github上的開原始碼Jupiter，寫的RPC框架讓我感嘆人外有人，廢話不多說，下面的程式碼全部擷取自Jupiter，寫了一個比較完整的例子，供大家一起學習分享，再次對@Luca抱拳，Jupiter的Github地址：

https://github.com/fengjiachun/Jupiter

今天研究的是，心跳和重連，雖然這次是大神寫的程式碼，但是萬變不離其宗，我們先回顧一下Netty應用心跳和重連的整個過程：

1）客戶端連線服務端

2）在客戶端的的ChannelPipeline中加入一個比較特殊的IdleStateHandler，設定一下客戶端的寫空閒時間，例如5s

3）當客戶端的所有ChannelHandler中4s內沒有write事件，則會觸發userEventTriggered方法（上文介紹過）

4）我們在客戶端的userEventTriggered中對應的觸發事件下發送一個心跳包給服務端，檢測服務端是否還存活，防止服務端已經宕機，客戶端還不知道

5）同樣，服務端要對心跳包做出響應，其實給客戶端最好的回覆就是“不回覆”，這樣可以服務端的壓力，假如有10w個空閒Idle的連線，那麼服務端光傳送心跳回復，則也是費事的事情，那麼怎麼才能告訴客戶端它還活著呢，其實很簡單，因為5s服務端都會收到來自客戶端的心跳資訊，那麼如果10秒內收不到，服務端可以認為客戶端掛了，可以close鏈路

6）加入服務端因為什麼因素導致宕機的話，就會關閉所有的鏈路連結，所以作為客戶端要做的事情就是短線重連

以上描述的就是整個心跳和重連的整個過程，雖然很簡單，上一篇blog也寫了一個Demo,簡單地做了一下上述功能

要寫工業級的Netty心跳重連的程式碼，需要解決一下幾個問題：

1）ChannelPipeline中的ChannelHandlers的維護，首次連線和重連都需要對ChannelHandlers進行管理

2）重連物件的管理，也就是bootstrap物件的管理

3）重連機制編寫

完整的程式碼：https://github.com/BazingaLyn/netty-study/tree/master/src/main/java/com/lyncc/netty/idle

下面我們就看大神是如何解決這些問題的，首先先定義一個介面ChannelHandlerHolder，用來保管ChannelPipeline中的Handlers的

[java]  view plain  copy  

1. package com.lyncc.netty.idle;  
2.   
3. import io.netty.channel.ChannelHandler;  
4.   
5. /** 
6.  *  
7.  * 客戶端的ChannelHandler集合，由子類實現，這樣做的好處： 
8.  * 繼承這個介面的所有子類可以很方便地獲取ChannelPipeline中的Handlers 
9.  * 獲取到handlers之後方便ChannelPipeline中的handler的初始化和在重連的時候也能很方便 
10.  * 地獲取所有的handlers 
11.  */  
12. public interface ChannelHandlerHolder {  
13.   
14.     ChannelHandler[] handlers();  
15. }  

我們再來編寫我們熟悉的服務端的ServerBootstrap的編寫：

HeartBeatServer.java

[java]  view plain  copy  

1. package com.lyncc.netty.idle;  
2.   
3. import io.netty.bootstrap.ServerBootstrap;  
4. import io.netty.channel.ChannelFuture;  
5. import io.netty.channel.ChannelInitializer;  
6. import io.netty.channel.ChannelOption;  
7. import io.netty.channel.EventLoopGroup;  
8. import io.netty.channel.nio.NioEventLoopGroup;  
9. import io.netty.channel.socket.SocketChannel;  
10. import io.netty.channel.socket.nio.NioServerSocketChannel;  
11. import io.netty.handler.codec.string.StringDecoder;  
12. import io.netty.handler.codec.string.StringEncoder;  
13. import io.netty.handler.logging.LogLevel;  
14. import io.netty.handler.logging.LoggingHandler;  
15. import io.netty.handler.timeout.IdleStateHandler;  
16.   
17. import java.net.InetSocketAddress;  
18. import java.util.concurrent.TimeUnit;  
19.   
20. public class HeartBeatServer {  
21.       
22.     private final AcceptorIdleStateTrigger idleStateTrigger = new AcceptorIdleStateTrigger();  
23.       
24.     private int port;  
25.   
26.     public HeartBeatServer(int port) {  
27.         this.port = port;  
28.     }  
29.   
30.     public void start() {  
31.         EventLoopGroup bossGroup = new NioEventLoopGroup(1);  
32.         EventLoopGroup workerGroup = new NioEventLoopGroup();  
33.         try {  
34.             ServerBootstrap sbs = new ServerBootstrap().group(bossGroup, workerGroup)  
35.                     .channel(NioServerSocketChannel.class).handler(new LoggingHandler(LogLevel.INFO))  
36.                     .localAddress(new InetSocketAddress(port)).childHandler(new ChannelInitializer<SocketChannel>() {  
37.                         protected void initChannel(SocketChannel ch) throws Exception {  
38.                             ch.pipeline().addLast(new IdleStateHandler(5, 0, 0, TimeUnit.SECONDS));  
39.                             ch.pipeline().addLast(idleStateTrigger);  
40.                             ch.pipeline().addLast("decoder", new StringDecoder());  
41.                             ch.pipeline().addLast("encoder", new StringEncoder());  
42.                             ch.pipeline().addLast(new HeartBeatServerHandler());  
43.                         };  
44.   
45.                     }).option(ChannelOption.SO_BACKLOG, 128).childOption(ChannelOption.SO_KEEPALIVE, true);  
46.             // 繫結埠，開始接收進來的連線  
47.             ChannelFuture future = sbs.bind(port).sync();  
48.   
49.             System.out.println("Server start listen at " + port);  
50.             future.channel().closeFuture().sync();  
51.         } catch (Exception e) {  
52.             bossGroup.shutdownGracefully();  
53.             workerGroup.shutdownGracefully();  
54.         }  
55.     }  
56.   
57.     public static void main(String[] args) throws Exception {  
58.         int port;  
59.         if (args.length > 0) {  
60.             port = Integer.parseInt(args[0]);  
61.         } else {  
62.             port = 8080;  
63.         }  
64.         new HeartBeatServer(port).start();  
65.     }  
66.   
67. }  

單獨寫一個AcceptorIdleStateTrigger，其實也是繼承ChannelInboundHandlerAdapter，重寫userEventTriggered方法，因為客戶端是write，那麼服務端自然是read，設定的狀態就是IdleState.READER_IDLE，原始碼如下：

[java]  view plain  copy  

1. package com.lyncc.netty.idle;  
2.   
3. import io.netty.channel.ChannelHandler;  
4. import io.netty.channel.ChannelHandlerContext;  
5. import io.netty.channel.ChannelInboundHandlerAdapter;  
6. import io.netty.handler.timeout.IdleState;  
7. import io.netty.handler.timeout.IdleStateEvent;  
8.   
9.   
10. @ChannelHandler.Sharable  
11. public class AcceptorIdleStateTrigger extends ChannelInboundHandlerAdapter {  
12.   
13.     @Override  
14.     public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {  
15.         if (evt instanceof IdleStateEvent) {  
16.             IdleState state = ((IdleStateEvent) evt).state();  
17.             if (state == IdleState.READER_IDLE) {  
18.                 throw new Exception("idle exception");