循序渐进Java Socket网络编程（多客户端、信息共享、文件传输）

最新推荐文章于 2023-06-20 16:43:31 发布

u011393661

最新推荐文章于 2023-06-20 16:43:31 发布

阅读量886

点赞数

分类专栏： java cs

java cs 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、TCP/IP协议
二、TCP与UDP
三、Socket是什么
四、Java中的Socket
五、基本的Client/Server程序
六、多客户端连接服务器
七、信息共享
八、文件传输
推荐阅读：
前言：在最近一个即将结束的项目中使用到了Socket编程，用于调用另一系统进行处理并返回数据。故把Socket的基础知识总结梳理一遍。

一、TCP/IP协议

　　既然是网络编程，涉及几个系统之间的交互，那么首先要考虑的是如何准确的定位到网络上的一台或几台主机，另一个是如何进行可靠高效的数据传输。这里就要使用到TCP/IP协议。

　　TCP/IP协议（传输控制协议）由网络层的IP协议和传输层的TCP协议组成。IP层负责网络主机的定位，数据传输的路由，由IP地址可以唯一的确定Internet上的一台主机。TCP层负责面向应用的可靠的或非可靠的数据传输机制，这是网络编程的主要对象。

二、TCP与UDP

　　TCP是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。

　　UDP是一种面向无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

TCP与UDP区别：

TCP特点：

　　1、TCP是面向连接的协议，通过三次握手建立连接，通讯完成时要拆除连接，由于TCP是面向连接协议，所以只能用于点对点的通讯。而且建立连接也需要消耗时间和开销。

　　2、TCP传输数据无大小限制，进行大数据传输。

　　3、TCP是一个可靠的协议，它能保证接收方能够完整正确地接收到发送方发送的全部数据。

UDP特点：

　　1、UDP是面向无连接的通讯协议，UDP数据包括目的端口号和源端口号信息，由于通讯不需要连接，所以可以实现广播发送。

　　2、UDP传输数据时有大小限制，每个被传输的数据报必须限定在64KB之内。

　　3、UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方。

TCP与UDP应用：

　　1、TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。

　　2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

三、Socket是什么

　　Socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket，一个Socket由一个IP地址和一个端口号唯一确定。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 Socket是TCP/IP协议的一个十分流行的编程界面，但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

　　Socket通讯过程：服务端监听某个端口是否有连接请求，客户端向服务端发送连接请求，服务端收到连接请求向客户端发出接收消息，这样一个连接就建立起来了。客户端和服务端都可以相互发送消息与对方进行通讯。

　　Socket的基本工作过程包含以下四个步骤：

　　1、创建Socket；

　　2、打开连接到Socket的输入输出流；

　　3、按照一定的协议对Socket进行读写操作；

　　4、关闭Socket。

四、Java中的Socket

　　在java.net包下有两个类：Socket和ServerSocket。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

列出几个常用的构造方法：

?
1
2
3
4
5
6
7
8
9
Socket(InetAddress address,int port);//创建一个流套接字并将其连接到指定 IP 地址的指定端口号
Socket(String host,int port);//创建一个流套接字并将其连接到指定主机上的指定端口号
Socket(InetAddress address,int port, InetAddress localAddr,int localPort);//创建一个套接字并将其连接到指定远程地址上的指定远程端口
Socket(String host,int port, InetAddress localAddr,int localPort);//创建一个套接字并将其连接到指定远程主机上的指定远程端口
Socket(SocketImpl impl);//使用用户指定的 SocketImpl 创建一个未连接 Socket

ServerSocket(int port);//创建绑定到特定端口的服务器套接字
ServerSocket(int port,int backlog);//利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号
ServerSocket(int port,int backlog, InetAddress bindAddr);//使用指定的端口、侦听 backlog 和要绑定到的本地 IP地址创建服务器
　　构造方法的参数中，address、host和port分别是双向连接中另一方的IP地址、主机名和端口号，stream指明socket是流socket还是数据报socket，localPort表示本地主机的端口号，localAddr和bindAddr是本地机器的地址（ServerSocket的主机地址），impl是socket的父类，既可以用来创建serverSocket又可以用来创建Socket。count则表示服务端所能支持的最大连接数。

注意：必须小心选择端口号。每一个端口提供一种特定的服务，只有给出正确的端口，才能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。

几个重要的Socke方法：

?
1
2
3
public InputStream getInputStream();//方法获得网络连接输入，同时返回一个IutputStream对象实例
public OutputStream getOutputStream();//方法连接的另一端将得到输入，同时返回一个OutputStream对象实例
public Socket accept();//用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。
"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。

