详解 Java 的 TCP 网络编程

发表于 标签 ， ，

网络编程简介

网络通讯的方式有 TCP 和 UDP 两种，其中 TCP 方式的网络通讯是指在通讯的过程中保持连接，有点类似于打电话，只需要拨打一次号码 (建立一次网络连接)，就可以多次通话 (多次传输数据)。这样方式在实际的网络编程中，由于传输可靠，类似于打电话，如果甲给乙打电话，乙说没有听清楚让甲重复一遍，直到乙听清楚为止，实际的网络传输也是这样，如果发送的一方发送的数据接收方觉得有问题，则网络底层会自动要求发送方重发，直到接收方收到为止。

在 Java 语言中，对于 TCP 方式的网络编程提供了良好的支持，在实际实现时，以 java.net.Socket 类代表客户端连接，以 java.net.ServerSocket 类代表服务器端连接。在进行网络编程时，底层网络通讯的细节已经实现了比较高的封装，所以在程序员实际编程时，只需要指定 IP 地址和端口号码就可以建立连接了。正是由于这种高度的封装，一方面简化了 Java 语言网络编程的难度，另外也使得使用 Java 语言进行网络编程时无法深入到网络的底层，所以使用 Java 语言进行网络底层系统编程很困难，具体点说，Java 语言无法实现底层的网络嗅探以及获得 IP 包结构等信息。但是由于 Java 语言的网络编程比较简单，所以还是获得了广泛的使用。

在使用 TCP 方式进行网络编程时，需要按照前面介绍的网络编程的步骤进行，下面分别介绍一下在 Java 语言中客户端和服务器端的实现步骤。

客户端

在网络编程中客户端需要做的事情包括：建立连接 -> 发送并接受数据 -> 关闭连接。

建立连接

在客户端网络编程中，首先需要建立连接，在 Java API 中以 java.net.Socket 类的对象代表网络连接，所以建立客户端网络连接，也就是创建 Socket 类型的对象，该对象代表网络连接，示例如下：

1
2
3
4
5
6
7
8
9
10
11
Socket socket1 = new Socket(“192.168.1.103”,10000);  
Socket socket2 = new Socket(“www.sohu.com”,80);  
```  
上面的代码中，**socket1实现的是连接到IP地址是192.168.1.103的计算机的10000号端口，而socket2实现的是连接到域名是www.sohu.com的计算机的80号端口，至于底层网络如何实现建立连接，对于程序员来说是完全透明的。**如果建立连接时，本机网络不通，或服务器端程序未开启，则会抛出异常。

### 传输数据  
连接一旦建立，则完成了客户端编程的第一步，紧接着的步骤就是按照“请求-响应”模型进行网络数据交换，在Java语言中，数据传输功能由Java IO实现，也就是说**需要发送的数据写入连接对象的输出流中，在发送完成以后从输入流中读取数据**即可。示例代码如下：

```java  
OutputStream os = socket1.getOutputStream();   //获得输出流  
InputStream is = socket1.getInputStream();     //获得输入流

上面的代码中，分别从 socket1 这个连接对象获得了输出流和输入流对象，在整个网络编程中，后续的数据交换就变成了 IO 操作，也就是遵循 “请求 - 响应” 模型的规定，先向输出流中写入数据，这些数据会被系统发送出去，然后在从输入流中读取服务器端的反馈信息，这样就完成了一次数据交换过程，当然这个数据交换过程可以多次进行。

这里获得的只是最基本的输出流和输入流对象，还可以根据前面学习到的 IO 知识，使用流的嵌套将这些获得到的基本流对象转换成需要的装饰流对象，从而方便数据的操作。

关闭连接

最后当数据交换完成以后，关闭网络连接，释放网络连接占用的系统端口和内存等资源，完成网络操作，示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
socket1.close();  
```  
### 客户端简单案例  
这就是最基本的网络编程功能介绍。下面是一个简单的网络客户端程序示例，该程序的作用是向服务器端发送一个字符串“Hello”，并将服务器端的反馈显示到控制台，数据交换只进行一次，当数据交换进行完成以后关闭网络连接，程序结束。实现的代码如下：

```java  
import java.io.*;  
import java.net.*;  
/**  
 * 简单的Socket客户端  
 * 功能为：发送字符串“Hello”到服务器端，并打印出服务器端的反馈  
 */  
