socket框架netty-socket android客户端方式，内含心跳重连等

╰半橙微兮° 2023-05-21 15:20 13阅读 0赞

之前自己写了socket建立的连接，但是涉及到一些需要完善的地方，表示自己有点懒。然后就在网上找了一个socket框架， 拿来直接用。

阅读测试后，个人认为NettyClient 主要分为几个部分：  
1，异步端口连接 Bootstrap  
2，NettyClient的解码方式等 pipeline  
3，配套的HandlerAdapter ： ChannelInboundHandlerAdapter等。  
4，计算断开后重新调用连接。

*  使用的时候下载个jar包就可以了  
    [https://download.csdn.net/download/binbinxiaoz/10488657][https_download.csdn.net_download_binbinxiaoz_10488657]
 *  我先把定义的接口写了，下面的代码里面有用到。

public interface NettyListener {
    
        public final static byte STATUS_CONNECT_SUCCESS = 1;//连接成功
    
        public final static byte STATUS_CONNECT_CLOSED = 0;//关闭连接
    
        public final static byte STATUS_CONNECT_ERROR = 0;//连接失败
    
    
        /**
         * 当接收到系统消息
         */
        void onMessageResponse(Object msg);
    
        /**
         * 当连接状态发生变化时调用 
         */
        public void onServiceStatusConnectChanged(int statusCode);
    }

*  NettyClient 类的书写

public class NettyClient {
    
        private static final String TAG = "NettyClient";
    
        private EventLoopGroup group;//Bootstrap参数
    
        private NettyListener listener;//写的接口用来接收服务端返回的值
    
        private Channel channel;//通过对象发送数据到服务端
    
        private boolean isConnect = false;//判断是否连接了
    
        private static int reconnectNum = Integer.MAX_VALUE;//定义的重连到时候用
        private boolean isNeedReconnect = true;//是否需要重连
        private boolean isConnecting = false;//是否正在连接
        private long reconnectIntervalTime = 5000;//重连的时间
    
        public String host;//ip
        public int tcp_port;//端口
    
        /*
        构造 传入 ip和端口
         */
        public NettyClient(String host, int tcp_port) {
            this.host = host;
            this.tcp_port = tcp_port;
        }
    
        /*
        连接方法
         */
        public void connect() {
    
            if (isConnecting) {
                return;
            }
            //起个线程
            Thread clientThread = new Thread("client-Netty") {
                @Override
                public void run() {
                    super.run();
                    isNeedReconnect = true;
                    reconnectNum = Integer.MAX_VALUE;
                    connectServer();
                }
            };
            clientThread.start();
        }
    
        //连接时的具体参数设置
        private void connectServer() {
            synchronized (NettyClient.this) {
                ChannelFuture channelFuture = null;//连接管理对象
                if (!isConnect) {
                    isConnecting = true;
                    group = new NioEventLoopGroup();//设置的连接group
                    Bootstrap bootstrap = new Bootstrap().group(group)//设置的一系列连接参数操作等
                            .option(ChannelOption.TCP_NODELAY, true)//屏蔽Nagle算法试图
                            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
                            .channel(NioSocketChannel.class)
                            .handler(new ChannelInitializer<SocketChannel>() { // 5
                                @Override
                                public void initChannel(SocketChannel ch) throws Exception {
    //                                ch.pipeline().addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));//服务端最后以"\n"作为结束标识
    //                                ch.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));//解码
    //                                ch.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));//解码
    //                                ch.pipeline().addLast(new IdleStateHandler(0, 0, 5));//如果需要开启心跳则打开，不开启心跳就注释
                                      ch.pipeline().addLast(new NettyClientHandler(listener));//需要的handlerAdapter
                                }
                            });
    
                    try {
                        //连接监听
                        channelFuture = bootstrap.connect(host, tcp_port).addListener(new ChannelFutureListener() {
                            @Override
                            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                                if (channelFuture.isSuccess()) {
                                    Log.e(TAG, "连接成功");
                                    isConnect = true;
                                    channel = channelFuture.channel();
                                } else {
                                    Log.e(TAG, "连接失败");
                                    isConnect = false;
                                }
                                isConnecting = false;
                            }
                        }).sync();
    
                        // 等待连接关闭
                        channelFuture.channel().closeFuture().sync();
                        Log.e(TAG, " 断开连接");
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        isConnect = false;
                        listener.onServiceStatusConnectChanged(NettyListener.STATUS_CONNECT_CLOSED);//STATUS_CONNECT_CLOSED 这我自己定义的 接口标识
                        if (null != channelFuture) {
                            if (channelFuture.channel() != null && channelFuture.channel().isOpen()) {
                                channelFuture.channel().close();
                            }
                        }
                        group.shutdownGracefully();
                        reconnect();//重新连接
                    }
                }
            }
        }
    
        //断开连接
        public void disconnect() {
            Log.e(TAG, "disconnect");
            isNeedReconnect = false;
            group.shutdownGracefully();
        }
    
        //重新连接
        public void reconnect() {
            Log.e(TAG, "reconnect");
            if (isNeedReconnect && reconnectNum > 0 && !isConnect) {
                reconnectNum--;
                SystemClock.sleep(reconnectIntervalTime);
                if (isNeedReconnect && reconnectNum > 0 && !isConnect) {
                    Log.e(TAG, "重新连接");
                    connectServer();
                }
            }
        }
    
        //发送消息到服务端。 Bootstrap设置的时候我没有设置解码，这边才转的
        public boolean sendMsgToServer(String data, ChannelFutureListener listener) {
            boolean flag = channel != null && isConnect;
            if (flag) {
                ByteBuf byteBuf = Unpooled.copiedBuffer(data + System.getProperty("line.separator"), //2
                        CharsetUtil.UTF_8);
                channel.writeAndFlush(byteBuf).addListener(listener);
            }
            return flag;
        }
    
        //重连时间
        public void setReconnectNum(int reconnectNum) {
            this.reconnectNum = reconnectNum;
        }
    
        public void setReconnectIntervalTime(long reconnectIntervalTime) {
            this.reconnectIntervalTime = reconnectIntervalTime;
        }
        //现在连接的状态
        public boolean getConnectStatus() {
            return isConnect;
        }
    
        public boolean isConnecting() {
            return isConnecting;
        }
    
        public void setConnectStatus(boolean status) {
            this.isConnect = status;
        }
    
        public void setListener(NettyListener listener) {
            this.listener = listener;
        }
    
    }

