Android笔记--TCP Scoket（字符串收发）

2019独角兽企业重金招聘Python工程师标准>>>

Tcp的连接和断开其实也就是很简短的代码，比较麻烦的就是断线检测重连等机制，如何设置的比较合理节省资源。

本代码暂时只是做简单的发送接收，并没有做比较严格的发送接收队列。

首先是断线，socket.isClosed() || !socket.isConnected()这两个socket方法都只是本地方法，如果在服务器端断开连接的话，这两个方法是检测不出来的。网上查了一下，据说是有4中方法来检测连接是否已经真正断开，方便起见我选用了sendUrgentData（）方法，

socket.sendUrgentData(0);//发送1个字节的紧急数据，默认情况下，服务器端没有开启紧急数据处理，不影响正常通信

为了验证发送状态，我再每次发送消息之前都会做一次检测，如果是频繁发送数据，不建议加上这个。

接收线程是阻塞的，所以不太好时时刻刻做这检测，所以我另外加了一个心跳机制，每秒（这个时间是非常频繁的）检测一次连接是否断开，如果断开则启动重连机制。

ALog类是我自定的输出打印类，用Log替换一下即可

package com.imxiaoyu.common.impl;

/**
 * 回调一个字符串
 * Created by 她叫我小渝 on 2016/11/1.
 */

public interface OnStringListener {
    void onClick(String str);
}

整个类的代码：

package com.ilink.ght.core.network.helper;

import android.os.Handler;
import android.os.Message;

import com.imxiaoyu.common.impl.OnStringListener;
import com.imxiaoyu.common.impl.OnSuccessListener;
import com.imxiaoyu.common.utils.ALog;
import com.imxiaoyu.common.utils.ByteUtils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * tcp发送接受帮助类
 * Created by XiaoYu on 2017/2/22.
 */

public class TcpHelper {

    private static String content;
    private static List<OnStringListener> onStringListenerList;


    /**
     * 常量
     */
    private static final String HOST = "192.168.0.191";
    private static final int PORT = 34952;

    /**
     * 变量
     */
    private static Socket socket = null;
    private static BufferedReader in = null;
    private static PrintWriter out = null;

    /**
     * TCP连接
     */
    public static void connTCP() {
        new Thread() {
            @Override
            public void run() {
                try {
                    socket = new Socket(HOST, PORT);
                    in = new BufferedReader(new InputStreamReader(socket
                            .getInputStream()));
                    out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                            socket.getOutputStream())), true);
                    ALog.e("连接成功");
                    Message msg = new Message();
                    msg.obj = "连接成功";
                    mHandler.sendMessage(msg);
                    if (checkConn()) {
                        receiveMsg();//注册消息接收
                        ALog.e("连接注册消息接收");
                        handler.postAtTime(runnable, 1000);
                    } else {
                        ALog.e("服务里，TCP连接失败");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    ALog.e("TCP连接失败,尝试重连");
                    connTCP();
                }
            }
        }.start();
        startPing();
    }

    /**
     * 断开连接
     */
    public static void disConn() {
        try {
            in.close();
            out.close();
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 判断连接是否可用
     *
     * @return
     */
    public static boolean checkConn() {
        if (socket == null) {
            return false;
        }
        if (socket.isClosed() || !socket.isConnected()) {
            return false;
        }
        try {
            socket.sendUrgentData(0);//发送1个字节的紧急数据，默认情况下，服务器端没有开启紧急数据处理，不影响正常通信
            return true;
        } catch (Exception se) {
            return false;
        }
    }


    /**
     * 发送消息
     *
     * @param str
     * @param onSuccessListener
     */
    public static void sendMsg(final String str, final OnSuccessListener onSuccessListener) {
       final Handler sendHandlde = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if(msg.what==1){
                    onSuccessListener.onSuccess();
                }else{
                    String error=msg.obj+"";
                    onSuccessListener.onError(error);
                }
            }
        };

        new Thread() {
            @Override
            public void run() {
                Message msg=new Message();
                if (checkConn()) {
                    if (!socket.isOutputShutdown()) {
                        out.print(str);
                        msg.what=1;
                    } else {
                        ALog.e("发送，断开输出通道了");
                        msg.what=0;
                    }
                } else {
                    msg.what=0;
                    msg.obj="连接已断开";
                    ALog.e("连接已断开");
                }
                sendHandlde.sendMessage(msg);
            }
        }.start();

    }

    /**
     * 接收消息
     * 当连接发生变更的时候，必须要初始化一次这个方法，
     */
    public static void receiveMsg() {
        try {
            while (true) {
                if (!socket.isClosed()) {
                    if (socket.isConnected()) {
                        if (!socket.isInputShutdown()) {
                            if ((content = in.readLine()) != null) {
                                content += "\n";
                                ALog.e("接收到消息：" + content);
                                Message msg = new Message();
                                msg.obj = content;
                                mHandler.sendMessage(msg);
                            } else {
                                ALog.e("读取不到，可能连接已经断开，关闭后尝试重连");
                                disConn();
                                ALog.e("正在尝试重连");
                                connTCP();
                                break;
                            }
                        } else {
                            //输入流已经关闭
                            ALog.e("输入流已经关闭");
                        }
                    } else {
                        //是否已连接
                        ALog.e("输入流，连接已经断开");
                    }
                } else {
                    //连接已关闭
                    ALog.e("输入流，连接已经关闭");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Handler mHandler = new Handler() {
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (onStringListenerList == null) {
                onStringListenerList = new ArrayList<>();
            }
            for (int i = 0; i < onStringListenerList.size(); i++) {
                if (onStringListenerList != null) {
                    onStringListenerList.get(i).onClick(msg.obj + "");
                }
            }

        }
    };

    /**
     * 添加消息监听器
     */
    public static void addRceiveListener(OnStringListener onStringListener) {
        if (onStringListenerList == null) {
            onStringListenerList = new ArrayList<>();
        }
        if (onStringListener != null) {
            onStringListenerList.add(onStringListener);
        }
    }

    /**
     * 移除消息监听器
     *
     * @param onStringListener
     */
    public static void removeRceiveListener(OnStringListener onStringListener) {
        if (onStringListener != null) {
            for (int i = onStringListenerList.size() - 1; i >= 0; i++) {
                if (onStringListenerList.get(i) == onStringListener) {
                    onStringListenerList.remove(i);
                }
            }
        }
    }

    private static Handler handler;
    private static Runnable runnable;

    private static void startPing() {
        if (handler == null) {
            handler = new Handler();
        }
        if (runnable == null) {
            runnable = new Runnable() {
                @Override
                public void run() {
                    if (!checkConn()) {
                        ALog.e("心跳包验证失败，已经断开,尝试重连");
                        Message msg = new Message();
                        msg.obj = "心跳包验证失败，已经断开,尝试重连";
                        mHandler.sendMessage(msg);
                        disConn();
                        connTCP();
                    } else {
                        handler.postAtTime(this, 1000);
                    }
                }
            };
        }
    }
}

 

 

转载于:https://my.oschina.net/u/1462828/blog/843813