Netty最佳实践之数据通信

使用Netty进行两台或者多台服务器之间的数据通信，大体有以下三种情况：

1. 使用长连接通道不断开的方式进行通信。也就是服务器和客户端的通道不断开，一直处于开启状态，如果服务器的性能足够好，并且我们的客户端数量足够少的情况下，推荐这种方式。
2. 一次性批量提交数据，推荐采用短连接方式。即我们可以把数据保存在本地临时缓冲区或者临时表中，当到达一定临界值的时候一次性批量提交，或者是根据定时任务轮询提交，这种方式的弊端是做不到实时性，在对实时性要求不高的应用程序中推荐使用。
3. 我们可以使用一种特殊的长连接，在指定的一段时间内，服务器与某台客户端么有进行任何通信，则断开连接。下次客户端向服务器端发送请求时再次建立连接，这种模式需要考虑两种因素：

3.1 如何在服务器端和客户端在一定时间超时后关闭通道？关闭通道后如何再建立连接？

答：可以使用Netty的ReadTimeoutHandler，在一定时间内没读取到数据则断开连接；再次建立连接直接发起请求即可。

3.2 客户端宕机时我们无需考虑，下次客户端重启后就可以与服务器建立连接；但是服务器宕机后，我们客户端如何与服务端建立连接？答案无非是隔一段时间轮询建立连接。

---

以下是设置连接的超时处理，在规定时间内无数据传输则断开，在断开连接后重新建立连接：

server：

public class Server {
 
	public static void main(String[] args) {
		
		EventLoopGroup pGroup = new NioEventLoopGroup();
		EventLoopGroup cGroup = new NioEventLoopGroup();
		try {
			ServerBootstrap b = new ServerBootstrap();
			b.group(pGroup, cGroup)
			 .channel(NioServerSocketChannel.class)
			 .option(ChannelOption.SO_BACKLOG, 1024)
			 // 设置日志
			 .handler(new LoggingHandler(LogLevel.INFO))
			 .childHandler(new ChannelInitializer<SocketChannel>() {
				protected void initChannel(SocketChannel sc) throws Exception {
					// Marshalling的编解码器
					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());
					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());
					// 设置无数据读取的超时处理器
					sc.pipeline().addLast(new ReadTimeoutHandler(5)); 
					// 自定义处理器
					sc.pipeline().addLast(new ServerHandler());
				}
			});
			
			ChannelFuture cf = b.bind(8765).sync();
			
			cf.channel().closeFuture().sync();
		}finally{
			pGroup.shutdownGracefully();
			cGroup.shutdownGracefully();
		}
	}
}

serverhandler

public class ServerHandler extends ChannelHandlerAdapter{

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		Request request = (Request)msg;
		System.out.println("Server : " + request.getId() + ", " + request.getName() + ", " + request.getRequestMessage());
		Response response = new Response();
		response.setId(request.getId());
		response.setName("response" + request.getId());
		response.setResponseMessage("响应内容" + request.getId());
		ctx.writeAndFlush(response);//.addListener(ChannelFutureListener.CLOSE);
	}
 
	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
		ctx.close();
	}
}

client：

public class Client {
	
	private static class SingletonHolder {
		static final Client instance = new Client();
	}
	
	public static Client getInstance(){
		return SingletonHolder.instance;
	}
	
	private EventLoopGroup group;
	private Bootstrap b;
	private ChannelFuture cf ;
	
