Android工具类——Socket通讯

Activity中使用：

        ServiceConnection connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                TcpService.ClientBinder clientBinder = (TcpService.ClientBinder) service;
                clientBinder.startConnect();
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
            }
        };
        Intent intent = new Intent(this, TcpService.class);
        bindService(intent, connection, BIND_AUTO_CREATE);

工具类 TcpService：

public class TcpService extends Service {
    public static final String TAG = "TcpService";

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new ClientBinder();
    }

    public class ClientBinder extends Binder {
        private int mHeart_spacetime = 1000; //心跳间隔时间
        private BufferedInputStream bis;
        private BufferedOutputStream bos;
        private ReadThread mReadThread;
        private Handler mHandler = new Handler();
        private Socket mSocket;
        private ExecutorService mExecutorService;
        private int tryCount = 0;//重试次数

        public void startConnect() {
            //在子线程进行网络操作
            // Service也是运行在主线程，千万不要以为Service意思跟后台运行很像，就以为Service运行在后台子线程
            if (mExecutorService == null) {
                mExecutorService = Executors.newCachedThreadPool();
            }
            mExecutorService.execute(connectRunnable);
        }

        private Runnable connectRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    // 建立Socket连接
                    if (mSocket == null){
                        Log.d(TAG, "run: mSocket");
                        mSocket = new Socket();
                    }
                    mSocket.connect(new InetSocketAddress("119.164.215.70", 33337), 1000);
                    if (bis == null){
                        Log.d(TAG, "run: bis");
                        bis = new BufferedInputStream(mSocket.getInputStream());
                    }
                    if (bos == null){
                        Log.d(TAG, "run: bos");
                        bos = new BufferedOutputStream(mSocket.getOutputStream());
                    }

                    // 创建读取服务器心跳的线程
                    if (mReadThread == null){
                        mReadThread = new ReadThread();
                        mReadThread.start();
                    }
                    //开启心跳,每隔1秒钟发送一次心跳
                    mHandler.post(mHeartRunnable);
                    tryCount = 1;
                    Log.d(TAG, "Socket连接建立");
                } catch (Exception e) {
                    tryCount ++ ;
                    e.printStackTrace();
                    Log.d(TAG, "Socket连接建立失败,正在尝试第"+ tryCount + "次重连");
                    mHandler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mExecutorService.execute(connectRunnable);
                        }
                    },mHeart_spacetime);
                }
            }
        };

        public class ReadThread extends Thread {
            @Override
            public void run() {
                int size;
                byte[] buffer = new byte[1024];
                try {
                    while ((size = bis.read(buffer)) != -1) {
                        String str = new String(buffer, 0, size);
//                        MainActivity.serialPortUtils.sendSerialPort(buffer, MyApplication.myApplication); TODO
                        Log.d(TAG,"我收到来自服务器的消息: " +str);
                        //收到心跳消息以后，首先移除断连消息，然后创建一个新的60秒后执行断连的消息。
                        //这样每次收到心跳后都会重新创建一个60秒的延时消息，在60秒后还没收到心跳消息，表明服务器已死，就会执行断开Socket连接
                        //在60秒钟内如果收到过一次心跳消息，就表明服务器还活着，可以继续与之通讯。
                        mHandler.removeCallbacks(disConnectRunnable);
                        mHandler.postDelayed(disConnectRunnable, mHeart_spacetime * 40);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        private Runnable mHeartRunnable = new Runnable() {
            @Override
            public void run() {
                sendData();
            }
        };

        private void sendData() {
            mExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        bos.write("Xing Test！".getBytes());
                        //一定不能忘记这步操作
                        bos.flush();
                        //发送成功以后，重新建立一个心跳消息
                        mHandler.postDelayed(mHeartRunnable, mHeart_spacetime);
                        Log.d(TAG, "我发送给了服务器的消息:  Xing Test"  );
                    } catch (Exception e) {
                        e.printStackTrace();
                        Log.d(TAG, "心跳任务发送失败，正在尝试第"+ tryCount + "次重连");
                        //mExecutorService.schedule(connectRunnable,mHeart_spacetime, TimeUnit.SECONDS);
                        mExecutorService.execute(connectRunnable);
                    }
                }
            });
        }

        private Runnable disConnectRunnable = new Runnable() {
            @Override
            public void run() {
                disConnect();
            }
        };

        private void disConnect() {
            mExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Log.d(TAG, "正在执行断连: disConnect");
                        //执行Socket断连
                        mHandler.removeCallbacks(mHeartRunnable);
                        if (mReadThread != null) {
                            mReadThread.interrupt();
                            mReadThread = null;
                        }

                        if (bos != null) {
                            bos.close();
                            bos =null;
                        }

                        if (bis != null) {
                            bis.close();
                            bis =null;
                        }

                        if (mSocket != null) {
                            mSocket.shutdownInput();
                            mSocket.shutdownOutput();
                            mSocket.close();
                            mSocket= null;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

别忘了在AndroidManifest.xml注册：

 <service android:name=".Util.TcpService"/>