使用netty进行客户端网络编程及断线重连功能实现

       不管做哪个方向开发，都会有那么一两个牛B闪闪的库，可以极大的方便开发，比如java网络编程中的netty库。无论客户端还是服务端网络编程，netty基本都是首选网络库，健壮、高效、稳定，并且已经得到很多商业项目验证。
       当用netty进行客户端网络编程时，与服务端建立连接并完成数据编码、解码、通信是最基础功能，考虑程序的健壮性，则断线重连是必不可少的一个功能点。netty源码的example文件夹中uptime目录中有相关示例demo，但是总觉得该样例代码封装的不够好，于是决定自己动手重新写一个，如果有更优雅的断线重连实现方法，希望大家将链接留言发我。下面是主体代码，Handler部分就不分享了。

public class BaseClient implements Runnable {

private static Logger LOGGER = LoggerTools.getInstance(BaseClient.class);

private String host_;
private int port_;
private int reConnectCount_ = 0;
private ClientHandler clientHandler_;
private OnMessageListener messageListener_;
private OnStartupListener startupListener_;
private volatile boolean isChannelPrepared_;

private final static int MAX_MESSAGE_LENGTH = 8192;

public BaseClient(String host, int port, OnMessageListener messageListener, OnStartupListener startupListener) {
host_ = host;
port_ = port;
messageListener_ = messageListener;
startupListener_ = startupListener;
}

@Override
public void run() {
connect(host_, port_);
}

// 发送消息
public void sendMessage(String msg, ResultListener<String> listener) {
if (isChannelPrepared_) {
clientHandler_.sendMessage(msg, listener);
} else {
listener.onFailure(msg);
LOGGER.error("连接还未建立, 无法发送数据...");
}
}

// 建立连接
private void connect(String host, int port) {
EventLoopGroup group = new NioEventLoopGroup();

try {
Bootstrap b = new Bootstrap();
b.group(group);
b.channel(NioSocketChannel.class);
b.option(ChannelOption.TCP_NODELAY, true);
b.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();

p.addLast(new LengthFieldBasedFrameDecoder(MAX_MESSAGE_LENGTH, 0, 4, 0 ,4));
p.addLast(new LengthFieldPrepender(4));
p.addLast(new StringDecoder(CharsetUtil.UTF_8));
p.addLast(new StringEncoder(CharsetUtil.UTF_8));

clientHandler_ = new ClientHandler(messageListener_);
p.addLast(clientHandler_);
}
});

ChannelFuture f = b.connect(host, port).sync();
f.addListener(new GenericFutureListener<Future<? super Void>>() {
@Override
public void operationComplete(Future<? super Void> future) throws Exception {
if (future.isSuccess()) {
reConnectCount_ = 0;
isChannelPrepared_ = true;
startupListener_.onCompletion(true);
LOGGER.info("与服务器{}:{}连接建立成功...", host_, port_);
} else {
isChannelPrepared_ = false;
startupListener_.onCompletion(false);
LOGGER.info("与服务器{}:{}连接建立失败...", host_, port_);
}
}
});

f.channel().closeFuture().sync();
} catch (Exception e) {
isChannelPrepared_ = false;
LOGGER.error("与服务器{}:{}连接出现异常...", host_, port_);
} finally {
isChannelPrepared_ = false;
group.shutdownGracefully();
reConnect(host, port);
}
}

// 断线重连
private void reConnect(String host, int port) {
// fixme: 重连显式退出?
try {
isChannelPrepared_ = false;
int delay = ++reConnectCount_ * 5;
reConnectCount_ = reConnectCount_ > 23 ? 23 : reConnectCount_;
LOGGER.error("与服务器{}:{}连接已断开, {}秒后重连...", host, port, delay);

Thread.sleep(delay * 1000);
connect(host, port);
} catch (Exception e) {
e.printStackTrace();
}
}

}