*  netty socket 配套的handlerAdapter,直接上代码直接上

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    
        private static final String TAG = "NettyClientHandler";
        private NettyListener listener;
    
        public NettyClientHandler(NettyListener listener) {
            this.listener = listener;
        }
    
        //每次给服务器发送的东西， 让服务器知道我们在连接中哎
        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
            if (evt instanceof IdleStateEvent) {
                IdleStateEvent event = (IdleStateEvent) evt;
                if (event.state() == IdleState.WRITER_IDLE) {
                    ctx.channel().writeAndFlush("Heartbeat" + System.getProperty("line.separator"));
                }else if(event.state() == IdleState.ALL_IDLE){//如果空闲5S没有事件发生，则发送心跳包
                    System.out.println("Chunna.zheng===ALL_IDLE===发送心跳包");
                }
            }
        }
    
        /**
         * 连接成功
         */
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            Log.e(TAG, "channelActive");
            super.channelActive(ctx);
            listener.onServiceStatusConnectChanged(NettyListener.STATUS_CONNECT_SUCCESS);
        }
    
        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
            super.channelInactive(ctx);
            Log.e(TAG, "channelInactive");
        }
    
        //接收消息的地方， 接口调用返回到activity了
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("客户端开始读取服务端过来的信息");
            listener.onMessageResponse(msg);
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            // 当引发异常时关闭连接。
            Log.e(TAG, "exceptionCaught");
            listener.onServiceStatusConnectChanged(NettyListener.STATUS_CONNECT_ERROR);
            cause.printStackTrace();
            ctx.close();
        }
    
    }

我觉得我注释写的还挺多的，哈哈，  
对了，还有个定义的host和port类。虽然就几行，但我还是决定写上