注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

五、基本的Client/Server程序

以下是一个基本的客户端/服务器端程序代码。主要实现了服务器端一直监听某个端口，等待客户端连接请求。客户端根据IP地址和端口号连接服务器端，从键盘上输入一行信息，发送到服务器端，然后接收服务器端返回的信息，最后结束会话。这个程序一次只能接受一个客户连接。

ps：这个小例子写好后，服务端一直接收不到消息，调试了好长时间，才发现误使用了PrintWriter的print()方法，而BufferedReader的readLine()方法一直没有遇到换行，所以一直等待读取。我晕死~~@_@

客户端程序：

01
package sock;
02

03
import java.io.BufferedReader;
04
import java.io.InputStreamReader;
05
import java.io.PrintWriter;
06
import java.net.Socket;
07

08
public class SocketClient {
09
public static void main(String[] args) {
10
try {
11
/** 创建Socket*/
12
// 创建一个流套接字并将其连接到指定 IP 地址的指定端口号(本处是本机)
13
Socket socket =new Socket("127.0.0.1",2013);
14
// 60s超时
15
socket.setSoTimeout(60000);
16

17
/** 发送客户端准备传输的信息 */
18
// 由Socket对象得到输出流，并构造PrintWriter对象
19
PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);
20
// 将输入读入的字符串输出到Server
21
BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));
22
printWriter.println(sysBuff.readLine());
23
// 刷新输出流，使Server马上收到该字符串
24
printWriter.flush();
25

26
/** 用于获取服务端传输来的信息 */
27
// 由Socket对象得到输入流，并构造相应的BufferedReader对象
28
BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
29
// 输入读入一字符串
30
String result = bufferedReader.readLine();
31
System.out.println("Server say : " + result);
32

33
/** 关闭Socket*/
34
printWriter.close();
35
bufferedReader.close();
36
socket.close();
37
}catch (Exception e) {
38
System.out.println("Exception:" + e);
39
}
40
}
41
}
服务器端程序：

01
package sock;
02
import java.io.BufferedReader;
03
import java.io.InputStreamReader;
04
import java.io.PrintWriter;
05
import java.net.ServerSocket;
06
import java.net.Socket;
07

08
public class SocketServer {
09
public static void main(String[] args) {
10
try {
11
/** 创建ServerSocket*/
12
// 创建一个ServerSocket在端口2013监听客户请求
13
ServerSocket serverSocket =new ServerSocket(2013);
14
while (true) {
15
// 侦听并接受到此Socket的连接,请求到来则产生一个Socket对象，并继续执行
16
Socket socket = serverSocket.accept();
17

18
/** 获取客户端传来的信息 */
19
// 由Socket对象得到输入流，并构造相应的BufferedReader对象
20
BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
21
// 获取从客户端读入的字符串
22
String result = bufferedReader.readLine();
23
System.out.println("Client say : " + result);
24

25
/** 发送服务端准备传输的 */
26
// 由Socket对象得到输出流，并构造PrintWriter对象
27
PrintWriter printWriter =new PrintWriter(socket.getOutputStream());
28
printWriter.print("hello Client, I am Server!");
29
printWriter.flush();
30

31
/** 关闭Socket*/
32
printWriter.close();
33
bufferedReader.close();
34
socket.close();
35
}
36
}catch (Exception e) {
37
System.out.println("Exception:" + e);
38
}finally{
39
// serverSocket.close();
40
}
41
}
42
}
六、多客户端连接服务器

上面的服务器端程序一次只能连接一个客户端，这在实际应用中显然是不可能的。通常的网络环境是多个客户端连接到某个主机进行通讯，所以我们要对上面的程序进行改造。

设计思路：服务器端主程序监听某一个端口，客户端发起连接请求，服务器端主程序接收请求，同时构造一个线程类，用于接管会话。当一个Socket会话产生后，这个会话就会交给线程进行处理，主程序继续进行监听。

下面的实现程序流程是：客户端和服务器建立连接，客户端发送消息，服务端根据消息进行处理并返回消息，若客户端申请关闭，则服务器关闭此连接，双方通讯结束。

客户端程序：

01
package sock;
02

03
import java.io.BufferedReader;
04
import java.io.InputStreamReader;
05
import java.io.PrintWriter;
06
import java.net.Socket;
07

