Netty學習(八)-Netty的心跳機制

阿新 • • 發佈：2019-01-18

1. 如何實現心跳機制
一般實現心跳機制由兩種方式：

TCP協議自帶的心跳機制來實現；
在應用層來實現。
但是TCP協議自帶的心跳機制系統預設是設定的是2小時的心跳頻率。它檢查不到機器斷電、網線拔出、防火牆這些斷線。而且邏輯層處理斷線可能也不是那麼好處理。另外該心跳機制是與TCP協議繫結的，那如果我們要是使用UDP協議豈不是用不了？所以一般我們都不用。

而一般我們自己實現呢大致的策略是這樣的：

Client啟動一個定時器，不斷髮送心跳；
Server收到心跳後，做出迴應；
Server啟動一個定時器，判斷Client是否存在，這裡做判斷有兩種方法：時間差和簡單標識。
時間差：

收到一個心跳包之後記錄當前時間；
判斷定時器到達時間，計算多久沒收到心跳時間=當前時間-上次收到心跳時間。如果改時間大於設定值則認為超時。
簡單標識：

收到心跳後設置連線標識為true;
判斷定時器到達時間，如果未收到心跳則設定連線標識為false;
今天我們來看一下Netty的心跳機制的實現，在Netty中提供了IdleStateHandler類來進行心跳的處理，它可以對一個 Channel 的讀/寫設定定時器, 當 Channel 在一定事件間隔內沒有資料互動時(即處於 idle 狀態), 就會觸發指定的事件。

該類可以對三種類型的超時做心跳機制檢測：

public IdleStateHandler(int readerIdleTimeSeconds, int writerIdleTimeSeconds, int allIdleTimeSeconds) {
this((long)readerIdleTimeSeconds, (long)writerIdleTimeSeconds, (long)allIdleTimeSeconds, TimeUnit.SECONDS);
}
1
2
3
readerIdleTimeSeconds：設定讀超時時間；
writerIdleTimeSeconds：設定寫超時時間；
allIdleTimeSeconds：同時為讀或寫設定超時時間；
下面我們還是通過一個例子來講解IdleStateHandler的使用。

服務端：

