java web接收tcp_Java Web 基础（一） 基于TCP的Socket网络编程

一、Socket简单介绍

Socket通信作为Java网络通讯的基础内容，集中了异常、I/O流模式等众多知识点。学习Socket通信，既能够了解真正的网络通讯原理，也能够增强对I/O流模式的理解。

1)Socket通信分类

(一)基于TCP的Socket通信：使用流式套接字，提供可靠、面向连接的通信流。

(二)基于UDP的Socket通信：使用数据报套接字，定义一种无连接服务，数据之间通过相互独立的报文进行传输，是无序的，并且不保证可靠、无差错。

2)Socket概念理解

金山词霸中对Socket名词解释：插座、灯座、窝，引申到计算机科学称为"套接字"。至于为什么要翻译成"套接字"，可以参考：https://www.zhihu.com/question/21383903/answer/18347271z对Socket历史较为详细考证。

Socket曾经被翻译为"软插座"，表明此处说的插座不是实际生活中的那种插座(硬插座)，而是在计算机领域抽象出来的接口。如果在客户端插座和服务器端插座之间连一条线(也就是数据交互的信道)，那么客户端就能够与服务器端进行数据交互。

二、基于TCP的Socket通信理论基础

基于TCP/IP协议的网络编程，就是利用TCP/IP协议在客户端和服务器端之间建立通信链接来实现数据交换。　具体的编程实现步骤如下：

1)服务器端创建其提供服务的端口号，即服务器端中提供服务的应用程序接口名称。

服务器端ServerSocket： ServerSocket serverSocket = new ServerSocket(int port, int backlog);  ServerSocket作用是向操作系统注册相应协议服务，申请端口并监听这个端口是否有链接请求。其中port是端口号，backlog是服务器最多允许链接的客户端数。注册完成后，服务器分配此端口用于提供某一项进程服务。

2)服务器端(Server)和客户端(Client)都创建各自的Socket对象。

服务器端Socket:  Socket socket = serverSocket.accept();  服务器端创建一个socket对象用于等待客户端socket的链接(accept方法是创建一个阻塞队列，只有客户端socket申请链接到服务器后，服务器端socket才能收到消息) 。如果服务器端socket收到客户端的链接请求，那么经过"三次握手"过程，建立客户端与服务器端的连接。如果连接不成功，则抛出异常(详见模块三)。

客户端Socket： Socket socket = new Socket(String host, int port);  客户端创建按一个socket对象用于链接具体服务器host的具体服务端口port，用于获得服务器进程的相应服务。

经过三次握手后，一个Socket通路就建立起来。此时，服务器端和客户端就可以开始通讯了。

3)服务器端和客户端打开链接到Socket通路的I/O流，按照一定协议进行数据通信。

协议就是指发送与接受数据的编码格式(计算机网络中为：语义、同步)。简单说就是输入和输出的流必须匹配。

开启网络输入流：网络输入流指的是从socket通道进入计算机内存的流。    socket.getInputStream();  返回值InputStream 输入字节流

开启网络输出流：网络输出流指的是从计算机内存走出到socket通道的流。 socket.getOutputStream(); 返回值OutputStream 输出字节流

为了通讯方便，往往将低级流包装成高级流进行服务端与客户端之间的交互。

4)通信完毕，关闭网络流

一般而言，服务器端的流失不用关闭的，当然在某些条件下(比如服务器需要维护)也是需要关闭的。而客户端一般都需要关闭。

三、Socket异常类

网络通讯中会遇到很多种错误，比如通讯中断、服务器维护拒绝访问等等。下面稍微总结一下Socket通讯中常见的异常类。

1)java.net.SocketTimeoutException套接字超时异常。常见原因：网络通路中断，链接超时；

2)java.net.UnknowHostException未知主机异常。常见原因：客户端绑定的服务器IP或主机名不存在；

3)java.net.BindException绑定异常。常见原因：端口被占用；

4)java.net.ConnectException连接异常。常见原因：服务器未启动，客户端申请服务；服务器拒绝服务，即服务器正在维护；

四、Java建立Socket通讯