public class SimpleSocketClient {  
         public static void main(String[] args) {  
                   Socket socket = null;  
                   InputStream is = null;  
                   OutputStream os = null;  
                   //服务器端IP地址  
                   String serverIP = "127.0.0.1";  
                   //服务器端端口号  
                   int port = 10000;  
                   //发送内容  
                   String data = "Hello";  
                   try {  
                            //建立连接  
                            socket = new Socket(serverIP,port);  
                            //发送数据  
                            os = socket.getOutputStream();  
                            os.write(data.getBytes());  
                            //接收数据  
                            is = socket.getInputStream();  
                            byte[] b = new byte[1024];  
                            int n = is.read(b);  
                            //输出反馈数据  
                            System.out.println("服务器反馈：" + new String(b,0,n));  
                   } catch (Exception e) {  
                            e.printStackTrace(); //打印异常信息  
                   }finally{  
                            try {  
                                     //关闭流和连接  
                                     is.close();  
                                     os.close();  
                                     socket.close();  
                            } catch (Exception e2) {}  
                   }  
         }  
}

在该示例代码中建立了一个连接到 IP 地址为 127.0.0.1，端口号码为 10000 的 TCP 类型的网络连接，然后获得连接的输出流对象，将需要发送的字符串 “Hello” 转换为 byte 数组写入到输出流中，由系统自动完成将输出流中的数据发送出去，如果需要强制发送，可以调用输出流对象中的 flush 方法实现。在数据发送出去以后，从连接对象的输入流中读取服务器端的反馈信息，读取时可以使用 IO 中的各种读取方法进行读取，这里使用最简单的方法进行读取，从输入流中读取到的内容就是服务器端的反馈，并将读取到的内容在客户端的控制台进行输出，最后依次关闭打开的流对象和网络连接对象。

这是一个简单的功能示例，在该示例中演示了 TCP 类型的网络客户端基本方法的使用，该代码只起演示目的，还无法达到实用的级别。

服务器端

介绍完一个简单的客户端编程的示例，下面接着介绍一下 TCP 类型的服务器端的编写。

服务器端需要完成的事情包括：监听端口 -> 获得客户端的连接 ->
连接后传送数据 -> 关闭连接。

监听端口

在服务器端程序编程中，由于服务器端实现的是被动等待连接，所以服务器端编程的第一个步骤是监听端口，也就是监听是否有客户端连接到达。实现服务器端监听的代码为：

1
ServerSocket ss = new ServerSocket(10000);

该代码实现的功能是监听当前计算机的 10000 号端口，如果在执行该代码时，10000 号端口已经被别的程序占用，那么将抛出异常。否则将实现监听。

获得客户端的连接

服务器端编程的第二个步骤是获得连接。该步骤的作用是当有客户端连接到达时，建立一个和客户端连接对应的 Socket 连接对象，从而释放客户端连接对于服务器端端口的占用。实现功能就像公司的前台一样，当一个客户到达公司时，会告诉前台我找某某某，然后前台就通知某某某， 然后就可以继续接待其它客户了。通过获得连接，使得客户端的连接在服务器端获得了保持，另外使得服务器端的端口释放出来，可以继续等待其它的客户端连接。 实现获得连接的代码是：

1
Socket socket = ss.accept();

该代码实现的功能是获得当前连接到服务器端的客户端连接。需要说明的是 accept 和前面 IO 部分介绍的 read 方法一样，都是一个阻塞方法，也就是当无连接时，该方法将阻塞程序的执行，直到连接到达时才执行该行代码。另外获得的连接会在服务器端的该端口注册，这样以后就可以通过在服务器端的注册信息直接通信，而注册以后服务器端的端口就被释放出来，又可以继续接受其它的连接了。

连接获得以后，后续的编程就和客户端的网络编程类似了，这里获得的 Socket 类型的连接就和客户端的网络连接一样了，只是服务器端需要首先读取发送过来的数据，然后进行逻辑处理以后再发送给客户端，也就是交换数据的顺序和客户端交换数据的步骤刚好相反。这部分的内容和客户端很类似，所以就不重复了，如果还不熟悉，可以参看下面的示例代码。

关闭连接

最后，在服务器端通信完成以后，关闭服务器端连接。实现的代码为：

1
ss.close();

简单例子

这就是基本的 TCP 类型的服务器端编程步骤。下面以一个简单的 echo 服务实现为例子，介绍综合使用示例。echo 的意思就是 “回声”，echo 服务器端实现的功能就是将客户端发送的内容再原封不动的反馈给客户端。实现的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.io.*;  
import java.net.*;  
/**  
 * echo服务器  
 * 功能：将客户端发送的内容反馈给客户端  
 */  