public class HeartBeatServer {
private int port;

public HeartBeatServer(int port) {
this.port = port;
}

public void start(){
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workGroup = new NioEventLoopGroup();

ServerBootstrap server = new ServerBootstrap().group(bossGroup,workGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new HeartBeatServerChannelInitializer());

try {
ChannelFuture future = server.bind(port).sync();
future.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
bossGroup.shutdownGracefully();
workGroup.shutdownGracefully();
}
}

public static void main(String[] args) {
HeartBeatServer server = new HeartBeatServer(7788);
server.start();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
服務端Initializer：

public class HeartBeatServerChannelInitializer extends ChannelInitializer<SocketChannel> {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
ChannelPipeline pipeline = socketChannel.pipeline();

pipeline.addLast("handler",new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
pipeline.addLast(new HeartBeatServerHandler());
}
}
1
2
3
4
5
6
7
8
9
10
11
在這裡IdleStateHandler也是handler的一種，所以加入addLast。我們分別設定4個引數：讀超時時間為3s，寫超時和讀寫超時為0，然後加入時間控制單元。

服務端handler：

public class HeartBeatServerHandler extends ChannelInboundHandlerAdapter{
private int loss_connect_time = 0;

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println(ctx.channel().remoteAddress() + "Server :" + msg.toString());
}

@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if(evt instanceof IdleStateEvent){
//服務端對應著讀事件，當為READER_IDLE時觸發
IdleStateEvent event = (IdleStateEvent)evt;
if(event.state() == IdleState.READER_IDLE){
loss_connect_time++;
System.out.println("接收訊息超時");
if(loss_connect_time > 2){
System.out.println("關閉不活動的連結");
ctx.channel().close();
}
}else{
super.userEventTriggered(ctx,evt);
}
}
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
我們看到在handler中呼叫了userEventTriggered方法，IdleStateEvent的state()方法一個有三個值：
READER_IDLE，WRITER_IDLE，ALL_IDLE。正好對應讀事件寫事件和讀寫事件。

再來寫一下客戶端：

public class HeartBeatsClient {
private int port;
private String address;

public HeartBeatsClient(int port, String address) {
this.port = port;
this.address = address;
}

public void start(){
EventLoopGroup group = new NioEventLoopGroup();

Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.handler(new HeartBeatsClientChannelInitializer());

try {
ChannelFuture future = bootstrap.connect(address,port).sync();
future.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
}finally {
group.shutdownGracefully();
}

}

public static void main(String[] args) {
HeartBeatsClient client = new HeartBeatsClient(7788,"127.0.0.1");
client.start();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
客戶端Initializer：

public class HeartBeatsClientChannelInitializer extends ChannelInitializer<SocketChannel> {

protected void initChannel(SocketChannel socketChannel) throws Exception {
ChannelPipeline pipeline = socketChannel.pipeline();

pipeline.addLast("handler", new IdleStateHandler(0, 3, 0, TimeUnit.SECONDS));
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
pipeline.addLast(new HeartBeatClientHandler());
}
}
1
2
3
4
5
6
7
8
9
10
11
這裡我們設定了IdleStateHandler的寫超時為3秒，客戶端執行的動作為寫訊息到服務端，服務端執行讀動作。

客戶端handler:

public class HeartBeatClientHandler extends ChannelInboundHandlerAdapter {

private static final ByteBuf HEARTBEAT_SEQUENCE = Unpooled.unreleasableBuffer(Unpooled.copiedBuffer("Heartbeat",
CharsetUtil.UTF_8));

private static final int TRY_TIMES = 3;

private int currentTime = 0;

@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("啟用時間是："+new Date());
System.out.println("連結已經啟用");
ctx.fireChannelActive();
}

@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
System.out.println("停止時間是："+new Date());
System.out.println("關閉連結");
}

@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
System.out.println("當前輪詢時間："+new Date());
if (evt instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.WRITER_IDLE) {
if(currentTime <= TRY_TIMES){
System.out.println("currentTime:"+currentTime);
currentTime++;
ctx.channel().writeAndFlush(HEARTBEAT_SEQUENCE.duplicate());
}
}
}
}

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
String message = (String) msg;
System.out.println(message);
if (message.equals("Heartbeat")) {
ctx.write("has read message from server");
ctx.flush();
}
ReferenceCountUtil.release(msg);
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
啟動服務端和客戶端我們看到輸出為：

我們再來屢一下思路：

首先客戶端啟用channel，因為客戶端中並沒有傳送訊息所以會觸發客戶端的IdleStateHandler，它設定的寫超時時間為3s；
然後觸發客戶端的事件機制進入userEventTriggered方法，在觸發器中計數並向客戶端傳送訊息；
服務端接收訊息；
客戶端觸發器繼續輪詢傳送訊息，直到計數器滿不再向服務端傳送訊息；
服務端在IdleStateHandler設定的讀訊息超時時間5s內未收到訊息，觸發了服務端中handler的userEventTriggered方法，於是關閉客戶端的連結。
大體我們的簡單心跳機制就是這樣的思路，通過事件觸發機制以及計數器的方式來實現，上面我們的案例中最後客戶端沒有傳送訊息的時候我們是強制斷開了客戶端的連結，那麼既然可以關閉，我們是不是也可是重新連結客戶端呢？因為萬一客戶端本身並不想關閉而是由於別的原因導致他無法與服務端通訊。下面我們來說一下重連機制。

當我們的服務端在未讀到客戶端訊息超時而關閉客戶端的時候我們一般在客戶端的finally塊中方的是關閉客戶端的程式碼，這時我們可以做一下修改的，finally是一定會被執行新的，所以我們可以在finally塊中重新呼叫一下啟動客戶端的程式碼，這樣就又重新啟動了客戶端了，上客戶端程式碼：

/**
* 本Client為測試netty重連機制
* Server端程式碼都一樣，所以不做修改
* 只用在client端中做一下判斷即可
*/
public class HeartBeatsClient2 {

private int port;
private String address;
ChannelFuture future;

public HeartBeatsClient2(int port, String address) {
this.port = port;
this.address = address;
}

public void start(){
EventLoopGroup group = new NioEventLoopGroup();

Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.handler(new HeartBeatsClientChannelInitializer());

try {
future = bootstrap.connect(address,port).sync();
future.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
}finally {
//group.shutdownGracefully();
if (null != future) {
if (future.channel() != null && future.channel().isOpen()) {
future.channel().close();
}
}
System.out.println("準備重連");
start();
System.out.println("重連成功");
}

}

public static void main(String[] args) {
HeartBeatsClient2 client = new HeartBeatsClient2(7788,"127.0.0.1");
client.start();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
其餘部分的程式碼與上面的例項並無異同，只需改造客戶端即可，我們再執行服務端和客戶端會看到客戶端雖然被關閉了，但是立馬又被重啟：

當然生產級別的程式碼應該不是這樣實現的吧，哈哈，下一節我們再好好探討。
---------------------
作者：rickiyang
來源：CSDN
原文：https://blog.csdn.net/a953713428/article/details/69378412
版權宣告：本文為博主原創文章，轉載請附上博文連結！

Netty學習(八)-Netty的心跳機制

Netty學習(八)-Netty的心跳機制

Java Netty 學習(八) - Netty的Channel

Java Netty 學習(八)

Netty學習(九)-Netty編解碼技術之Marshalling

Netty學習——用Netty實現一個簡單的Http伺服器

Netty 之 Netty生產級的心跳和重連機制

Netty 實現心跳機制.md

netty 實現長連線，心跳機制，以及重連

Netty學習之路（八）-Google Protobuf編碼

NETTY 心跳機制

Netty(一) SpringBoot 整合長連線心跳機制

一起學Netty（十八）netty原始碼學習之netty server端原始碼初讀（上）

Netty學習之旅------原始碼分析Netty執行緒本地分配機制與PooledByteBuf執行緒級物件池原理分析

一起學Netty（十四）之 Netty生產級的心跳和重連機制

netty學習筆記(一)—結合reactor模式探索netty對網路io的處理機制

netty自定義心跳機制

淺析 Netty心跳機制

聊聊心跳機制及netty心跳實現

netty學習(一)--linux下的網絡io模型簡單介紹

netty學習之Reactor線程模型以及在netty中的應用

Netty學習(八)-Netty的心跳機制

相關推薦