netty实现长连接心跳检

主要逻辑：

使用netty实现长连接，主要靠心跳来维持服务器端及客户端连接。

实现的逻辑主要是：

服务器端方面：

1， 服务器在网络空闲操作一定时间后，服务端失败心跳计数器加1。

2， 如果收到客户端的ping心跳包，则清零失败心跳计数器，如果连续n次未收到客户端的ping心跳包，则关闭链路，释放资源，等待客户端重连。

客户端方面：

1， 客户端网络空闲在一定时间内没有进行写操作时，则发送一个ping心跳包。

2， 如果服务器端未在发送下一个心跳包之前回复pong心跳应答包，则失败心跳计数器加1。

3， 如果客户端连续发送n（此处根据具体业务进行定义）次ping心跳包，服务器端均未回复pong心跳应答包，则客户端断开连接，间隔一定时间进行重连操作，直至连接服务器成功。

环境：netty5,tomcat7,jdk7,myeclipse

服务器端心跳处理类:

1. public class HeartBeatRespHandler extends ChannelInboundHandlerAdapter {
2. private  final Logger log=Logger.getLogger(HeartBeatRespHandler.class);
3. //线程安全心跳失败计数器
4. private AtomicInteger unRecPingTimes = new AtomicInteger(1);
5. @Override
6. public void channelRead(ChannelHandlerContext ctx, Object msg)
7. throws Exception {
8. NettyMessageProto message = (NettyMessageProto)msg;
9. unRecPingTimes = new AtomicInteger(1);
10. //接收客户端心跳信息
11. if(message.getHeader() != null  && message.getHeader().getType() == Constants.MSGTYPE_HEARTBEAT_REQUEST){
12. //清零心跳失败计数器
13. log.info("server receive client"+ctx.channel().attr(SysConst.SERIALNO_KEY)+" ping msg :---->"+message);
14. //接收客户端心跳后,进行心跳响应
15. NettyMessageProto replyMsg = buildHeartBeat();
16. ctx.writeAndFlush(replyMsg);
17. }else{
18. ctx.fireChannelRead(msg);
19. }
20. }
21. /**
22. * 事件触发器，该处用来处理客户端空闲超时,发送心跳维持连接。
23. */
24. @Override
25. public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
26. if (evt instanceof IdleStateEvent) {
27. IdleStateEvent event = (IdleStateEvent) evt;
28. if (event.state() == IdleState.READER_IDLE) {
29. /*读超时*/
30. log.info("===服务器端===(READER_IDLE 读超时)");
31. unRecPingTimes.getAndIncrement();
32. //客户端未进行ping心跳发送的次数等于3,断开此连接
33. if(unRecPingTimes.intValue() == 3){
34. ctx.disconnect();
35. System.out.println("此客户端连接超时，服务器主动关闭此连接....");
36. log.info("此客户端连接超时，服务器主动关闭此连接....");
37. }
38. } else if (event.state() == IdleState.WRITER_IDLE) {
39. /*服务端写超时*/
40. log.info("===服务器端===(WRITER_IDLE 写超时)");
41. } else if (event.state() == IdleState.ALL_IDLE) {
42. /*总超时*/
43. log.info("===服务器端===(ALL_IDLE 总超时)");
44. }
45. }
46. }
47. /**
48. * 创建心跳响应消息
49. * @return
50. */
51. private NettyMessageProto buildHeartBeat(){
52. HeaderProto header = HeaderProto.newBuilder().setType(Constants.MSGTYPE_HEARTBEAT_RESPONSE).build();
53. NettyMessageProto message =NettyMessageProto.newBuilder().setHeader(header).build();
54. return message;
55. }

客户端心跳处理类：

1. public class HeartBeatReqHandler extends ChannelHandlerAdapter {
2. private  final Logger log=Logger.getLogger(HeartBeatReqHandler.class);
3. //线程安全心跳失败计数器
4. private AtomicInteger unRecPongTimes = new AtomicInteger(1);
5. public void channelRead(ChannelHandlerContext ctx, Object msg)
6. throws Exception {
7. NettyMessageProto message = (NettyMessageProto)msg;
8. //服务器端心跳回复
9. if(message.getHeader() != null  && message.getHeader().getType() == Constants.MSGTYPE_HEARTBEAT_RESPONSE){
10. //如果服务器进行pong心跳回复，则清零失败心跳计数器
11. unRecPongTimes = new AtomicInteger(1);
12. log.debug("client receive server pong msg :---->"+message);
13. }else{
14. ctx.fireChannelRead(msg);
15. }
16. }
17. /**
18. * 事件触发器，该处用来处理客户端空闲超时,发送心跳维持连接。
19. */
20. public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
21. if (evt instanceof IdleStateEvent) {
22. IdleStateEvent event = (IdleStateEvent) evt;
23. if (event.state() == IdleState.READER_IDLE) {
24. /*读超时*/
25. log.info("===客户端===(READER_IDLE 读超时)");
26. } else if (event.state() == IdleState.WRITER_IDLE) {
27. /*客户端写超时*/
28. log.info("===客户端===(WRITER_IDLE 写超时)");
29. unRecPongTimes.getAndIncrement();
30. //服务端未进行pong心跳响应的次数小于3,则进行发送心跳，否则则断开连接。
31. if(unRecPongTimes.intValue() < 3){
32. //发送心跳，维持连接
33. ctx.channel().writeAndFlush(buildHeartBeat()) ;
34. log.info("客户端：发送心跳");
35. }else{
36. ctx.channel().close();
37. }
38. } else if (event.state() == IdleState.ALL_IDLE) {
39. /*总超时*/
40. log.info("===客户端===(ALL_IDLE 总超时)");
41. }
42. }
43. }
44. private NettyMessageProto buildHeartBeat(){
45. HeaderProto header = HeaderProto.newBuilder().setType(Constants.MSGTYPE_HEARTBEAT_REQUEST).build();
46. NettyMessageProto  message = NettyMessageProto.newBuilder().setHeader(header).build();
47. return message;
48. }
49. /**
50. * 异常处理
51. */
52. public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)throws Exception{
53. ctx.fireExceptionCaught(cause);
54. }
55. }

1. <pre code_snippet_id="2489110" snippet_file_name="blog_20170719_2_6056366" name="code" class="java"><pre code_snippet_id="2489110" snippet_file_name="blog_20170719_2_6056366"></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre><pre></pre></pre>
2. <pre></pre>
3. <pre></pre>
4. <pre></pre>
5. <pre></pre>
6. <link rel="stylesheet" href="http://static.blog.csdn.net/public/res-min/markdown_views.css?v=1.0">

 

 

版权声明：本文为博主原创文章，未经博主允许不得转载。