public class SimpleSocketServer {  
         public static void main(String[] args) {  
                   ServerSocket serverSocket = null;  
                   Socket socket = null;  
                   OutputStream os = null;  
                   InputStream is = null;  
                   //监听端口号  
                   int port = 10000;  
                   try {  
                            //建立连接  
                            serverSocket = new ServerSocket(port);  
                            //获得连接  
                            socket = serverSocket.accept();  
                            //接收客户端发送内容  
                            is = socket.getInputStream();  
                            byte[] b = new byte[1024];  
                            int n = is.read(b);  
                            //输出  
                            System.out.println("客户端发送内容为：" + new String(b,0,n));  
                            //向客户端发送反馈内容  
                            os = socket.getOutputStream();  
                            os.write(b, 0, n);  
                   } catch (Exception e) {  
                            e.printStackTrace();  
                   }finally{  
                            try{  
                                     //关闭流和连接  
                                     os.close();  
                                     is.close();  
                                     socket.close();  
                                     serverSocket.close();  
                            }catch(Exception e){}  
                   }  
         }  
}

在该示例代码中建立了一个监听当前计算机 10000 号端口的服务器端 Socket 连接，然后获得客户端发送过来的连接，如果有连接到达时，读取连接中发送过来的内容，并将发送的内容在控制台进行输出，输出完成以后将客户端发送的内容再反馈给客户端。最后关闭流和连接对象，结束程序。

这样，就以一个很简单的示例演示了 TCP 类型的网络编程在 Java 语言中的基本实现，这个示例只是演示了网络编程的基本步骤以及各个功能方法的基本使用，只是为网络编程打下了一个基础，下面将就几个问题来深入介绍网络编程深层次的一些知识。

深入介绍网络编程

为了一步一步的掌握网络编程，下面再研究网络编程中的两个基本问题，通过解决这两个问题将对网络编程的认识深入一层。

如何复用 Socket 连接？

在前面的示例中，客户端中建立了一次连接，只发送一次数据就关闭了，这就相当于拨打电话时，电话打通了只对话一次就关闭了，其实更加常用的应该是拨通一次电话以后多次对话，这就是复用客户端连接。

那么如何实现建立一次连接，进行多次数据交换呢？其实很简单，建立连接以后，将数据交换的逻辑写到一个循环中就可以了。这样只要循环不结束则连接就不会被关闭。按照这种思路，可以改造一下上面的代码，让该程序可以在建立连接一次以后，发送三次数据，当然这里的次数也可以是多次，示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.io.*;  
import java.net.*;  
/**  
 * 复用连接的Socket客户端  
 * 功能为：发送字符串“Hello”到服务器端，并打印出服务器端的反馈  
 */  
public class MulSocketClient {  
         public static void main(String[] args) {  
                   Socket socket = null;  
                   InputStream is = null;  
                   OutputStream os = null;  
                   //服务器端IP地址  
                   String serverIP = "127.0.0.1";  
                   //服务器端端口号  
                   int port = 10000;  
                   //发送内容  
                   String data[] ={"First","Second","Third"};  
                   try {  
                            //建立连接  
                            socket = new Socket(serverIP,port);  
                            //初始化流  
                            os = socket.getOutputStream();  
                            is = socket.getInputStream();  
                            byte[] b = new byte[1024];  
                            for(int i = 0;i < data.length;i++){  
                                     //发送数据  
                                     os.write(data[i].getBytes());  
                                     //接收数据  
                                     int n = is.read(b);  
                                     //输出反馈数据                                     System.out.println("服务器反馈：" + new String(b,0,n));  
                            }  
                   } catch (Exception e) {  
                            e.printStackTrace(); //打印异常信息  
                   }finally{  
                            try {  
                                     //关闭流和连接  
                                     is.close();  
                                     os.close();  
                                     socket.close();  
                            } catch (Exception e2) {}  
                   }  
         }  
}

该示例程序和前面的代码相比，将数据交换部分的逻辑写在一个 for 循环的内容，这样就可以建立一次连接，依次将 data 数组中的数据按照顺序发送给服务器端了。
如果还是使用前面示例代码中的服务器端程序运行该程序，则该程序的结果是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
java.net.SocketException: Software caused connection abort: recv failed  
at java.net.SocketInputStream.socketRead0(Native Method)  
at java.net.SocketInputStream.read(SocketInputStream.java:129)  
at java.net.SocketInputStream.read(SocketInputStream.java:90)  
at tcp.MulSocketClient.main(MulSocketClient.java:30)

