Android学习

套接字或插座(socket)是一种软件形式的抽象，用于表达两台机器间一个连接的“终端”。针对一个特定的连接，每台机器上都有一个“套接字”，可以想象它们之间有一条虚拟的“线缆”。Java有两个基于数据流的套接字类：ServerSocket，服务器用它“侦听”进入的连接；Socket，客户端用它初始一次连接。侦听套接字只能接收新的连接请求，不能接收实际的数据包。套接字是基于TCP/IP实现的，它是用来提供一个访问TCP的服务接口，或者说套接字socket是TCP的应用编程接口API，通过它应用层就可以访问TCP提供的服务。在JAVA中，我们用ServerSocket、Socket类创建一个套接字连接，从套接字得到的结果是一个InputStream以及OutputStream对象，以便将连接作为一个IO流对象对待。通过IO流可以从流中读取数据或者写数据到流中，读写IO流会有异常IOException产生。

套接字底层是基于TCP的，所以socket的超时和TCP超时是相同的。下面先讨论套接字读写缓冲区，接着讨论连接建立超时、读写超时以及JAVA套接字编程的嵌套异常捕获和一个超时例子程序的抓包示例。

1、socket读写缓冲区

一旦创建了一个套接字实例，操作系统就会为其分配缓冲区以存放接收和要发送的数据。

JAVA可以设置读写缓冲区的大小setReceiveBufferSize(intsize)、setSendBufferSize(intsize)。

向输出流写数据并不意味着数据实际上已经被发送，它们只是被复制到了发送缓冲区队列SendQ，就是在Socket的OutputStream上调用 flush()方法，也不能保证数据能够立即发送到网络。真正的数据发送是由操作系统的TCP协议栈模块从缓冲区中取数据发送到网络来完成的。当有数据从网络来到时，TCP协议栈模块接收数据并放入接收缓冲区队列RecvQ，输入流InputStream通过read方法从RecvQ中取出数据。

2、socket连接建立超时

socket连接建立是基于TCP的连接建立过程。TCP的连接需要通过3次握手报文来完成，开始建立TCP连接时需要发送同步SYN报文，然后等待确认报文SYN+ACK，最后再发送确认报文ACK。TCP连接的关闭通过4次挥手来完成，主动关闭TCP连接的一方发送FIN报文，等待对方的确认报文；被动关闭的一方也发送FIN报文，然等待确认报文。

正在等待TCP连接请求的一端有一个固定长度的连接队列，该队列中的连接已经被TCP接受（即三次握手已经完成），但还没有被应用层所接受。TCP接受一个连接是将其放入这个连接队列，而应用层接受连接是将其从该队列中移出。应用层可以通过设置backlog变量来指明该连接队列的最大长度，即已被TCP接受而等待应用层接受的最大连接数。

当一个连接请求SYN到达时，TCP确定是否接受这个连接。如果队列中还有空间，TCP模块将对SYN进行确认并完成连接的建立。但应用层只有在三次握手中的第三个报文收到后才会知道这个新连接。如果队列没有空间，TCP将不理会收到的SYN。

如果应用层不能及时接受已被TCP接受的连接，这些连接可能占满整个连接队列，新的连接请求可能不被响应而会超时。如果一个连接请求SYN发送后，一段时间后没有收到确认SYN+ACK，TCP会重传这个连接请求SYN两次，每次重传的时间间隔加倍，在规定的时间内仍没有收到SYN+ACK，TCP将放弃这个连接请求，连接建立就超时了。

JAVASocket连接建立超时和TCP是相同的，如果TCP建立连接时三次握手超时，那么导致Socket连接建立也就超时了。可以设置Socket连接建立的超时时间

[java] view plain copy

print?

1. connect(SocketAddress endpoint, int timeout)  

connect(SocketAddress endpoint, int timeout)

如果在timeout内，连接没有建立成功，在TimeoutException异常被抛出。如果timeout的值小于三次握手的时间，那么Socket连接永远也不会建立。

