Android Socket编程

花了大概两天的时间，终于把Android的Socket编程给整明白了。抽空和大家分享一下： 
Socket Programming on Android 
Socket 编程基础知识： 
主要分服务器端编程和客户端编程。 
服务器端编程步骤： 
1： 创建服务器端套接字并绑定到一个端口上（0-1023是系统预留的，最好大约1024） 
2： 套接字设置监听模式等待连接请求 
3： 接受连接请求后进行通信 
4： 返回，等待赢一个连接请求

客户端编程步骤： 
1： 创建客户端套接字（指定服务器端IP地址与端口号） 
2： 连接（Android 创建Socket时会自动连接） 
3： 与服务器端进行通信 
4： 关闭套接字

Android Socket 通信原理注意： 
1： 中间的管道连接是通过InputStream/OutputStream流实现的。 
2： 一旦管道建立起来可进行通信 
3： 关闭管道的同时意味着关闭Socket 
4： 当对同一个Socket创建重复管道时会异常 
5： 通信过程中顺序很重要：服务器端首先得到输入流，然后将输入流信息输出到其各个客户端 
    客户端先建立连接后先写入输出流，然后再获得输入流。不然活有EOFException的异常。

下面是关于在服务器端编程的代码：

1. import java.io.DataInputStream;
2. import java.io.DataOutputStream;
3. import java.io.IOException;
4. import java.net.ServerSocket;
5. import java.net.Socket;
6. import java.util.ArrayList;
7. /**
8. *@author Andrew.Lee
9. *@create 2011-6-1 下午04:45:19
10. *@version 1.0
11. *@see
12. */
13. public class Server {
14. static ServerSocket aServerSocket = null; // Server Socet.
15. DataInputStream aDataInput = null; // Server input Stream that to
16. // receive msg from client.
17. DataOutputStream aDataOutput = null; // Server output Stream that to
18. static ArrayList list = new ArrayList();
19. public static void main(String[] args) {
20. try {
21. aServerSocket = new ServerSocket(50003); // listen 8888 port.
22. System.out.println("already listen 50003 port.");
23. } catch (Exception e) {
24. e.printStackTrace();
25. }
26. int num = 0;
27. while (num < 10) {
28. Socket aSessionSoket = null;
29. try {
30. aSessionSoket = aServerSocket.accept();
31. MyThread thread = new Server().new MyThread(aSessionSoket);
32. thread.start();
33. num = list.size();
34. } catch (IOException e1) {
35. // TODO Auto-generated catch block
36. e1.printStackTrace();
37. }
38. }
39. }
40. class MyThread extends Thread {
41. Socket aSessionSoket = null;
42. public MyThread(Socket socket) {
43. aSessionSoket = socket;
44. }
45. public void run() {
46. try {
47. aDataInput = new DataInputStream(aSessionSoket.getInputStream());
48. aDataOutput = new DataOutputStream(aSessionSoket
49. .getOutputStream());
50. list.add(aDataOutput);
51. while (true) {
52. String msg = aDataInput.readUTF(); // read msg.
53. if (!msg.equals("connect...")) {
54. System.out.println("ip: "
55. + aSessionSoket.getInetAddress());// ip.
56. System.out.println("receive msg: " + msg);
57. for (int i = 0; i < list.size(); i++) {
58. DataOutputStream output = (DataOutputStream) list
59. .get(i);
60. output.writeUTF(msg + "----" + list.size());
61. }
62. if (msg.equals("end"))
63. break;
64. }
65. aDataOutput.writeUTF("");
66. }
67. } catch (IOException e) {
68. // TODO Auto-generated catch block
69. e.printStackTrace();
70. } finally {
71. try {
72. aDataInput.close();
73. if (aDataOutput != null)
74. aDataOutput.close();
75. list.remove(aDataOutput);
76. aSessionSoket.close();
77. } catch (Exception e2) {
78. e2.printStackTrace();
79. }
80. }
81. }
82. }
83. }

注意问题：为了实现对于多个客户端的处理，使用了多线程的操作，每个线程维护一个Socket的连接与通信，新连接的Socket的管道被加入到ArrayList中。对于输出流的操作是对于所有的连接的客户端进行写数据。对于关闭了Socket的客户端管道从List中移除。 
客户端编程代码：