服务器反馈：First  
```  
显然，客户端在实际运行时出现了异常，出现异常的原因是什么呢？如果仔细阅读前面的代码，应该还记得前面示例代码中的服务器端是对话一次数据以后就关闭了连接**，如果服务器端程序关闭了，客户端继续发送数据肯定会出现异常，这就是出现该问题的原因**。  
按照客户端实现的逻辑，也可以复用服务器端的连接，实现的原理也是将服务器端的数据交换逻辑写在循环中即可，按照该种思路改造以后的服务器端代码为：

```java  
import java.io.*;  
import java.net.*;  
/**  
 * 复用连接的echo服务器  
 * 功能：将客户端发送的内容反馈给客户端  
 */  
public class MulSocketServer {  
         public static void main(String[] args) {  
                   ServerSocket serverSocket = null;  
                   Socket socket = null;  
                   OutputStream os = null;  
                   InputStream is = null;  
                   //监听端口号  
                   int port = 10000;  
                   try {  
                            //建立连接  
                            serverSocket = new ServerSocket(port);  
                            System.out.println("服务器已启动：");  
                            //获得连接  
                            socket = serverSocket.accept();  
                            //初始化流  
                            is = socket.getInputStream();  
                            os = socket.getOutputStream();  
                            byte[] b = new byte[1024];  
                            for(int i = 0;i < 3;i++){  
                                     int n = is.read(b);  
                                     //输出  
                                     System.out.println("客户端发送内容为：" + new String(b,0,n));  
                                     //向客户端发送反馈内容  
                                     os.write(b, 0, n);  
                            }  
                   } catch (Exception e) {  
                            e.printStackTrace();  
                   }finally{  
                            try{  
                                     //关闭流和连接  
                                     os.close();  
                                     is.close();  
                                     socket.close();  
                                     serverSocket.close();  
                            }catch(Exception e){}  
                   }  
         }  
}

在该示例代码中，也将数据发送和接收的逻辑写在了一个 for 循环内部，只是在实现时硬性的将循环次数规定成了 3 次，这样代码虽然比较简单，但是通用性比较差。
以该服务器端代码实现为基础运行前面的客户端程序时，客户端的输出为：

1
2
3
服务器反馈：First  
服务器反馈：Second  
服务器反馈：Third

服务器端程序的输出结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
服务器已启动：  
客户端发送内容为：First  
客户端发送内容为：Second  
客户端发送内容为：Third  
```  
在该程序中，比较明显的体现出了“请求-响应”模型，也就是在客户端发起连接以后，首先发送字符串“First”给服务器端，服务器端输出客户端发送的内容“First”，然后将客户端发送的内容再反馈给客户端，这样客户端也输出服务器反馈“First”，这样就完成了客户端和服务器端的一次对话，紧接着客户端发送“Second”给服务器端，服务端输出“Second”，然后将“Second”再反馈给客户端，客户端再输出“Second”，从而完成第二次会话，第三次会话的过程和这个一样。在这个过程中，每次都是客户端程序首先发送数据给服务器端，服务器接收数据以后，将结果反馈给客户端，客户端接收到服务器端的反馈，从而完成一次通讯过程。

在该示例中，虽然解决了多次发送的问题，但是客户端和服务器端的次数控制还不够灵活，如果客户端的次数不固定怎么办呢？是否可以使用某个特殊的字符串，例如quit，表示客户端退出呢,这就涉及到网络协议的内容了，会在后续的网络应用示例部分详细介绍。下面开始介绍另外一个网络编程的突出问题。

### 如何使服务器端支持多个客户端同时工作？

前面介绍的服务器端程序，只是实现了概念上的服务器端，离实际的服务器端程序结构距离还很遥远，**如果需要让服务器端能够实际使用，那么最需要解决的问题就是——如何支持多个客户端同时工作**。

**一个服务器端一般都需要同时为多个客户端提供通讯，如果需要同时支持多个客户端，则必须使用前面介绍的线程的概念。简单来说，也就是当服务器端接收到一个连接时，启动一个专门的线程处理和该客户端的通讯。**

按照这个思路改写的服务端示例程序将由两个部分组成，MulThreadSocketServer类实现服务器端控制，实现接收客户端连接，然后开启专门的逻辑线程处理该连接，LogicThread类实现对于一个客户端连接的逻辑处理，将处理的逻辑放置在该类的run方法中。该示例的代码实现为：


```java  
import java.net.ServerSocket;  
import java.net.Socket;  
/**  
 * 支持多客户端的服务器端实现  
 */  