不同的应用层有不同的连接建立过程，Socket的连接建立和TCP一样，仅仅需要三次握手就完成连接，但有些应用程序需要交互很多信息后才能成功建立连接，比如Telnet协议，在TCP三次握手完成后，需要进行选项协商之后，Telnet连接才建立完成。

3、socket读超时

如果输入缓冲队列RecvQ中没有数据，read操作会一直阻塞而挂起线程，直到有新的数据到来或者有异常产生。调用setSoTimeout(inttimeout)可以设置超时时间，如果到了超时时间仍没有数据，read会抛出一个SocketTimeoutException，程序需要捕获这个异常，但是当前的socket连接仍然是有效的。

如果对方进程崩溃、对方机器突然重启、网络断开，本端的read会一直阻塞下去，这时设置超时时间是非常重要的，否则调用read的线程会一直挂起。

TCP模块把接收到的数据放入RecvQ中，直到应用层调用输入流的read方法来读取。如果RecvQ队列被填满了，这时TCP会根据滑动窗口机制通知对方不要继续发送数据，本端停止接收从对端发送来的数据，直到接收者应用程序调用输入流的read方法后腾出了空间。

4、socket写超时

socket的写超时是基于TCP的超时重传。超时重传是TCP保证数据可靠性传输的一个重要机制，其原理是在发送一个数据报文后就开启一个计时器，在一定时间内如果没有得到发送报文的确认ACK，那么就重新发送报文。如果重新发送多次之后，仍没有确认报文，就发送一个复位报文RST，然后关闭TCP连接。首次数据报文发送与复位报文传输之间的时间差大约为9分钟，也就是说如果9分钟内没有得到确认报文，就关闭连接。但是这个值是根据不同的TCP协议栈实现而不同。

如果发送端调用write持续地写出数据，直到SendQ队列被填满。如果在SendQ队列已满时调用write方法，则write将被阻塞，直到SendQ有新的空闲空间为止，也就是说直到一些字节传输到了接收者套接字的RecvQ中。如果此时RecvQ队列也已经被填满，所有操作都将停止，直到接收端调用read方法将一些字节传输到应用程序。

当Socket的write发送数据时，如果网线断开、对端进程崩溃或者对端机器重启动，TCP模块会重传数据，最后超时而关闭连接。下次如再调用write会导致一个异常而退出。

Socket写超时是基于TCP协议栈的超时重传机制，一般不需要设置write的超时时间，也没有提供这种方法。

5、双重嵌套异常捕获

如果ServerSocket、Socket构造失败，只需要仅仅捕获这个构造失败异常而不需要调用套接字的close方法来释放资源（必须保证构造失败后不会留下任何需要清除的资源），因为这时套接字内部资源没有被成功分配。如果构造成功，必须进入一个try finally语句块里调用close释放套接字。请参照下面例子程序。

[java] view plain copy

print?

1. import java.net.*;  
2. import java.io.*;  
3.   
4. public class SocketClientTest {  
5.     public static final int PORT = 8088;  
6.   
7.     public static void main(String[] args) throws Exception {  
8.         InetAddress addr = InetAddress.getByName("127.0.0.1");  
9.         Socket socket = new Socket();  
10.         try {  
11.             socket.connect(new InetSocketAddress(addr, PORT), 30000);  
12.             socket.setSendBufferSize(100);  
13.             BufferedWriter out = new BufferedWriter(new OutputStreamWriter(  
14.                     socket.getOutputStream()));  
15.             int i = 0;  
16.             while (true) {  
17.                 System.out.println("client sent --- hello *** " + i++);  
18.                 out.write("client sent --- hello *** " + i);  
19.                 out.flush();  
20.                 Thread.sleep(1000);  
21.             }  
22.         } finally {  
23.             socket.close();  
24.         }  
25.     }  
26. }  
27.   
28. import java.io.*;  
29. import java.net.ServerSocket;  
30. import java.net.Socket;  
31.   
32. public class SocketServerTest {  
33.     public static final int PORT = 8088;  
34.     public static final int BACKLOG = 2;  
35.   
36.     public static void main(String[] args) throws IOException {  
37.         ServerSocket server = new ServerSocket(PORT, BACKLOG);  
38.         System.out.println("started: " + server);  
39.         try {  
40.             Socket socket = server.accept();  
41.             try {  
42.                 BufferedReader in = new BufferedReader(new InputStreamReader(  
43.                         socket.getInputStream()));  
44.                 String info = null;  
45.                 while ((info = in.readLine()) != null) {  
46.                     System.out.println(info);  
47.                 }  
48.             } finally {  
49.                 socket.close();  
50.             }  
51.         } finally {  
52.             server.close();  
53.         }  
54.     }  
55. }  

