zoukankan      html  css  js  c++  java
  • netty4 断线重连

    转载:http://www.tuicool.com/articles/B7RzMbY

    一 实现心跳检测

    原理:当服务端每隔一段时间就会向客户端发送心跳包,客户端收到心跳包后同样也会回一个心跳包给服务端

    一般情况下,客户端与服务端在指定时间内没有任何读写请求,就会认为连接是idle(空闲的)的。此时,客户端需要向服务端发送心跳消息,来维持服务端与客户端的链接。那么怎么判断客户端在指定时间里没有任何读写请求呢?netty中为我们提供一个特别好用的IdleStateHandler来干这个苦差事!

    在服务端工作线程中添加:arg0.pipeline().addLast("ping", new IdleStateHandler(25, 15, 10,TimeUnit.SECONDS));


    这个处理器,它的作用就是用来检测客户端的读取超时的,该类的第一个参数是指定读操作空闲秒数,第二个参数是指定写操作的空闲秒数,第三个参数是指定读写空闲秒数,
    当有操作操作超出指定空闲秒数时,便会触发UserEventTriggered事件。所以我们只需要在自己的handler中截获该事件,然后发起相应的操作即可(比如说发起心跳操作)。
    以下是我们自定义的handler中的代码:

    /**
    	 * 一段时间未进行读写操作 回调
    	 */
    	@Override
    	public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
    			throws Exception {
    		// TODO Auto-generated method stub
    		super.userEventTriggered(ctx, evt);
    
    		if (evt instanceof IdleStateEvent) {
    
    			IdleStateEvent event = (IdleStateEvent) evt;
    			
    			if (event.state().equals(IdleState.READER_IDLE)) {
    				//未进行读操作
    				System.out.println("READER_IDLE");
    				// 超时关闭channel
    				 ctx.close();
    
    			} else if (event.state().equals(IdleState.WRITER_IDLE)) {
    				
    
    			} else if (event.state().equals(IdleState.ALL_IDLE)) {
    				//未进行读写
    				System.out.println("ALL_IDLE");
    				// 发送心跳消息
    				MsgHandleService.getInstance().sendMsgUtil.sendHeartMessage(ctx);
    				
    			}
    
    		}
    	}


    也就是说 服务端在10s内未进行读写操作,就会向客户端发送心跳包,客户端收到心跳包后立即回复心跳包给服务端,此时服务端就进行了读操作,
    也就不会触发IdleState.READER_IDLE(未读操作状态),
    若客户端异常掉线了,并不能响应服务端发来的心跳包,在25s后就会触发IdleState.READER_IDLE(未读操作状态),
    此时服务器就会将通道关闭。

    二 客户端实现断线重连

    原理当客户端连接服务器时

    bootstrap.connect(new InetSocketAddress(
                        serverIP, port));


    会返回一个ChannelFuture的对象,我们对这个对象进行监听。

    代码如下:
    
    
    import android.os.Handler;
    import android.os.HandlerThread;
    import android.os.Message;
    import android.util.Log;
    
    import com.ld.qmwj.Config;
    import com.ld.qmwj.MyApplication;
    
    import java.net.InetSocketAddress;
    import java.nio.charset.Charset;
    import java.util.concurrent.TimeUnit;
    
    import io.netty.bootstrap.Bootstrap;
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelFutureListener;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelOption;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.channel.socket.nio.NioSocketChannel;
    import io.netty.handler.codec.DelimiterBasedFrameDecoder;
    import io.netty.handler.codec.string.StringDecoder;
    import io.netty.handler.codec.string.StringEncoder;
    
    /**
     * Created by zsg on 2015/11/21.
     */
    public class MyClient implements Config {
        private static Bootstrap bootstrap;
        private static ChannelFutureListener channelFutureListener = null;
    
        public MyClient() {
    
        }
    
    
        // 初始化客户端
        public static void initClient() {
    
            NioEventLoopGroup group = new NioEventLoopGroup();
    
            // Client服务启动器 3.x的ClientBootstrap
            // 改为Bootstrap,且构造函数变化很大,这里用无参构造。
            bootstrap = new Bootstrap();
            // 指定EventLoopGroup
            bootstrap.group(group);
            // 指定channel类型
            bootstrap.channel(NioSocketChannel.class);
            // 指定Handler
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    // 创建分隔符缓冲对象
                    ByteBuf delimiter = Unpooled.copiedBuffer("#"
                            .getBytes());
                    // 当达到最大长度仍没找到分隔符 就抛出异常
                    ch.pipeline().addLast(
                            new DelimiterBasedFrameDecoder(10000, true, false, delimiter));
                    // 将消息转化成字符串对象 下面的到的消息就不用转化了
                    //解码
                    ch.pipeline().addLast(new StringEncoder(Charset.forName("UTF-8")));
                    ch.pipeline().addLast(new StringDecoder(Charset.forName("GBK")));
                    ch.pipeline().addLast(new MyClientHandler());
                }
            });
            //设置TCP协议的属性
            bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
            bootstrap.option(ChannelOption.TCP_NODELAY, true);
            bootstrap.option(ChannelOption.SO_TIMEOUT, 5000);
    
            channelFutureListener = new ChannelFutureListener() {
                public void operationComplete(ChannelFuture f) throws Exception {
                    //  Log.d(Config.TAG, "isDone:" + f.isDone() + "     isSuccess:" + f.isSuccess() +
                    //          "     cause" + f.cause() + "        isCancelled" + f.isCancelled());
    
                    if (f.isSuccess()) {
                        Log.d(Config.TAG, "重新连接服务器成功");
    
                    } else {
                        Log.d(Config.TAG, "重新连接服务器失败");
                        //  3秒后重新连接
                        f.channel().eventLoop().schedule(new Runnable() {
                            @Override
                            public void run() {
                                doConnect();
                            }
                        }, 3, TimeUnit.SECONDS);
                    }
                }
            };
    
        }
    
        //  连接到服务端
        public static void doConnect() {
            Log.d(TAG, "doConnect");
            ChannelFuture future = null;
            try {
                future = bootstrap.connect(new InetSocketAddress(
                        serverIP, port));
                future.addListener(channelFutureListener);
    
            } catch (Exception e) {
                e.printStackTrace();
                //future.addListener(channelFutureListener);
                Log.d(TAG, "关闭连接");
            }
    
        }
    
    }


    监听到连接服务器失败时,会在3秒后重新连接(执行doConnect方法)

    这还不够,当客户端掉线时要进行重新连接

    在我们自己定义逻辑处理的Handler中

    @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
            Log.d(Config.TAG, "与服务器断开连接服务器");
            super.channelInactive(ctx);
            MsgHandle.getInstance().channel = null;
    
            //重新连接服务器
            ctx.channel().eventLoop().schedule(new Runnable() {
                @Override
                public void run() {
                    MyClient.doConnect();
                }
            }, 2, TimeUnit.SECONDS);
            ctx.close();
        }
     
     
  • 相关阅读:
    053-005
    053-002
    053-004
    Dynamic Programming: Fibonacci
    Some tips on using HashSet<T> and List<T>
    使用NPOI导出DataTable到Excel
    简简单单写个特效
    vue项目使用tinymce 适用于5.0版本
    封装AJAX
    全屏滑动效果
  • 原文地址:https://www.cnblogs.com/fanguangdexiaoyuer/p/6132968.html
Copyright © 2011-2022 走看看