1)服务器端与客户端建立连接

1 package day05;

2

3 import java.io.IOException;

4 import java.net.ServerSocket;

5 import java.net.Socket;

6

7 /**

8 * 服务器端

9 * @author forget406

10 *

11 */

12 public class Server {

13

14 private ServerSocket serverSocket;

15

16 /** 在操作系统中注册8000端口服务，并监听8000端口 */

17 public Server() {

18 try {

19 /* public ServerSocket(int port, int backlog)

20 * port表示端口号，backlog表示最多支持连接数 */

21 serverSocket = new ServerSocket(8000, 3);

22 } catch (IOException e) {

23 e.printStackTrace();

24 }

25 }

26

27 /** 与客户端交互 */

28 public void start() {

29 try {

30 System.out.println("等待用户链接...");

31 /* 创建Socket对象: public Socket accept()

32 * 等待客户端链接，直到客户端链接到此端口 */

33 Socket socket = serverSocket.accept();

34 System.out.println("链接成功，可以通讯！");

35 } catch (IOException e) {

36 // TODO Auto-generated catch block

37 e.printStackTrace();

38 }

39 }

40

41 public static void main(String[] args) {

42 Server server = new Server();

43 server.start();

44 }

45 }

46

47 ==============================================

48

49 package day05;

50

51 import java.io.IOException;

52 import java.net.Socket;

53 import java.net.UnknownHostException;

54

55 /**

56 * 客户端

57 * @author forget406

58 *

59 */

60 public class Client {

61

62 private Socket socket;

63

64 /** 申请与服务器端口连接 */

65 public Client() {

66 try {

67 /* 请求与服务器端口建立连接

68 * 并申请服务器8000端口的服务*/

69 socket = new Socket("localhost", 8000);

70 } catch (UnknownHostException e) {

71 e.printStackTrace();

72 } catch (IOException e) {

73 e.printStackTrace();

74 }

75 }

76

77 /** 与服务器交互 */

78 public void start() {

79

80 }

81

82 public static void main(String[] args) {

83 Client client = new Client();

84 client.start();

85 }

86 }

服务器端结果：

五、Java实现C/S模式Socket通讯

1)客户端向服务器端发送消息(单向通信)：服务器只能接受数据，客户端只能发送数据。这是由于socket绑定了从客户端到服务器的一条通信通路。

1 package day05;

2

3 import java.io.BufferedReader;

4 import java.io.IOException;

5 import java.io.InputStream;

6 import java.io.InputStreamReader;

7 import java.net.ServerSocket;

8 import java.net.Socket;

9

10 /**

11 * 服务器端

12 * @author forget406

13 *

14 */

15 public class Server {

16

17 private ServerSocket serverSocket;

18

19 /** 在操作系统中注册8000端口服务，并监听8000端口 */

20 public Server() {

21 try {

22 /* public ServerSocket(int port, int backlog)

23 * port表示端口号，backlog表示最多支持连接数 */

24 serverSocket = new ServerSocket(8000, 3);

25 } catch (IOException e) {

26 e.printStackTrace();

27 }

28 }

29

30 /** 与客户端单向交互 */

31 public void start() {

32 System.out.println("等待用户链接...");

33 try {

34 /* 创建Socket对象: public Socket accept()

35 * 等待客户端链接，直到客户端链接到此端口 */

36 Socket socket = serverSocket.accept();

37 System.out.println("用户链接成功，开始通讯！");

38

39 /* 服务器开始与客户端通讯 */

40 while(true) {

41 // 开启服务器socket端口到服务器内存的网路输入字节流

42 InputStream is

43 = socket.getInputStream();

44 // 在服务器内存中将网络字节流转换成字符流

45 InputStreamReader isr

46 = new InputStreamReader(

47 is, "UTF-8"

48 );

49 // 包装成按行读取字符流

50 BufferedReader br

51 = new BufferedReader(isr);

52

53 /* 中途网络可能断开

54 * 1)Windows的readLine会直接抛出异常

55 * 2)Linux的readLine则会返回null*/

56 String msg = null;

57 if((msg = br.readLine()) != null) {

58 System.out.println("客户端说：" +

59 msg

60 );

61 }

62

63 }

64

65 } catch (IOException e) {

66 System.out.println("链接失败");

67 e.printStackTrace();

68 }

69 }

70

71 public static void main(String[] args) {

72 Server server = new Server();

73 server.start();

74 }

75 }