import java.net.*;import java.io.*;public class SocketClientTest {public static final int PORT = 8088;public static void main(String[] args) throws Exception {InetAddress addr = InetAddress.getByName("127.0.0.1");Socket socket = new Socket();try {socket.connect(new InetSocketAddress(addr, PORT), 30000);socket.setSendBufferSize(100);BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));int i = 0;while (true) {System.out.println("client sent --- hello *** " + i++);out.write("client sent --- hello *** " + i);out.flush();Thread.sleep(1000);}} finally {socket.close();}}}import java.io.*;import java.net.ServerSocket;import java.net.Socket;public class SocketServerTest {public static final int PORT = 8088;public static final int BACKLOG = 2;public static void main(String[] args) throws IOException {ServerSocket server = new ServerSocket(PORT, BACKLOG);System.out.println("started: " + server);try {Socket socket = server.accept();try {BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));String info = null;while ((info = in.readLine()) != null) {System.out.println(info);}} finally {socket.close();}} finally {server.close();}}}

执行上面的程序，在程序运行一会儿之后，断开client和server之间的网络连接，在机器上输出如下：

Server上的输出：

[plain] view plain copy

print?

1. Echoing:client sent -----hello0  
2.   
3. Echoing:client sent -----hello1  
4. Echoing:client sent -----hello2  
5. Echoing:client sent -----hello3  
6. Echoing:client sent -----hello4  
7. Echoing:client sent -----hello5  
8. Echoing:client sent -----hello6  

Echoing:client sent -----hello0Echoing:client sent -----hello1Echoing:client sent -----hello2Echoing:client sent -----hello3Echoing:client sent -----hello4Echoing:client sent -----hello5Echoing:client sent -----hello6

断开了网络连接之后没有数据输出。

Client上的输出：

[plain] view plain copy

print?

1. socket default timeout = 0  
2. socket = Socket[addr=/10.15.9.99,port=8088,localport=4691]  
3. begin to read  
4. client sent --- hello *** 0  
5. client sent --- hello *** 1  
6. client sent --- hello *** 2  
7. client sent --- hello *** 3  
8. client sent --- hello *** 4  
9. client sent --- hello *** 5  
10. client sent --- hello *** 6  
11. client sent --- hello *** 7  
12. client sent --- hello *** 8  
13. client sent --- hello *** 9  
14. client sent --- hello *** 10  

socket default timeout = 0socket = Socket[addr=/10.15.9.99,port=8088,localport=4691]begin to readclient sent --- hello *** 0client sent --- hello *** 1client sent --- hello *** 2client sent --- hello *** 3client sent --- hello *** 4client sent --- hello *** 5client sent --- hello *** 6client sent --- hello *** 7client sent --- hello *** 8client sent --- hello *** 9client sent --- hello *** 10

断开网络连接后客户端进程挂起：

[plain] view plain copy

print?

1. java.net.SocketException : Connection reset by peer: socket write error  
2.     at java.net.SocketOutputStream.socketWrite0( Native Method )  
3.     at java.net.SocketOutputStream.socketWrite( SocketOutputStream.java:92 )  
4.     at java.net.SocketOutputStream.write( SocketOutputStream.java:136 )  
5.     at sun.nio.cs.StreamEncoder.writeBytes( StreamEncoder.java:202 )  
6.     at sun.nio.cs.StreamEncoder.implFlushBuffer( StreamEncoder.java:272 )  
7.     at sun.nio.cs.StreamEncoder.implFlush( StreamEncoder.java:276 )  
8.     at sun.nio.cs.StreamEncoder.flush( StreamEncoder.java:122 )  
9.     at java.io.OutputStreamWriter.flush( OutputStreamWriter.java:212 )  
10.     at java.io.BufferedWriter.flush( BufferedWriter.java:236 )  
11.     at com.xtera.view.SocketClientTest.main( SocketClientTest.java:99 )  