	private Client(){
		group = new NioEventLoopGroup();
		b = new Bootstrap();
		b.group(group)
		 .channel(NioSocketChannel.class)
		 .handler(new LoggingHandler(LogLevel.INFO))
		 .handler(new ChannelInitializer<SocketChannel>() {
				@Override
				protected void initChannel(SocketChannel sc) throws Exception {
					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());
					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());
					// 超时handler（当服务器端与客户端在指定时间以上没有任何进行通信，则会关闭响应的通道，主要为减小服务端资源占用）
					sc.pipeline().addLast(new ReadTimeoutHandler(5)); 
					sc.pipeline().addLast(new ClientHandler());
				}
	    });
	}
	
	public void connect(){
		try {
			this.cf = b.connect("127.0.0.1", 8765).sync();
			System.out.println("远程服务器已经连接, 可以进行数据交换..");				
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public ChannelFuture getChannelFuture(){
		
		if(this.cf == null){
			this.connect();
		}
		if(!this.cf.channel().isActive()){
			this.connect();
		}
		
		return this.cf;
	}
	
	public static void main(String[] args) throws Exception{
		final Client c = Client.getInstance();
		
		ChannelFuture cf = c.getChannelFuture();
		for(int i = 1; i <= 3; i++ ){
			Request request = new Request();
			request.setId("" + i);
			request.setName("pro" + i);
			request.setRequestMessage("数据信息" + i);
			cf.channel().writeAndFlush(request);
			TimeUnit.SECONDS.sleep(4);
		}
 
		cf.channel().closeFuture().sync();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println("进入子线程...");
					ChannelFuture cf = c.getChannelFuture();
					System.out.println(cf.channel().isActive());
					System.out.println(cf.channel().isOpen());
					
					//再次发送数据
					Request request = new Request();
					request.setId("" + 4);
					request.setName("pro" + 4);
					request.setRequestMessage("数据信息" + 4);
					cf.channel().writeAndFlush(request);					
					cf.channel().closeFuture().sync();
					System.out.println("子线程结束.");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
		
		System.out.println("断开连接,主线程结束..");
	}
}

clienthandler

public class ClientHandler extends ChannelHandlerAdapter{

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		try {
			Response resp = (Response)msg;
			System.out.println("Client : " + resp.getId() + ", " + resp.getName() + ", " + resp.getResponseMessage());			
		} finally {
			ReferenceCountUtil.release(msg);
		}
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		ctx.close();
	}
	
}

流程分析：

客户端每隔4s钟向服务器端发数据：

ChannelFuture cf = c.getChannelFuture();

for(int i = 1; i <= 3; i++ ){
	Request request = new Request();
	request.setId("" + i);
	request.setName("pro" + i);
	request.setRequestMessage("数据信息" + i);
	cf.channel().writeAndFlush(request);
	TimeUnit.SECONDS.sleep(4);
}

cf.channel().closeFuture().sync();

那么当发完三次数据后，将会断开和服务器端的连接，看打印：

Client打印：

远程服务器已经连接, 可以进行数据交换..
Client : 1, response1, 响应内容1
Client : 2, response2, 响应内容2
Client : 3, response3, 响应内容3
断开连接,主线程结束..

Server打印：

[01:07:14] nioEventLoopGroup-0-0 INFO  [] [] [io.netty.handler.logging.LoggingHandler] - [id: 0xa1a7160d] REGISTERED
[01:07:14] nioEventLoopGroup-0-0 INFO  [] [] [io.netty.handler.logging.LoggingHandler] - [id: 0xa1a7160d] BIND: 0.0.0.0/0.0.0.0:8765
[01:07:14] nioEventLoopGroup-0-0 INFO  [] [] [io.netty.handler.logging.LoggingHandler] - [id: 0xa1a7160d, /0:0:0:0:0:0:0:0:8765] ACTIVE
[01:07:21] nioEventLoopGroup-0-1 INFO  [] [] [io.netty.handler.logging.LoggingHandler] - [id: 0xa1a7160d, /0:0:0:0:0:0:0:0:8765] RECEIVED: [id: 0x076dc15e, /127.0.0.1:61655 => /127.0.0.1:8765]
Server : 1, pro1, 数据信息1
Server : 2, pro2, 数据信息2
Server : 3, pro3, 数据信息3

为了让客户端断开后可以重新连接上，添加以下代码：

new Thread(new Runnable() {
	@Override
	public void run() {
		try {
			System.out.println("进入子线程...");
			ChannelFuture cf = c.getChannelFuture();
			System.out.println(cf.channel().isActive());
			System.out.println(cf.channel().isOpen());
			
			// 再次发送数据
			Request request = new Request();
			request.setId("" + 4);
			request.setName("pro" + 4);
			request.setRequestMessage("数据信息" + 4);
			cf.channel().writeAndFlush(request);					
			cf.channel().closeFuture().sync();
			System.out.println("子线程结束.");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}).start();

开启一个线程重新获取channelFuture：

public ChannelFuture getChannelFuture(){
	
	if(this.cf == null){
		this.connect();
	}
	if(!this.cf.channel().isActive()){
		this.connect();
	}
	
	return this.cf;
}

于是客户端继续向服务器发送第四次数据：

服务端：