【简单封装】Android——TCP服务端

使用

mTCPServer = new PZHelp_TCPServer(3232, new PZHelp_TCPServer.ReceiveListener() {
    
    
    @Override
    public void onFail(String err) {
    
    
        //错误
        Log.e(TAG, "onFail: " + err);
    }

    @Override
    public void Receive(Socket socket, String receive) {
    
    
        //成功接收到数据
        Log.d(TAG, "Socket: "+socket);//当前数据连接
        Log.d(TAG, "String: "+receive);//数据
    }
});
mTCPServer.start();

封装类

public class PZHelp_TCPServer extends Thread {
    
    
    private static final String TAG = "PZHelp_TCPServer";

    //Server
    private ServerSocket                  serverSocket;
    private int                           port;
    //TCPServer标志位
    private boolean                       isTCPServerOpen = false;
    //存放所有客户端线程
    private ArrayList<ServerSocketThread> clientList      = new ArrayList<>();
    //回调
    private ReceiveListener               listener;

    public PZHelp_TCPServer(int port, ReceiveListener listener) {
    
    
        this.port = port;
        this.listener = listener;
    }

    @Override
    public synchronized void start() {
    
    
        isTCPServerOpen = true;
        super.start();
    }

    /**
     * TCPServer主体
     */
    @Override
    public void run() {
    
    
        try {
    
    
            serverSocket = new ServerSocket(port);
            while (isTCPServerOpen) {
    
    
                Socket socket = serverSocket.accept();
                if (socket != null) {
    
    
                    Log.d(TAG, "run: 新的客户端：" + socket);
                    new ServerSocketThread(socket);
                }
            }
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * 获取当前Server的连接数
     *
     * @return 连接数
     */
    public int getClientNum() {
    
    
        return clientList.size();
    }

    /**
     * 关闭TCPServer
     */
    void close() {
    
    
        isTCPServerOpen = false;
        try {
    
    
            serverSocket.close();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * client线程
     */
    public class ServerSocketThread extends Thread {
    
    
        private Socket      socket;
        private InputStream is = null;
        private PrintWriter pw = null;

        //接收到的数据
        String receive;
        //接收到的数据长度
        int    length;
        byte[] buff = new byte[2048];

        ServerSocketThread(Socket socket) {
    
    
            this.socket = socket;
            try {
    
    
                socket.setSoTimeout(8000);
                is = socket.getInputStream();
                pw = new PrintWriter(socket.getOutputStream(), true);
                start();
            } catch (IOException e) {
    
    
                listener.onFail(e.getMessage());
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
    
    
            clientList.add(this);
            while (isTCPServerOpen && !socket.isClosed() && !socket.isInputShutdown()) {
    
    
                try {
    
    
                    if ((length = is.read(buff)) != -1) {
    
    
                        //连接正常，接收到数据
                        receive = new String(buff, 0, length, "GBK");
                        listener.Receive(socket, receive);
                    } else {
    
    
                        Log.d(TAG, "客户端断开，关闭通讯线程: " + this);
                        break;
                    }
                } catch (SocketTimeoutException e) {
    
    
                    Log.d(TAG, "长时间未收到客户端数据，关闭通讯线程：" + this);
                    break;
                } catch (IOException e) {
    
    
                    listener.onFail("接收数据异常");
                    e.printStackTrace();
                }
            }

            //关闭通讯和线程
            try {
    
    
                socket.close();
                clientList.remove(this);
            } catch (IOException e) {
    
    
                listener.onFail("关闭与客户端之间的通讯出现异常");
                e.printStackTrace();
            }
        }

        /**
         * 发送信息
         *
         * @param msg 信息
         * @return 是否发送成功
         */
        public boolean send(String msg) {
    
    
            if (!socket.isClosed()) {
    
    
                pw.println(msg);
                pw.flush();
                return true;
            }
            return false;
        }
    }

    /**
     * 回调
     */
    public interface ReceiveListener {
    
    
        void onFail(String err);

        void Receive(Socket socket, String receive);
    }
}