java.net.SocketException : Connection reset by peer: socket write error    at java.net.SocketOutputStream.socketWrite0( Native Method )    at java.net.SocketOutputStream.socketWrite( SocketOutputStream.java:92 )    at java.net.SocketOutputStream.write( SocketOutputStream.java:136 )    at sun.nio.cs.StreamEncoder.writeBytes( StreamEncoder.java:202 )    at sun.nio.cs.StreamEncoder.implFlushBuffer( StreamEncoder.java:272 )    at sun.nio.cs.StreamEncoder.implFlush( StreamEncoder.java:276 )    at sun.nio.cs.StreamEncoder.flush( StreamEncoder.java:122 )    at java.io.OutputStreamWriter.flush( OutputStreamWriter.java:212 )    at java.io.BufferedWriter.flush( BufferedWriter.java:236 )    at com.xtera.view.SocketClientTest.main( SocketClientTest.java:99 )

当hello6被发送到server端后，网络连接被断开，这时server端不能接收任何数据而挂起。client端仍然继续发送数据，实际上hello7、hello8、hello9、hello10都被复制到SendQ队列中，write方法立即返回。当client的SendQ队列被填满之后，write方法就被阻塞。TCP模块在发送报文hello7之后，没有收到确认而超时重传，再重传几次之后关闭了TCP连接，同时导致被阻塞的 write方法异常返回。

通过抓包工具，我们可以看到超时重传的报文。

6、判断远端服务器是否已经断开连接

如何判断远端服务器是否已经断开连接，如果断开那么需要重新连接。首先想到socket类的方法isClosed()、isConnected()、isInputStreamShutdown()、isOutputStreamShutdown()等，但经过试验并查看相关文档，这些方法都是本地端的状态，无法判断远端是否已经断开连接。然后想到是否可以通过OutputStream发送一段测试数据，如果发送失败就表示远端已经断开连接，类似ping，但是这样会影响到正常的输出数据，远端无法把正常数据和测试数据分开。最后又回到socket类，发现有一个方法sendUrgentData，查看文档后得知它会往输出流发送一个字节的数据，只要对方Socket的SO_OOBINLINE属性没有打开，就会自动舍弃这个字节，而SO_OOBINLINE属性默认情况下就是关闭的。于是，下面一段代码就可以判断远端是否断开了连接：

[java] view plain copy

print?

1. try{  
2.       socket.sendUrgentData(0xFF);  
3. }catch(Exception ex){  
4.       reconnect();  
5. }  

try{      socket.sendUrgentData(0xFF);}catch(Exception ex){      reconnect();}

用ping实现

[java] view plain copy

print?

1. import java.io.BufferedReader;  
2. import java.io.IOException;  
3. import java.io.InputStreamReader;  
4.   
5. public class test {  
6.     static BufferedReader bufferedReader;  
7.   
8.     public static void main(String[] args) throws IOException {  
9.         try {  
10.             Process process = Runtime.getRuntime().exec("ping 192.168.1.104");// 判断是否连接的IP;  
11.             bufferedReader = new BufferedReader(new InputStreamReader(  
12.                     process.getInputStream()));  
13.             String connectionStr = "";  
14.             while ((connectionStr = bufferedReader.readLine()) != null) {  
15.                 System.out.println(connectionStr);  
16.             }  
17.         } catch (IOException e) {  
18.             e.printStackTrace();  
19.         } finally {  
20.             bufferedReader.close();  
21.         }  
22.     }  
23. }  

