Android IPC进程间通信（六）Socket

网络通信之Socket

特点：功能强大，可通过网络传输字节流，支持一对多并发即时通信。
不支持RPC。
服务端实现:

public class SorviceSocket extends Service {

    private static final String TAG = "SorviceSocket";
    private static final int PORT = 5000;
    private boolean mIsServiceDestory = false;


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

    @Override
    public void onCreate() {
        super.onCreate();
        new Thread(new MyRunnable()).start();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mIsServiceDestory = true;
    }

    private class MyRunnable implements Runnable {
        @Override
        public void run() {
            serverReceviedByTcp();
        }
    }

    public void serverReceviedByTcp() {
        // 声明一个ServerSocket对象
        ServerSocket serverSocket = null;
        try {
            // 创建一个ServerSocket对象，并让这个Socket在5000端口监听
            serverSocket = new ServerSocket(PORT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //一直等待客户端的链接
        while (!mIsServiceDestory) {
            // 调用ServerSocket的accept()方法，接受客户端所发送的请求，
            // 如果客户端没有发送数据，那么该线程就停滞不继续
            try {
               final Socket socket = serverSocket.accept();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            readAndWriteData(socket);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void readAndWriteData(Socket socket) throws IOException {
        BufferedReader bReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintWriter pWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())));
        String line = null;
        StringBuilder sb = new StringBuilder();
        //一直读取
        while (!mIsServiceDestory) {
            line = bReader.readLine();
            //无流数据则断开链接
            if (line == null){
                break;
            }
            sb.append(line);
            Log.d(TAG, "connectServerWithTCPSocket: " + sb.toString());
            pWriter.println("你好客户端，这是来自服务端的问候！");
        }
        //不要关闭服务端serverSocket
        bReader.close();
        pWriter.close();
        socket.close();
    }
}

客户端实现：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "MainActivity";
    private static final int PORT = 5000;
    private Socket mSocket = null;
    private PrintWriter pWriter;
    private BufferedReader bReader;
    private Button mSendBtn;
    public static final int MSG_DATA = 100;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mSendBtn = findViewById(R.id.id_btn);
        mSendBtn.setOnClickListener(this);
        Intent intent = new Intent(MainActivity.this, SorviceSocket.class);
        startService(intent);
        new Thread(new MyRunnable()).start();
    }

    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
                case MSG_DATA:
                    String strMsg = msg.getData().toString();
                    Toast.makeText(MainActivity.this, strMsg, Toast.LENGTH_SHORT).show();
                    break;
            }
        }
    };

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.id_btn:
                if (pWriter !=null){
                    pWriter.println("你好服务器");
                }
                // 发送读取的数据到服务端
                break;

            default:
                break;
        }
    }

    private class MyRunnable implements Runnable {
        @Override
        public void run() {
            connectServerWithTCPSocket();
        }
    }

    protected void connectServerWithTCPSocket() {
        while (mSocket == null) {
            try {
                // 创建一个Socket对象，并指定服务端的IP及端口号
                mSocket = new Socket("locketHost", PORT);
                pWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(mSocket.getOutputStream())));
                bReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream()));
                String line = null;
                StringBuilder sb = new StringBuilder();
                while (!MainActivity.this.isFinishing()) {
                    line = bReader.readLine();
                    if (line == null) {
                        break;
                    }
                    sb.append(line);
                    mHandler.obtainMessage(MSG_DATA,sb.toString());
                    Log.d(TAG, "connectServerWithTCPSocket: " + sb.toString());
                }
                bReader.close();
                pWriter.close();
                mSocket.close();
            } catch (UnknownHostException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}