08
public class SocketClient {
09
public static void main(String[] args) {
10
try {
11
Socket socket =new Socket("127.0.0.1",2013);
12
socket.setSoTimeout(60000);
13

14
PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);
15
BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
16

17
String result ="";
18
while(result.indexOf("bye") == -1){
19
BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));
20
printWriter.println(sysBuff.readLine());
21
printWriter.flush();
22

23
result = bufferedReader.readLine();
24
System.out.println("Server say : " + result);
25
}
26

27
printWriter.close();
28
bufferedReader.close();
29
socket.close();
30
}catch (Exception e) {
31
System.out.println("Exception:" + e);
32
}
33
}
34
}
服务器端程序：

01
package sock;
02
import java.io.*;
03
import java.net.*;
04

05
public class Server extends ServerSocket {
06
private static final int SERVER_PORT =2013;
07

08
public Server()throws IOException {
09
super(SERVER_PORT);
10

11
try {
12
while (true) {
13
Socket socket = accept();
14
new CreateServerThread(socket);//当有请求时，启一个线程处理
15
}
16
}catch (IOException e) {
17
}finally {
18
close();
19
}
20
}
21

22
//线程类
23
class CreateServerThread extends Thread {
24
private Socket client;
25
private BufferedReader bufferedReader;
26
private PrintWriter printWriter;
27

28
public CreateServerThread(Socket s)throws IOException {
29
client = s;
30

31
bufferedReader =new BufferedReader(new InputStreamReader(client.getInputStream()));
32

33
printWriter =new PrintWriter(client.getOutputStream(),true);
34
System.out.println("Client(" + getName() +") come in...");
35

36
start();
37
}
38

39
public void run() {
40
try {
41
String line = bufferedReader.readLine();
42

43
while (!line.equals("bye")) {
44
printWriter.println("continue, Client(" + getName() +")!");
45
line = bufferedReader.readLine();
46
System.out.println("Client(" + getName() +") say: " + line);
47
}
48
printWriter.println("bye, Client(" + getName() +")!");
49

50
System.out.println("Client(" + getName() +") exit!");
51
printWriter.close();
52
bufferedReader.close();
53
client.close();
54
}catch (IOException e) {
55
}
56
}
57
}
58

59
public static void main(String[] args)throws IOException {
60
new Server();
61
}
62
}
七、信息共享

以上虽然实现了多个客户端和服务器连接，但是仍然是消息在一个客户端和服务器之间相互传播。现在我们要实现信息共享，即服务器可以向多个客户端发送广播消息，客户端也可以向其他客户端发送消息。类似于聊天室的那种功能，实现信息能在多个客户端之间共享。

设计思路：客户端循环可以不停输入向服务器发送消息，并且启一个线程，专门用来监听服务器端发来的消息并打印输出。服务器端启动时，启动一个监听何时需要向客户端发送消息的线程。每次接受客户端连接请求，都启一个线程进行处理，并且将客户端信息存放到公共集合中。当客户端发送消息时，服务器端将消息顺序存入队列中，当需要输出时，从队列中取出广播到各客户端处。客户端输入showuser命令可以查看在线用户列表，输入bye向服务器端申请退出连接。

PS：以下代码在测试时发现了一个中文乱码小问题，当文件设置UTF-8编码时，无论怎样在代码中设置输入流编码都不起作用，输入中文仍然会乱码。把文件设置为GBK编码后，不用在代码中设置输入流编码都能正常显示传输中文。

客户端代码：

01
package sock;
02

03
import java.io.BufferedReader;
04
import java.io.InputStreamReader;
05
import java.io.PrintWriter;
06
import java.net.Socket;
07

08
public class SocketClient extends Socket{
09

10
private static final String SERVER_IP ="127.0.0.1";
11
private static final int SERVER_PORT =2013;
12

13
private Socket client;
14
private PrintWriter out;
15
private BufferedReader in;
16

17
/**
18
* 与服务器连接，并输入发送消息
19
*/
20
public SocketClient()throws Exception{
21
super(SERVER_IP, SERVER_PORT);
22
client =this;
23
out =new PrintWriter(this.getOutputStream(),true);
24
in =new BufferedReader(new InputStreamReader(this.getInputStream()));
25
new readLineThread();
26

27
while(true){
28
in =new BufferedReader(new InputStreamReader(System.in));
29
String input = in.readLine();
30
out.println(input);
31
}
32
}
33

34
/**
35
* 用于监听服务器端向客户端发送消息线程类
36
*/
37
class readLineThread extends Thread{
38

39
private BufferedReader buff;
40
public readLineThread(){
41
try {
42
buff =new BufferedReader(new InputStreamReader(client.getInputStream()));
43
start();
44
}catch (Exception e) {
45
}
46
}
47

48
@Override
49
public void run() {
50
try {
51
while(true){
52
String result = buff.readLine();
53
if("byeClient".equals(result)){//客户端申请退出，服务端返回确认退出
54
break;
55
}else{//输出服务端发送消息
56
System.out.println(result);
57
}
58
}
59
in.close();
60
out.close();
61
client.close();
62
}catch (Exception e) {
63
}
64
}
65
}
66

67
public static void main(String[] args) {
68
try {
69
new SocketClient();//启动客户端
70
}catch (Exception e) {
71
}
72
}
73
}
服务器端代码：