import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class test {static BufferedReader bufferedReader;public static void main(String[] args) throws IOException {try {Process process = Runtime.getRuntime().exec("ping 192.168.1.104");// 判断是否连接的IP;bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));String connectionStr = "";while ((connectionStr = bufferedReader.readLine()) != null) {System.out.println(connectionStr);}} catch (IOException e) {e.printStackTrace();} finally {bufferedReader.close();}}}

ping的方法有个严重的BUG，就是你只能判断对方是否连接网络，而不能判断客户端是否开启。我在写聊天室时经常要注意客户端异常退出的问题(比如客户直接调用任务管理器结束程序进程)，其实在通过socket.getoutstream和socket.getinputstream流对客户端发送、接受信息时如果socket没连接上是会抛出异常的，这也就是为什么Java会要求网络编程都要写在try里面，所以只要在catch里面写入客户端退出的处理就行了，没必要专门去想什么方法。

7、Android socket编程

SocketServer类，服务器实现：

[java] view plain copy

print?

1. import java.io.BufferedReader;  
2. import java.io.IOException;  
3. import java.io.InputStreamReader;  
4. import java.io.PrintWriter;  
5. import java.net.ServerSocket;  
6. import java.net.Socket;  
7.   
8. public class SocketServer {  
9.   
10.     ServerSocket sever;  
11.   
12.     public SocketServer(int port) {  
13.         try {  
14.             sever = new ServerSocket(port);  
15.         } catch (IOException e) {  
16.             e.printStackTrace();  
17.         }  
18.     }  
19.   
20.     public void beginListen() {  
21.         while (true) {  
22.             try {  
23.                 final Socket socket = sever.accept();  
24.                 new Thread(new Runnable() {  
25.                     public void run() {  
26.                         BufferedReader in;  
27.                         try {  
28.                             in = new BufferedReader(new InputStreamReader(  
29.                                     socket.getInputStream(), "UTF-8"));  
30.                             PrintWriter out = new PrintWriter(  
31.                                     socket.getOutputStream());  
32.                             while (!socket.isClosed()) {  
33.                                 String str;  
34.                                 str = in.readLine();  
35.                                 out.println("Hello!world!! " + str);  
36.                                 out.flush();  
37.                                 if (str == null || str.equals("end"))  
38.                                     break;  
39.                                 System.out.println(str);  
40.                             }  
41.                             socket.close();  
42.                         } catch (IOException e) {  
43.                             e.printStackTrace();  
44.                         }  
45.                     }  
46.                 }).start();  
47.             } catch (IOException e) {  
48.                 e.printStackTrace();  
49.             }  
50.         }  
51.     }  
52. }  

import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;public class SocketServer {ServerSocket sever;public SocketServer(int port) {try {sever = new ServerSocket(port);} catch (IOException e) {e.printStackTrace();}}public void beginListen() {while (true) {try {final Socket socket = sever.accept();new Thread(new Runnable() {public void run() {BufferedReader in;try {in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));PrintWriter out = new PrintWriter(socket.getOutputStream());while (!socket.isClosed()) {String str;str = in.readLine();out.println("Hello!world!! " + str);out.flush();if (str == null || str.equals("end"))break;System.out.println(str);}socket.close();} catch (IOException e) {e.printStackTrace();}}}).start();} catch (IOException e) {e.printStackTrace();}}}}

服务器端调用：

[java] view plain copy

print?

1. public class TestSocketServer {  
2.   
3.     public static void main(String[] argvs) {  
4.         SocketServer server = new SocketServer(12345);  
5.         server.beginListen();  
6.     }  
7. }  

public class TestSocketServer {public static void main(String[] argvs) {SocketServer server = new SocketServer(12345);server.beginListen();}}

客户端实现：

[java] view plain copy

print?

1. import java.io.BufferedReader;  
2. import java.io.BufferedWriter;  
3. import java.io.IOException;  
4. import java.io.InputStreamReader;  
5. import java.io.OutputStreamWriter;  
6. import java.io.PrintWriter;  
7. import java.net.Socket;  
8.   
9. import android.app.Activity;  
10. import android.os.Bundle;  
11. import android.util.Log;  
12. import android.view.View;  
13. import android.widget.Button;  
14. import android.widget.EditText;  
15. import android.widget.TextView;  
16.   
17. public class SocketClientDemo extends Activity implements Runnable {  
18.     private TextView tv_msg = null;  
19.     private EditText ed_msg = null;  
20.     private Button btn_send = null;  
21.     private static final String HOST = "192.168.1.223";  
22.     private static final int PORT = 12345;  
23.     private Socket socket = null;  
24.     private BufferedReader in = null;  
25.     private PrintWriter out = null;  
26.     private String content = "";  
27.   
28.     /** Called when the activity is first created. */  
29.     @Override  
30.     public void onCreate(Bundle savedInstanceState) {  
31.         super.onCreate(savedInstanceState);  
32.         setContentView(R.layout.activity_main);  
33.         tv_msg = (TextView) findViewById(R.id.TextView);  
34.         ed_msg = (EditText) findViewById(R.id.EditText01);  
35.         btn_send = (Button) findViewById(R.id.Button01);  
36.         try {  
37.             socket = new Socket(HOST, PORT);  
38.             in = new BufferedReader(new InputStreamReader(  
39.                     socket.getInputStream()));  
40.             out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(  
41.                     socket.getOutputStream())), true);  
42.         } catch (IOException ex) {  
43.             ex.printStackTrace();  
44.             ShowDialog("login exception" + ex.getMessage());  
45.         }  
46.         btn_send.setOnClickListener(new Button.OnClickListener() {  
47.             @Override  
48.             public void onClick(View v) {  
49.                 // TODO Auto-generated method stub  
50.                 String msg = ed_msg.getText().toString();  
51.                 if (socket.isConnected()) {  
52.                     if (!socket.isOutputShutdown()) {  
53.                         out.println(msg);  
54.                     }  
55.                 }  
56.             }  
57.         });  
58.         new Thread(SocketDemo.this).start();  
59.     }  
60.   
61.     public void run() {  
62.         try {  
63.             while (true) {  
64.                 if (socket.isConnected()) {  
65.                     if (!socket.isInputShutdown()) {  
66.                         if ((content = in.readLine()) != null) {  
67.                             content += "\n";  
68.                             Log.d("socket", "socket:" + content);  
69.                         } else {  
70.   
71.                         }  
72.                     }  
73.                 }  
74.             }  
75.         } catch (Exception e) {  
76.             e.printStackTrace();  
77.         }  
78.     }  
79. }  

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.io.PrintWriter;import java.net.Socket;import android.app.Activity;import android.os.Bundle;import android.util.Log;import android.view.View;import android.widget.Button;import android.widget.EditText;import android.widget.TextView;public class SocketClientDemo extends Activity implements Runnable {private TextView tv_msg = null;private EditText ed_msg = null;private Button btn_send = null;private static final String HOST = "192.168.1.223";private static final int PORT = 12345;private Socket socket = null;private BufferedReader in = null;private PrintWriter out = null;private String content = "";/** Called when the activity is first created. */@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);tv_msg = (TextView) findViewById(R.id.TextView);ed_msg = (EditText) findViewById(R.id.EditText01);btn_send = (Button) findViewById(R.id.Button01);try {socket = new Socket(HOST, PORT);in = new BufferedReader(new InputStreamReader(socket.getInputStream()));out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);} catch (IOException ex) {ex.printStackTrace();ShowDialog("login exception" + ex.getMessage());}btn_send.setOnClickListener(new Button.OnClickListener() {@Overridepublic void onClick(View v) {// TODO Auto-generated method stubString msg = ed_msg.getText().toString();if (socket.isConnected()) {if (!socket.isOutputShutdown()) {out.println(msg);}}}});new Thread(SocketDemo.this).start();}public void run() {try {while (true) {if (socket.isConnected()) {if (!socket.isInputShutdown()) {if ((content = in.readLine()) != null) {content += "\n";Log.d("socket", "socket:" + content);} else {}}}}} catch (Exception e) {e.printStackTrace();}}}

注意在AndroidManifest.xml中加入对网络的访问权限：

[java] view plain copy

print?

1. <uses-permission android:name="android.permission.INTERNET"/>  

<uses-permission android:name="android.permission.INTERNET"/>