76

77 ===========================================

78

79 package day05;

80

81 import java.io.IOException;

82 import java.io.OutputStream;

83 import java.io.OutputStreamWriter;

84 import java.io.PrintWriter;

85 import java.net.Socket;

86 import java.net.UnknownHostException;

87 import java.util.Scanner;

88

89 /**

90 * 客户端

91 * @author forget406

92 *

93 */

94 public class Client {

95

96 private Socket socket;

97

98 /** 申请与服务器端口连接 */

99 public Client() {

100 try {

101 /* 请求与服务器端口建立连接

102 * 并申请服务器8000端口的服务*/

103 socket = new Socket("localhost", 8000);

104 } catch (UnknownHostException e) {

105 e.printStackTrace();

106 } catch (IOException e) {

107 e.printStackTrace();

108 }

109 }

110

111 /** 与服务器单向交互 */

112 public void start() {

113 try {

114 // 开启客户端内存到客户端socket端口的网络输出流

115 OutputStream os

116 = socket.getOutputStream();

117 // 将客户端网络输出字节流包装成网络字符流

118 OutputStreamWriter osw

119 = new OutputStreamWriter(os, "UTF-8");

120 // 将输出字符流包装成字符打印流

121 PrintWriter pw

122 = new PrintWriter(osw, true);

123 // 来自键盘的标准输入字节流

124 Scanner sc = new Scanner(System.in);

125 while(true) {

126 // 打印来自键盘的字符串(字节数组)

127 pw.println(sc.nextLine());

128 }

129

130 } catch (IOException e) {

131 e.printStackTrace();

132 }

133 }

134

135 public static void main(String[] args) {

136 Client client = new Client();

137 client.start();

138 }

139 }

客户端输入：

服务器端结果：

2)客户端与服务器端双向通信：客户端与服务器交互，能够实现服务器对客户端的应答，这更像是P2P模式。此时，双方socket端口均绑定来回一对通信通路。

1 package day05;

2

3 import java.io.BufferedReader;

4 import java.io.IOException;

5 import java.io.InputStreamReader;

6 import java.io.OutputStreamWriter;

7 import java.io.PrintWriter;

8 import java.net.ServerSocket;

9 import java.net.Socket;

10 import java.util.Scanner;

11

12 /**

13 * 服务器端

14 * @author forget406

15 *

16 */

17 public class Server {

18

19 private ServerSocket serverSocket;

20

21 /** 在操作系统中注册8000端口服务，并监听8000端口 */

22 public Server() {

23 try {

24 /* public ServerSocket(int port, int backlog)

25 * port表示端口号，backlog表示最多支持连接数 */

26 serverSocket = new ServerSocket(8000, 3);

27 } catch (IOException e) {

28 e.printStackTrace();

29 }

30 }

31

32 /** 与客户端单向交互 */

33 @SuppressWarnings("resource")

34 public void start() {

35 System.out.println("等待用户链接...");

36 try {

37 /* 创建Socket对象: public Socket accept()

38 * 等待客户端链接，直到客户端链接到此端口 */

39 Socket socket = serverSocket.accept();

40 System.out.println("用户链接成功，开始通讯！");

41

42 /* 服务器接收客户端数据 */

43 InputStreamReader isr

44 = new InputStreamReader(

45 socket.getInputStream(),

46 "UTF-8"

47 );

48 BufferedReader br

49 = new BufferedReader(isr);

50 String msgReceive = null;

51 String msgSend = null;

52

53 /* 服务器向客户端发送数据 */

54 OutputStreamWriter osw

55 = new OutputStreamWriter(

56 socket.getOutputStream(),

57 "UTF-8"

58 );

59 PrintWriter pw

60 = new PrintWriter(osw, true);

61 Scanner sc = new Scanner(System.in);

62

63 while(true) {

64 if((msgReceive = br.readLine()) != null) {

65 System.out.println("客户端说：" + msgReceive);

66 }

67

68 if((msgSend = sc.nextLine()) != null) {

69 pw.println(msgSend);

70 }

71 }

72

73 } catch (IOException e) {

74 System.out.println("链接失败");

75 e.printStackTrace();

76 }

77 }

78

79 public static void main(String[] args) {

80 Server server = new Server();

81 server.start();

82 }

83 }

