架构师养成记--22.客户端与服务器端保持连接的解决方案，netty的ReadTimeoutHandler

概述

保持客户端与服务器端连接的方案常用的有3种

1.长连接，也就是客户端与服务器端一直保持连接，适用于客户端比较少的情况。

2.定时段连接，比如在某一天的凌晨建立连接，适用于对实时性要求不高的情况。

3.设置连接超时，比如超过1分钟没有传输数据就断开连接，等下次需要的时候再建立连接，这种方案比较常用。

netty的ReadTimeOut实现方案3

服务端

大部分代码都保持不变，有变化的代码在第30行，设置服务端的超时时间

 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.logging.LogLevel;
 import io.netty.handler.logging.LoggingHandler;
 import io.netty.handler.timeout.ReadTimeoutHandler;
 
 public class Server {
 
     public static void main(String[] args) throws Exception{
 
         EventLoopGroup pGroup = new NioEventLoopGroup();
         EventLoopGroup cGroup = new NioEventLoopGroup();
 
         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 {
                 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();
         pGroup.shutdownGracefully();
         cGroup.shutdownGracefully();
 
     }
 }

ServerHandler代码也没有什么变化

 import io.netty.channel.ChannelHandlerAdapter;
 import io.netty.channel.ChannelHandlerContext;
 
 public class ServerHandler extends ChannelHandlerAdapter{
 
     @Override
     public void channelActive(ChannelHandlerContext ctx) throws Exception {
 
     }
 
     @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 {
 
     }
 
     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
         ctx.close();
     }
 
 }

客户端

客户端的代码也设置了超时时间（实际上只要服务器端设置也就可以了，有人说客户端不设置会出问题，现在还没有发现什么问题）。主要看getChannelFuture这个方法，this.cf == null是第一次连接的时候用到的，!this.cf.channel().isActive() 是连接超时后重新发起连接用到的。再看main方法，可以发现for(int i = 1; i <= 3; i++ ) 这个循环中，每个循环停顿4秒，也就是每隔4秒发送一次请求，而服务器端的超时时间设置为5秒，那么在这个for循环期间连接是不会断开的，等for循环结束 cf.channel().closeFuture().sync(); 断开连接this.cf.channel().isActive()  变为否，在new Thread(）中再次发送请求，getChannelFuture会重新建立连接。

 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelInitializer;
 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.logging.LogLevel;
 import io.netty.handler.logging.LoggingHandler;
 import io.netty.handler.timeout.ReadTimeoutHandler;
 
 import java.util.concurrent.TimeUnit;
 
 /**
  * Best Do It
  */
 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();
         //c.connect();
 
         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没有什么变化

 import io.netty.channel.ChannelHandlerAdapter;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.util.ReferenceCountUtil;
 
 public class ClientHandler extends ChannelHandlerAdapter{
 
     @Override
     public void channelActive(ChannelHandlerContext ctx) throws Exception {
 
     }
 
     @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 channelReadComplete(ChannelHandlerContext ctx) throws Exception {
 
     }
 
     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
         ctx.close();
     }
 
 }

工厂类不变

 import io.netty.handler.codec.marshalling.DefaultMarshallerProvider;
 import io.netty.handler.codec.marshalling.DefaultUnmarshallerProvider;
 import io.netty.handler.codec.marshalling.MarshallerProvider;
 import io.netty.handler.codec.marshalling.MarshallingDecoder;
 import io.netty.handler.codec.marshalling.MarshallingEncoder;
 import io.netty.handler.codec.marshalling.UnmarshallerProvider;
 
 import org.jboss.marshalling.MarshallerFactory;
 import org.jboss.marshalling.Marshalling;
 import org.jboss.marshalling.MarshallingConfiguration;
 
 /**
  * Marshalling工厂
  * @author（alienware）
  * @since 2014-12-16
  */
 public final class MarshallingCodeCFactory {
 
     /**
      * 创建Jboss Marshalling解码器MarshallingDecoder
      * @return MarshallingDecoder
      */
     public static MarshallingDecoder buildMarshallingDecoder() {
         //首先通过Marshalling工具类的精通方法获取Marshalling实例对象 参数serial标识创建的是java序列化工厂对象。
         final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
         //创建了MarshallingConfiguration对象，配置了版本号为5
         final MarshallingConfiguration configuration = new MarshallingConfiguration();
         configuration.setVersion(5);
         //根据marshallerFactory和configuration创建provider
         UnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, configuration);
         //构建Netty的MarshallingDecoder对象，俩个参数分别为provider和单个消息序列化后的最大长度
         MarshallingDecoder decoder = new MarshallingDecoder(provider, 1024);
         return decoder;
     }
 
     /**
      * 创建Jboss Marshalling编码器MarshallingEncoder
      * @return MarshallingEncoder
      */
     public static MarshallingEncoder buildMarshallingEncoder() {
         final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
         final MarshallingConfiguration configuration = new MarshallingConfiguration();
         configuration.setVersion(5);
         MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, configuration);
         //构建Netty的MarshallingEncoder对象，MarshallingEncoder用于实现序列化接口的POJO对象序列化为二进制数组
         MarshallingEncoder encoder = new MarshallingEncoder(provider);
         return encoder;
     }
 }

自定义的Request和Response对象没有什么变化，这里不再赘述