1. package com.daisy.android.network;
2. import java.io.DataInputStream;
3. import java.io.DataOutputStream;
4. import java.io.IOException;
5. import java.net.InetSocketAddress;
6. import java.net.Socket;
7. import java.net.SocketAddress;
8. import java.net.UnknownHostException;
9. import android.app.Activity;
10. import android.os.Bundle;
11. import android.os.Handler;
12. import android.os.Message;
13. import android.util.Log;
14. import android.view.View;
15. import android.view.View.OnClickListener;
16. import android.widget.Button;
17. import android.widget.EditText;
18. import android.widget.TextView;
19. /**
20. *@author Andrew.Lee
21. *@create 2011-5-28 下午02:26:20
22. *@version 1.0
23. *@see
24. */
25. public class SocketActivity extends Activity {
26. EditText editText = null;
27. Button sendButton = null;
28. TextView display = null;
29. Socket client = null;
30. MyHandler myHandler;
31. DataOutputStream dout;
32. DataInputStream din;
33. public void onCreate(Bundle savedInstanceState) {
34. super.onCreate(savedInstanceState);
35. setContentView(R.layout.clientsocket);
36. editText = (EditText) findViewById(R.id.message);
37. sendButton = (Button) findViewById(R.id.send);
38. display = (TextView) findViewById(R.id.display);
39. sendButton.setOnClickListener(listener);
40. try {
41. client = new Socket("192.168.0.120", 50003);
42. dout = new DataOutputStream(client.getOutputStream());
43. din = new DataInputStream(client.getInputStream());
44. } catch (UnknownHostException e) {
45. // TODO Auto-generated catch block
46. e.printStackTrace();
47. } catch (IOException e) {
48. // TODO Auto-generated catch block
49. e.printStackTrace();
50. }
51. myHandler = new MyHandler();
52. MyThread m = new MyThread();
53. m.start();
54. }
55. class MyHandler extends Handler {
56. public MyHandler() {
57. }
58. // 子类必须重写此方法,接受数据
59. @Override
60. public void handleMessage(Message msg) {
61. // TODO Auto-generated method stub
62. Log.d("MyHandler", "handleMessage......");
63. super.handleMessage(msg);
64. // 此处可以更新UI
65. if (client != null && client.isConnected()) {
66. Log.i("handler..", "*-----*");
67. try {
68. dout.writeUTF("connect...");
69. String message = din.readUTF();
70. if (!message.equals(""))
71. display.setText(display.getText().toString() + "\n"
72. + "服务器发来的消息--：" + message);
73. } catch (IOException e) {
74. // TODO Auto-generated catch block
75. e.printStackTrace();
76. }
77. }
78. }
79. }
80. class MyThread extends Thread {
81. public void run() {
82. while (true) {
83. try {
84. Thread.sleep(1000);
85. } catch (InterruptedException e) {
86. // TODO Auto-generated catch block
87. e.printStackTrace();
88. }
89. Message msg = new Message();
90. SocketActivity.this.myHandler.sendMessage(msg);
91. }
92. }
93. }
94. OnClickListener listener = new OnClickListener() {
95. @Override
96. public void onClick(View v) {
97. // TODO Auto-generated method stub
98. String sendText = editText.getText().toString();
99. try {
100. // din = new DataInputStream(client.getInputStream());
101. dout.writeUTF(sendText);
102. /*
103. * display.setText(display.getText().toString() + "\n" +
104. * "服务器发来的消息：" + din.readUTF());
105. */
106. /*
107. * display.setText(display.getText().toString() + "\n" +
108. * "服务器发来的消息--：" + din.readUTF());
109. */
110. } catch (UnknownHostException e) {
111. // TODO Auto-generated catch block
112. e.printStackTrace();
113. } catch (IOException e) {
114. // TODO Auto-generated catch block
115. e.printStackTrace();
116. }
117. }
118. };
119. }

注意：为实现对于UI的间歇性刷新操作，使用到了Handler的消息机制。

附注：以上只是对Android的Socket编程的大致思路和过程，其中缺少了对于InputStream/OututStream 的异常处理，连接超时等处理。

摘自：http://duguyidao.iteye.com/blog/1069736