public class Const {
    public static final String HOST = "192.168.0.46";
    public static final int TCP_PORT = 5212;
    public static final int LIVE_PORT = 5500;
    }

*   *   *  # 最重要的来袭了， 使用！ #

布局没什么东西， 就是个Button发送消息的，连接我写成进入app后默认连接了，失败和成功会有提示的昂， 失败了会一直重连。

其他核心的使用代码：！！！！

public class MainActivity extends BaseActivitiy implements NettyListener {
    
        private Button btn_send;//发送
        private NettyClient nettyClient;//socket操作连接对象
        private final String TAG = "MainActivity.class";
    
        @Override
        protected int getContentView() {//这我自己的基类抽象的
            return R.layout.activity_main;
        }
    
        @Override
        protected void initView() {//这我自己的基类抽象的
            initSocketTcp();//默认自动连接socket
    
            btn_send = findViewById(R.id.btn_send);//发送
            btn_send.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (!nettyClient.getConnectStatus()) {//获取连接状态，必须连接才能点。
                        Toast.makeText(MainActivity.this, "先连接", Toast.LENGTH_SHORT).show();
                    } else {
                        JSONObject jsonObject = new JSONObject();//传个jsonobject给服务器
                        long l = System.currentTimeMillis();
                        try {
                            jsonObject.put("msgType", "infomation");
                            jsonObject.put("msgValue", "status");
                            jsonObject.put("msgTime", l + "");
    
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }
                        /*
                        调用的发送。
                         */
                        nettyClient.sendMsgToServer(jsonObject.toString(), new ChannelFutureListener() {
                            @Override
                            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                                if (channelFuture.isSuccess()) {                //4
                                    Log.d(TAG, "Write auth successful");
                                } else {
                                    Log.d(TAG, "Write auth error");
                                }
                            }
                        });
                    }
                }
            });
        }
    
        /*
         socket 端口号以及开始连接，配置接口监听
         */
        private void initSocketTcp() {
            nettyClient = new NettyClient(Const.HOST, Const.TCP_PORT);
            if (!nettyClient.getConnectStatus()) {
                nettyClient.setListener(MainActivity.this);
                nettyClient.connect();
            } else {
                nettyClient.disconnect();
            }
        }
    
    
        /*
           回调客户端接收的信息  解析 数据流， 转换为string
           */
        @Override
        public void onMessageResponse(final Object msg) {
            ByteBuf result = (ByteBuf) msg;
            byte[] result1 = new byte[result.readableBytes()];
            result.readBytes(result1);
            result.release();
            final String ss = new String(result1);
    
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
    
                    Toast.makeText(MainActivity.this, "接收成功" + ss, Toast.LENGTH_SHORT).show();
                }
            });
        }
    
        //连接状态变化的时候 会走这
        @Override
        public void onServiceStatusConnectChanged(final int statusCode) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    if (statusCode == NettyListener.STATUS_CONNECT_SUCCESS) {
                        Log.e(TAG, "STATUS_CONNECT_SUCCESS:");
                        if (nettyClient.getConnectStatus()) {
                            Toast.makeText(MainActivity.this, "连接成功", Toast.LENGTH_SHORT).show();
                        }
                    } else {
                        Log.e(TAG, "onServiceStatusConnectChanged:" + statusCode);
                        if (!nettyClient.getConnectStatus()) {
                            Toast.makeText(MainActivity.this, "网路不好，正在重连", Toast.LENGTH_SHORT).show();
                        }
                    }
                }
            });
        }
    }

基本就这些了，我觉得我写非常清楚， 按照步骤的话直接就可以实现，  
如果想知道到底能不能使用，能不能行。  
可以使用工具…等等，肯定是能用的，好吗？？？！

哈哈，模拟服务端的话，可以下载个 ，windows还是mac都有，网上找就有，我没有提供链接。

# sokit #

![sokitsokit.png好了好了，可算写完了，技术太菜望见谅，我是一名又懒又菜的猿。][sokitsokit.png]

[https_download.csdn.net_download_binbinxiaoz_10488657]: https://download.csdn.net/download/binbinxiaoz/10488657
[sokitsokit.png]: /images/20230521/44794fb4fdde45929b50bb100f0fafe1.png