84

85 ============================================

86

87 package day05;

88

89 import java.io.BufferedReader;

90 import java.io.IOException;

91 import java.io.InputStreamReader;

92 import java.io.OutputStreamWriter;

93 import java.io.PrintWriter;

94 import java.net.Socket;

95 import java.net.UnknownHostException;

96 import java.util.Scanner;

97

98 /**

99 * 客户端

100 * @author forget406

101 *

102 */

103 public class Client {

104

105 private Socket socket;

106

107 /** 申请与服务器端口连接 */

108 public Client() {

109 try {

110 /* 请求与服务器端口建立连接

111 * 并申请服务器8000端口的服务*/

112 socket = new Socket("localhost", 8000);

113 } catch (UnknownHostException e) {

114 e.printStackTrace();

115 } catch (IOException e) {

116 e.printStackTrace();

117 }

118 }

119

120 /** 与服务器单向交互 */

121 @SuppressWarnings("resource")

122 public void start() {

123 try {

124 /* 客户端向服务器发送数据 */

125 OutputStreamWriter osw

126 = new OutputStreamWriter(

127 socket.getOutputStream(),

128 "UTF-8"

129 );

130 PrintWriter pw

131 = new PrintWriter(osw, true);

132 Scanner sc = new Scanner(System.in);

133

134 /* 客户端接收服务器数据 */

135 InputStreamReader isr

136 = new InputStreamReader(

137 socket.getInputStream(),

138 "UTF-8"

139 );

140 BufferedReader br

141 = new BufferedReader(isr);

142 String msgReceive = null;

143 String msgSend = null;

144

145 while(true) {

146 if((msgSend = sc.nextLine()) != null) {

147 pw.println(msgSend);

148 }

149 if((msgReceive = br.readLine()) != null) {

150 System.out.println("服务器说：" + msgReceive);

151 }

152 }

153

154 } catch (IOException e) {

155 System.out.println("链接失败！");

156 e.printStackTrace();

157 }

158 }

159

160

161 public static void main(String[] args) {

162 Client client = new Client();

163 client.start();

164

165 }

166 }

PS: 只是初步实现，有些bug没有改进。类似QQ的完善版本代码会在后续的文章中更新。

六、心得体会

上述代码实现的是C/S模型的简化版本，即P2P模式---客户端与服务器端一对一进行交互通信。事实上，服务器可以并行与多台客户机进行数据收发与交互，这需要运用到Java多线程的知识，这将会在后续文章中分析。

I/O流模式的选取原则：

1. 选择合适的节点流。在Socket网络编程中，节点流分别是socket.getInputStream和socket.getOutputStream，均为字节流。

1.1)选择合适方向的流。输入流socket.getInputStream、InputStreamReader、BufferedReader；输出流socket.getOutputStream、OutputStreamWriter、PrintWriter。

1.2)选择字节流和字符流。网络通信在实际通信线路中传递的是比特流(字节流)；而字符流只会出现在计算机内存中。

2. 选择合适的包装流。在选择I/O流时，节点流是必须的，而包装流则是可选的；节点流类型只能存在一种，而包装流则能存在多种(注意区分：是一种或一对，而不是一个)。

2.1)选择符合功能要求的流。如果需要读写格式化数据，选择DataInputStream/DataOutputStream；而BufferedReader/BufferedWriter则提供缓冲区功能，能够提高格式化读写的效率。

2.2)选择合适方向的包装流。基本与节点流一致。当选择了多个包装流后，可以使用流之间的多层嵌套功能，不过流的嵌套在物理实现上是组合关系，因此彼此之间没有顺序。