Netty心跳简单Demo

前面简单地了解了一下IdleStateHandler，我们现在写一个简单的心跳demo：

1）服务器端每隔5秒检测服务器端的读超时，如果5秒没有接受到客户端的写请求，也就说服务器端5秒没有收到读事件，则视为一次超时

2）如果超时二次则说明连接处于不活跃的状态，关闭ServerChannel

3）客户端每隔4秒发送一些写请求，这个请求相当于一次心跳包，告之服务器端：客户端仍旧活着

我们开始先开始写服务器端的handler,继承ChannelInboundHandlerAdapter，我们先重写userEventTriggered方法，这个方法我们前面讲过，如果超时则会触发相应的超时事件

HeartBeatServerHandler.java

1. package com.lyncc.netty.heartbeats;
2. import io.netty.channel.ChannelHandlerContext;
3. import io.netty.channel.ChannelInboundHandlerAdapter;
4. import io.netty.handler.timeout.IdleState;
5. import io.netty.handler.timeout.IdleStateEvent;
6. public class HeartBeatServerHandler extends ChannelInboundHandlerAdapter {
7. private int loss_connect_time = 0;
8. @Override
9. public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
10. if (evt instanceof IdleStateEvent) {
11. IdleStateEvent event = (IdleStateEvent) evt;
12. if (event.state() == IdleState.READER_IDLE) {
13. loss_connect_time++;
14. System.out.println("5 秒没有接收到客户端的信息了");
15. if (loss_connect_time > 2) {
16. System.out.println("关闭这个不活跃的channel");
17. ctx.channel().close();
18. }
19. }
20. } else {
21. super.userEventTriggered(ctx, evt);
22. }
23. }
24. @Override
25. public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
26. System.out.println("server channelRead..");
27. System.out.println(ctx.channel().remoteAddress() + "->Server :" + msg.toString());
28. }
29. @Override
30. public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
31. cause.printStackTrace();
32. ctx.close();
33. }
34. }

再写一下服务器端，我们要注意的是，我们要在channelPipeline中加入IdleStateHandler，我们在handler中提示的是5秒读，所以我们配置的是：

这样就可以每隔5秒检测一下服务端的读超时。完整代码清单如下:

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

HeartBeatClientHandler.java方法也重写userEventTriggered方法，因为客户端没有任何写的情况，所以我们可以每次都能进行写超时：

也就说这个方法每隔4秒都能触发：

红色边框代码在客户端没有写事件的时候，一超时就会触发写请求：

完整代码如下：

HeartBeatClientHandler.java

1. package com.lyncc.netty.heartbeats;
2. import java.util.Date;
3. import io.netty.buffer.ByteBuf;
4. import io.netty.buffer.Unpooled;
5. import io.netty.channel.ChannelHandlerContext;
6. import io.netty.channel.ChannelInboundHandlerAdapter;
7. import io.netty.handler.timeout.IdleState;
8. import io.netty.handler.timeout.IdleStateEvent;
9. import io.netty.util.CharsetUtil;
10. import io.netty.util.ReferenceCountUtil;
11. public class HeartBeatClientHandler extends ChannelInboundHandlerAdapter {
12. private static final ByteBuf HEARTBEAT_SEQUENCE = Unpooled.unreleasableBuffer(Unpooled.copiedBuffer("Heartbeat",
13. CharsetUtil.UTF_8));
14. private static final int TRY_TIMES = 3;
15. private int currentTime = 0;
16. @Override
17. public void channelActive(ChannelHandlerContext ctx) throws Exception {
18. System.out.println("激活时间是："+new Date());
19. System.out.println("HeartBeatClientHandler channelActive");
20. ctx.fireChannelActive();
21. }
22. @Override
23. public void channelInactive(ChannelHandlerContext ctx) throws Exception {
24. System.out.println("停止时间是："+new Date());
25. System.out.println("HeartBeatClientHandler channelInactive");
26. }
27. @Override
28. public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
29. System.out.println("循环触发时间："+new Date());
30. if (evt instanceof IdleStateEvent) {
31. IdleStateEvent event = (IdleStateEvent) evt;
32. if (event.state() == IdleState.WRITER_IDLE) {
33. if(currentTime <= TRY_TIMES){
34. System.out.println("currentTime:"+currentTime);
35. currentTime++;
36. ctx.channel().writeAndFlush(HEARTBEAT_SEQUENCE.duplicate());
37. }
38. }
39. }
40. }
41. @Override
42. public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
43. String message = (String) msg;
44. System.out.println(message);
45. if (message.equals("Heartbeat")) {
46. ctx.write("has read message from server");
47. ctx.flush();
48. }
49. ReferenceCountUtil.release(msg);
50. }
51. }

HeartBeatsClient.java

客户端代码也要加入IdleStateHandler这个handler，注意的是，我们要注意的是写超时，所以要设置写超时的时间，因为服务器端是5秒检测读超时，所以客户端必须在5秒内发送一次心跳，告之服务端，所以我们设置4秒：

完整代码如下：

1. package com.lyncc.netty.heartbeats;
2. import java.util.concurrent.TimeUnit;
3. import io.netty.bootstrap.Bootstrap;
4. import io.netty.channel.ChannelFuture;
5. import io.netty.channel.ChannelInitializer;
6. import io.netty.channel.ChannelOption;
7. import io.netty.channel.ChannelPipeline;
8. import io.netty.channel.EventLoopGroup;
9. import io.netty.channel.nio.NioEventLoopGroup;
10. import io.netty.channel.socket.SocketChannel;
11. import io.netty.channel.socket.nio.NioSocketChannel;
12. import io.netty.handler.codec.string.StringDecoder;
13. import io.netty.handler.codec.string.StringEncoder;
14. import io.netty.handler.logging.LogLevel;
15. import io.netty.handler.logging.LoggingHandler;
16. import io.netty.handler.timeout.IdleStateHandler;
17. public class HeartBeatsClient {
18. public void connect(int port, String host) throws Exception {
19. // Configure the client.
20. EventLoopGroup group = new NioEventLoopGroup();
21. try {
22. Bootstrap b = new Bootstrap();
23. b.group(group)
24. .channel(NioSocketChannel.class)
25. .option(ChannelOption.TCP_NODELAY, true)
26. .handler(new LoggingHandler(LogLevel.INFO))
27. .handler(new ChannelInitializer<SocketChannel>() {
28. @Override
29. public void initChannel(SocketChannel ch) throws Exception {
30. ChannelPipeline p = ch.pipeline();
31. p.addLast("ping", new IdleStateHandler(0, 4, 0, TimeUnit.SECONDS));
32. p.addLast("decoder", new StringDecoder());
33. p.addLast("encoder", new StringEncoder());
34. p.addLast(new HeartBeatClientHandler());
35. }
36. });
37. ChannelFuture future = b.connect(host, port).sync();
38. future.channel().closeFuture().sync();
39. } finally {
40. group.shutdownGracefully();
41. }
42. }
43. /**
44. * @param args
45. * @throws Exception
46. */
47. public static void main(String[] args) throws Exception {
48. int port = 8080;
49. if (args != null && args.length > 0) {
50. try {
51. port = Integer.valueOf(args[0]);
52. } catch (NumberFormatException e) {
53. // 采用默认值
54. }
55. }
56. new HeartBeatsClient().connect(port, "127.0.0.1");
57. }
58. }

我们先启动服务器端：

再启动客户端：

此时客户端还存活着，我们看看服务器端的输出：

我们再看看客户端的输出：

inactive的事件触发了，且客户端自动停止了~