001
package sock;
002
import java.io.BufferedReader;
003
import java.io.IOException;
004
import java.io.InputStreamReader;
005
import java.io.PrintWriter;
006
import java.net.ServerSocket;
007
import java.net.Socket;
008
import java.util.ArrayList;
009
import java.util.LinkedList;
010
import java.util.List;
011

012

013
public class Server extends ServerSocket{
014

015
private static final int SERVER_PORT =2013;
016

017
private static boolean isPrint =false;//是否输出消息标志
018
private static List user_list =new ArrayList();//登录用户集合
019
private static List<ServerThread> thread_list =new ArrayList<ServerThread>();//服务器已启用线程集合
020
private static LinkedList<String> message_list =new LinkedList<String>();//存放消息队列
021

022
/**
023
* 创建服务端Socket,创建向客户端发送消息线程,监听客户端请求并处理
024
*/
025
public Server()throws IOException{
026
super(SERVER_PORT);//创建ServerSocket
027
new PrintOutThread();//创建向客户端发送消息线程
028

029
try {
030
while(true){//监听客户端请求，启个线程处理
031
Socket socket = accept();
032
new ServerThread(socket);
033
}
034
}catch (Exception e) {
035
}finally{
036
close();
037
}
038
}
039

040
/**
041
* 监听是否有输出消息请求线程类,向客户端发送消息
042
*/
043
class PrintOutThread extends Thread{
044

045
public PrintOutThread(){
046
start();
047
}
048

049
@Override
050
public void run() {
051
while(true){
052
if(isPrint){//将缓存在队列中的消息按顺序发送到各客户端，并从队列中清除。
053
String message = message_list.getFirst();
054
for (ServerThread thread : thread_list) {
055
thread.sendMessage(message);
056
}
057
message_list.removeFirst();
058
isPrint = message_list.size() >0 ?true :false;
059
}
060
}
061
}
062
}
063

064
/**
065
* 服务器线程类
066
*/
067
class ServerThread extends Thread{
068
private Socket client;
069
private PrintWriter out;
070
private BufferedReader in;
071
private String name;
072

073
public ServerThread(Socket s)throws IOException{
074
client = s;
075
out =new PrintWriter(client.getOutputStream(),true);
076
in =new BufferedReader(new InputStreamReader(client.getInputStream()));
077
in.readLine();
078
out.println("成功连上聊天室,请输入你的名字：");
079
start();
080
}
081

082
@Override
083
public void run() {
084
try {
085
int flag =0;
086
String line = in.readLine();
087
while(!"bye".equals(line)){
088
//查看在线用户列表
089
if ("showuser".equals(line)) {
090
out.println(this.listOnlineUsers());
091
line = in.readLine();
092
}
093
//第一次进入，保存名字
094
if(flag++ ==0){
095
name = line;
096
user_list.add(name);
097
thread_list.add(this);
098
out.println(name +"你好,可以开始聊天了...");
099
this.pushMessage("Client<" + name +">进入聊天室...");
100
}else{
101
this.pushMessage("Client<" + name +"> say : " + line);
102
}
103
line = in.readLine();
104
}
105
out.println("byeClient");
106
}catch (Exception e) {
107
e.printStackTrace();
108
}finally{//用户退出聊天室
109
try {
110
client.close();
111
}catch (IOException e) {
112
e.printStackTrace();
113
}
114
thread_list.remove(this);
115
user_list.remove(name);
116
pushMessage("Client<" + name +">退出了聊天室");
117
}
118
}
119

120
//放入消息队列末尾，准备发送给客户端
121
private void pushMessage(String msg){
122
message_list.addLast(msg);
123
isPrint =true;
124
}
125

126
//向客户端发送一条消息
127
private void sendMessage(String msg){
128
out.println(msg);
129
}
130

131
//统计在线用户列表
132
private String listOnlineUsers() {
133
String s ="--- 在线用户列表 ---\015\012";
134
for (int i =0; i < user_list.size(); i++) {
135
s +="[" + user_list.get(i) +"]\015\012";
136
}
137
s +="--------------------";
138
return s;
139
}
140
}
141

142
public static void main(String[] args)throws IOException {
143
new Server();//启动服务端
144
}
145
}
八、文件传输