public class MulThreadSocketServer {  
         public static void main(String[] args) {  
                   ServerSocket serverSocket = null;  
                   Socket socket = null;  
                   //监听端口号  
                   int port = 10000;  
                   try {  
                            //建立连接  
                            serverSocket = new ServerSocket(port);  
                            System.out.println("服务器已启动：");  
                            while(true){  
                                     //获得连接  
                                     socket = serverSocket.accept();  
                                     //启动线程  
                                     new LogicThread(socket);  
                            }  
                   } catch (Exception e) {  
                            e.printStackTrace();  
                   }finally{  
                            try{  
                                     //关闭连接  
                                     serverSocket.close();  
                            }catch(Exception e){}  
                   }  
         }  
}

在该示例代码中，实现了一个 while 形式的死循环，由于 accept 方法是阻塞方法，所以当客户端连接未到达时，将阻塞该程序的执行，当客户端到达时接收该连接，并启动一个新的 LogicThread 线程处理该连接，然后按照循环的执行流程，继续等待下一个客户端连接。这样当任何一个客户端连接到达时，都开启一个专门的线程处理，通过多个线程支持多个客户端同时处理。

下面再看一下 LogicThread 线程类的源代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import java.io.*;  
import java.net.*;  
/**  
 * 服务器端逻辑线程  
 */  
public class LogicThread extends Thread {  
         Socket socket;  
         InputStream is;  
         OutputStream os;  
         public LogicThread(Socket socket){  
                   this.socket = socket;  
                   start(); //启动线程  
         }

         public void run(){  
                   byte[] b = new byte[1024];  
                   try{  
                            //初始化流  
                            os = socket.getOutputStream();  
                            is = socket.getInputStream();  
                            for(int i = 0;i < 3;i++){  
                                     //读取数据  
                                     int n = is.read(b);  
                                     //逻辑处理  
                                     byte[] response = logic(b,0,n);  
                                     //反馈数据  
                                     os.write(response);  
                            }  
                   }catch(Exception e){  
                            e.printStackTrace();  
                   }finally{  
                            close();  
                   }  
         }

         /**  
          * 关闭流和连接  
          */  
         private void close(){  
                   try{  
                            //关闭流和连接  
                            os.close();  
                            is.close();  
                            socket.close();  
                   }catch(Exception e){}  
         }

         /**  
          * 逻辑处理方法,实现echo逻辑  
          * @param b 客户端发送数据缓冲区  
          * @param off 起始下标  
          * @param len 有效数据长度  
          * @return  
          */  
         private byte[] logic(byte[] b,int off,int len){  
                   byte[] response = new byte[len];  
                   //将有效数据拷贝到数组response中  
                   System.arraycopy(b, 0, response, 0, len);  
                   return response;  
         }  
}

在该示例代码中，每次使用一个连接对象构造该线程，该连接对象就是该线程需要处理的连接，在线程构造完成以后，该线程就被启动起来了，然后在 run 方法内部对客户端连接进行处理，数据交换的逻辑和前面的示例代码一致，只是这里将接收到客户端发送过来的数据并进行处理的逻辑封装成了 logic 方法，按照前面介绍的 IO 编程的内容，客户端发送过来的内容存储在数组 b 的起始下标为 0，长度为 n 个中，这些数据是客户端发送过来的有效数据，将有效的数据传递给 logic 方法，logic 方法实现的是 echo 服务的逻辑，也就是将客户端发送的有效数据形成以后新的 response 数组，并作为返回值反馈。

在线程中将 logic 方法的返回值反馈给客户端，这样就完成了服务器端的逻辑处理模拟，其他的实现和前面的介绍类似，这里就不在重复了。

这里的示例还只是基础的服务器端实现，在实际的服务器端实现中，由于硬件和端口数的限制，所以不能无限制的创建线程对象，而且频繁的创建线程对象效率也比较低，所以程序中都实现了线程池来提高程序的执行效率。

这里简单介绍一下线程池的概念，线程池 (Thread pool) 是池技术的一种，就是在程序启动时首先把需要个数的线程对象创建好，例如创建 5000 个线程对象，然后当客户端连接到达时从池中取出一个已经创建完成的线程对象使用即可。当客户端连接关闭以后，将该线程对象重新放入到线程池中供其它的客户端重复使用，这样可以提高程序的执行速度，优化程序对于内存的占用等。

转载，作者不详，侵删