一起学Netty（十三）之 Netty简单的重连机制

本文主要是介绍一起学Netty（十三）之 Netty简单的重连机制，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

其实重连机制并不是多么多高深的技术，其实就是一个在客户端做一个简单的判断，如果连接断了，那么就重新调用连接服务端的代码

当然，我们重连的动作肯定是发生在断连之后发生的，我们可以在上篇的心跳机制的基础上，简单地修改一下客户端的启动代码就可以了：

我们在连接断了之后，我们一般会在finally的方法中去释放资源，这边我们应该不去释放资源，我们在finally里面进行重连：

整个客户端的代码如下：

[java]  view plain copy  
 package com.lyncc.netty.heartbeats;  
   
 import java.util.concurrent.TimeUnit;  
   
 import io.netty.bootstrap.Bootstrap;  
 import io.netty.channel.ChannelFuture;  
 import io.netty.channel.ChannelInitializer;  
 import io.netty.channel.ChannelOption;  
 import io.netty.channel.ChannelPipeline;  
 import io.netty.channel.EventLoopGroup;  
 import io.netty.channel.nio.NioEventLoopGroup;  
 import io.netty.channel.socket.SocketChannel;  
 import io.netty.channel.socket.nio.NioSocketChannel;  
 import io.netty.handler.codec.string.StringDecoder;  
 import io.netty.handler.codec.string.StringEncoder;  
 import io.netty.handler.logging.LogLevel;  
 import io.netty.handler.logging.LoggingHandler;  
 import io.netty.handler.timeout.IdleStateHandler;  
   
 public class HeartBeatsClient {  
   
     public void connect(int port, String host) throws Exception {  
      // Configure the client.  
         EventLoopGroup group = new NioEventLoopGroup();  
         ChannelFuture future = null;  
         try {  
             Bootstrap b = new Bootstrap();  
             b.group(group)  
              .channel(NioSocketChannel.class)  
              .option(ChannelOption.TCP_NODELAY, true)  
              .handler(new LoggingHandler(LogLevel.INFO))  
              .handler(new ChannelInitializer<SocketChannel>() {  
                  @Override  
                  public void initChannel(SocketChannel ch) throws Exception {  
                      ChannelPipeline p = ch.pipeline();  
                      p.addLast("ping", new IdleStateHandler(0, 4, 0, TimeUnit.SECONDS));  
                      p.addLast("decoder", new StringDecoder());  
                      p.addLast("encoder", new StringEncoder());  
                      p.addLast(new HeartBeatClientHandler());  
                  }  
              });  
   
             future = b.connect(host, port).sync();  
             future.channel().closeFuture().sync();  
         } finally {  
 //          group.shutdownGracefully();  
           if (null != future) {  
               if (future.channel() != null && future.channel().isOpen()) {  
                   future.channel().close();  
               }  
           }  
           System.out.println("准备重连");  
           connect(port, host);  
           System.out.println("重连成功");  
         }  
     }  
   
     /** 
      * @param args 
      * @throws Exception 
      */  
     public static void main(String[] args) throws Exception {  
         int port = 8080;  
         if (args != null && args.length > 0) {  
             try {  
                 port = Integer.valueOf(args[0]);  
             } catch (NumberFormatException e) {  
                 // 采用默认值  
             }  
         }  
         new HeartBeatsClient().connect(port, "127.0.0.1");  
     }  
   
 }  