客户端向服务器端传送文件，服务端可获取文件名用于保存，获取文件大小计算传输进度，比较简单，直接贴代码。

客户端代码：

01
package sock;
02

03
import java.io.DataOutputStream;
04
import java.io.File;
05
import java.io.FileInputStream;
06
import java.net.Socket;
07

08
/**
09
* 客户端
10
*/
11
public class Client extends Socket{
12

13
private static final String SERVER_IP ="127.0.0.1";
14
private static final int SERVER_PORT =2013;
15

16
private Socket client;
17
private FileInputStream fis;
18
private DataOutputStream dos;
19

20
public Client(){
21
try {
22
try {
23
client =new Socket(SERVER_IP, SERVER_PORT);
24
//向服务端传送文件
25
File file =new File("c:/test.doc");
26
fis =new FileInputStream(file);
27
dos =new DataOutputStream(client.getOutputStream());
28

29
//文件名和长度
30
dos.writeUTF(file.getName());
31
dos.flush();
32
dos.writeLong(file.length());
33
dos.flush();
34

35
//传输文件
36
byte[] sendBytes =new byte[1024];
37
int length =0;
38
while((length = fis.read(sendBytes,0, sendBytes.length)) >0){
39
dos.write(sendBytes,0, length);
40
dos.flush();
41
}
42
}catch (Exception e) {
43
e.printStackTrace();
44
}finally{
45
if(fis !=null)
46
fis.close();
47
if(dos !=null)
48
dos.close();
49
client.close();
50
}
51
}catch (Exception e) {
52
e.printStackTrace();
53
}
54
}
55

56
public static void main(String[] args)throws Exception {
57
new Client();
58
}
59
}
服务器端代码：

view sourceprint?
01
package sock;
02
import java.io.DataInputStream;
03
import java.io.File;
04
import java.io.FileOutputStream;
05
import java.net.ServerSocket;
06
import java.net.Socket;
07

08
/**
09
* 服务器
10
*/
11
public class Server extends ServerSocket{
12

13
private static final int PORT =2013;
14

15
private ServerSocket server;
16
private Socket client;
17
private DataInputStream dis;
18
private FileOutputStream fos;
19

20
public Server()throws Exception{
21
try {
22
try {
23
server =new ServerSocket(PORT);
24

25
while(true){
26
client = server.accept();
27

28
dis =new DataInputStream(client.getInputStream());
29
//文件名和长度
30
String fileName = dis.readUTF();
31
long fileLength = dis.readLong();
32
fos =new FileOutputStream(new File("d:/" + fileName));
33

34
byte[] sendBytes =new byte[1024];
35
int transLen =0;
36
System.out.println("----开始接收文件<" + fileName +">,文件大小为<" + fileLength +">----");
37
while(true){
38
int read =0;
39
read = dis.read(sendBytes);
40
if(read == -1)
41
break;
42
transLen += read;
43
System.out.println("接收文件进度" +100 * transLen/fileLength +"%...");
44
fos.write(sendBytes,0, read);
45
fos.flush();
46
}
47
System.out.println("----接收文件<" + fileName +">成功-------");
48
client.close();
49
}
50
}catch (Exception e) {
51
e.printStackTrace();
52
}finally {
53
if(dis !=null)
54
dis.close();
55
if(fos !=null)
56
fos.close();
57
server.close();
58
}
59
}catch (Exception e) {
60
e.printStackTrace();
61
}
62
}
63

64
public static void main(String[] args)throws Exception {
65
new Server();
66
}
67

}

转载链接：http://my.oschina.net/leejun2005/blog/104955

u011393661

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
循序渐进Java Socket网络编程（多客户端、信息共享、文件传输）

循序渐进Java Socket网络编程（多客户端、信息共享、文件传输）发表于1年前(2013-01-25 21:51) 阅读（7609） | 评论（3） 62人收藏此文章, 我要收藏赞2目录[-]一、TCP/IP协议二、TCP与UDP三、Socket是什么四、Java中的Socket五、基本的Client/Server程序六、多客户端连接服务器七、信息共
复制链接

扫一扫