#### 2.4.6 使用Socket 在本节中，我们**通过Socket来实现进程间的通信**。 Socket也称为“**套接字**”，是网络通信中的概念，它分为**流式套接字和用户数据报套接字两种**，分别**对应于网络的传输控制层中的TCP和UDP协议**。 * **TCP协议是面向连接的协议，提供稳定的双向通信功能**，TCP连接的建立**需要经过“三次握手”才能完成**，为了提供**稳定的数据传输功能**，其**本身提供了超时重传机制**，因此**具有很高的稳定性**； * 而**UDP是无连接的，提供不稳定的单向通信功能**，当然**UDP也可以实现双向通信功能**。 * 在**性能上，UDP具有更好的效率，其缺点是不保证数据一定能够正确传输，尤其是在网络拥塞的情况下**。 关于TCP和UDP的介绍就这么多，更详细的资料请查看相关网络资料。 接下来我们**演示一个跨进程的聊天程序**，**两个进程可以通过Socket来实现信息的传输，Socket本身可以支持传输任意字节流，这里为了简单起见，仅仅传输文本信息，很显然，这是一种IPC方式**。 使用Socket来进行通信，有两点需要注意，首先需要声明权限： ``` <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> ``` 其次要**注意不能在主线程中访问网络，因为这会导致我们的程序无法在Android 4.0及其以上的设备中运行**，会抛出如下异常：`android.os.NetworkOnMainThreadException`。而且**进行网络操作很可能是耗时的，如果放在主线程中会影响程序的响应效率，从这方面来说，也不应该在主线程中访问网络**。 下面就开始设计我们的聊天室程序了，比较简单，**首先在远程Service建立一个TCP服务，然后在主界面中连接TCP服务，连接上了以后，就可以给服务端发消息。对于我们发送的每一条文本消息，服务端都会随机地回应我们一句话。为了更好地展示Socket的工作机制，在服务端我们做了处理，使其能够和多个客户端同时建立连接并响应**。 先看一下**服务端的设计**，**当Service启动时，会在线程中建立TCP服务，这里监听的是8688端口，然后就可以等待客户端的连接请求**。 * 当**有客户端连接时**，就会**生成一个新的Socket，通过每次新创建的Socket就可以分别和不同的客户端通信了**。服务端每收到一次客户端的消息就会随机回复一句话给客户端。 * 当**客户端断开连接时**，**服务端这边也会相应的关闭对应Socket并结束通话线程**，这点是如何做到的呢？方法有很多，这里是**通过判断服务端输入流的返回值来确定的，当客户端断开连接后，服务端这边的输入流会返回null，这个时候我们就知道客户端退出了**。 服务端的代码如下所示。 ~~~ package com.ryg.chapter_2.socket; public class TCPServerService extends Service { private boolean mIsServiceDestoryed = false; private String[] mDefinedMessages = new String[] { "你好啊，哈哈", "请问你叫什么名字呀？", "今天北京天气不错啊，shy", "你知道吗？我可是可以和多个人同时聊天的哦", "给你讲个笑话吧：据说爱笑的人运气不会太差，不知道真假。" }; @Override public void onCreate() { new Thread(new TcpServer()).start(); super.onCreate(); } @Override public IBinder onBind(Intent intent) { return null; } @Override public void onDestroy() { mIsServiceDestoryed = true; super.onDestroy(); } private class TcpServer implements Runnable { @SuppressWarnings("resource") @Override public void run() { ServerSocket serverSocket = null; try { //监听本地8688端口 serverSocket = new ServerSocket(8688); } catch (IOException e) { System.err.println("establish tcp server failed, port:8688"); e.printStackTrace(); return; } while (!mIsServiceDestoryed) { try { // 接受客户端请求 final Socket client = serverSocket.accept(); System.out.println("accept"); //这里建议不要显示创建线程，尽量使用线程池。 //线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 // 说明：使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。 // 如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。 new Thread() { @Override public void run() { try { responseClient(client); } catch (IOException e) { e.printStackTrace(); } }; }.start(); } catch (IOException e) { e.printStackTrace(); } } } } private void responseClient(Socket client) throws IOException { // 用于接收客户端消息 BufferedReader in = new BufferedReader(new InputStreamReader( client.getInputStream())); // 用于向客户端发送消息 PrintWriter out = new PrintWriter(new BufferedWriter( new OutputStreamWriter(client.getOutputStream())), true); out.println("欢迎来到聊天室！"); while (!mIsServiceDestoryed) { String str = in.readLine(); System.out.println("msg from client:" + str); if (str == null) { //客户端断开连接 break; } int i = new Random().nextInt(mDefinedMessages.length); String msg = mDefinedMessages[i]; out.println(msg); System.out.println("send :" + msg); } System.out.println("client quit."); // 关闭流 MyUtils.close(out); MyUtils.close(in); client.close(); } } ~~~ 接着看一下客户端，**客户端Activity启动**时，会**在onCreate中开启一个线程去连接服务端Socket，至于为什么用线程在前面已经做了介绍（不要在主线程中访问网络）。为了确定能够连接成功，这里采用了超时重连的策略，每次连接失败后都会重新建立尝试建立连接。当然为了降低重试机制的开销，我们加入了休眠机制，即每次重试的时间间隔为1000毫秒**。 Socket socket = null; //超时重连机制，只有当socket不为空，才是连接成功 while (socket == null) { try { socket = new Socket("localhost", 8688); mClientSocket = socket; mPrintWriter = new PrintWriter(new BufferedWriter( new OutputStreamWriter(socket.getOutputStream())), true); mHandler.sendEmptyMessage(MESSAGE_SOCKET_CONNECTED); System.out.println("connect server success."); } catch (IOException e) { SystemClock.sleep(1000); System.out.println("connect tcp server failed, retry..."); } } **服务端连接成功以后，就可以和服务端进行通信了**。 下面的代码**在线程中通过while循环不断地去读取服务端发送过来的消息，同时当Activity退出时，就退出循环并终止线程**。 ~~~ // 接收服务器端的消息 BufferedReader br = new BufferedReader(new InputStreamReader( socket.getInputStream())); while (!TCPClientActivity.this.isFinishing()) { String msg = br.readLine(); System.out.println("receive :" + msg); if (msg != null) { String time = formatDateTime(System.currentTimeMillis()); final String showedMsg = "server " + time + ":" + msg + "\n"; mHandler.obtainMessage(MESSAGE_RECEIVE_NEW_MSG, showedMsg) .sendToTarget(); } } ~~~ 同时，**当Activity退出时，还要关闭当前的Socket**，如下所示。 ~~~ @Override protected void onDestroy() { if (mClientSocket != null) { try { mClientSocket.shutdownInput(); mClientSocket.close(); } catch (IOException e) { e.printStackTrace(); } } super.onDestroy(); } ~~~ 接着是发送消息的过程，这个就很简单了，这里不再详细说明。客户端的完整代码如下： ~~~ package com.ryg.chapter_2.socket; public class TCPClientActivity extends Activity implements OnClickListener { private static final int MESSAGE_RECEIVE_NEW_MSG = 1; private static final int MESSAGE_SOCKET_CONNECTED = 2; private Button mSendButton; private TextView mMessageTextView; private EditText mMessageEditText; private PrintWriter mPrintWriter; private Socket mClientSocket; @SuppressLint("HandlerLeak") private Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MESSAGE_RECEIVE_NEW_MSG: { mMessageTextView.setText(mMessageTextView.getText() + (String) msg.obj); break; } case MESSAGE_SOCKET_CONNECTED: { mSendButton.setEnabled(true); break; } default: break; } } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_tcpclient); mMessageTextView = (TextView) findViewById(R.id.msg_container); mSendButton = (Button) findViewById(R.id.send); mSendButton.setOnClickListener(this); mMessageEditText = (EditText) findViewById(R.id.msg); Intent service = new Intent(this, TCPServerService.class); startService(service); new Thread() { @Override public void run() { connectTCPServer(); } }.start(); } @Override protected void onDestroy() { if (mClientSocket != null) { try { mClientSocket.shutdownInput(); mClientSocket.close(); } catch (IOException e) { e.printStackTrace(); } } super.onDestroy(); } @Override public void onClick(View v) { if (v == mSendButton) { final String msg = mMessageEditText.getText().toString(); if (!TextUtils.isEmpty(msg) && mPrintWriter != null) { mPrintWriter.println(msg); mMessageEditText.setText(""); String time = formatDateTime(System.currentTimeMillis()); final String showedMsg = "self " + time + ":" + msg + "\n"; mMessageTextView.setText(mMessageTextView.getText() + showedMsg); } } } @SuppressLint("SimpleDateFormat") private String formatDateTime(long time) { return new SimpleDateFormat("(HH:mm:ss)").format(new Date(time)); } private void connectTCPServer() { Socket socket = null; //超时重连机制，只有当socket不为空，才是连接成功 while (socket == null) { try { socket = new Socket("localhost", 8688); mClientSocket = socket; mPrintWriter = new PrintWriter(new BufferedWriter( new OutputStreamWriter(socket.getOutputStream())), true); mHandler.sendEmptyMessage(MESSAGE_SOCKET_CONNECTED); System.out.println("connect server success"); } catch (IOException e) { SystemClock.sleep(1000); System.out.println("connect tcp server failed, retry..."); } } try { // 接收服务器端的消息 BufferedReader br = new BufferedReader(new InputStreamReader( socket.getInputStream())); while (!TCPClientActivity.this.isFinishing()) { String msg = br.readLine(); System.out.println("receive :" + msg); if (msg != null) { String time = formatDateTime(System.currentTimeMillis()); final String showedMsg = "server " + time + ":" + msg + "\n"; mHandler.obtainMessage(MESSAGE_RECEIVE_NEW_MSG, showedMsg) .sendToTarget(); } } System.out.println("quit..."); MyUtils.close(mPrintWriter); MyUtils.close(br); socket.close(); } catch (IOException e) { e.printStackTrace(); } } } ~~~ 上述就是**通过Socket来进行进程间通信的实例，除了采用TCP套接字，还可以采用UDP套接字**。 另外，上面的例子仅仅是一个示例，实际上**通过Socket不仅仅能实现进程间的通信，还可以实现设备间的通信，当然前提是这些设备之间的IP地址互相可见**，这其中又涉及许多复杂的概念，这里就不一一介绍了。下面看一下上述例子的运行效果，如图2-9所示。 :-:  图2-9 Socket通信示例