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

最新推荐文章于 2023-04-01 10:43:23 发布
最新推荐文章于 2023-04-01 10:43:23 发布
阅读量771 收藏 1
点赞数
文章标签： java 网络编程 clientserver 实例

前言：在最近一个即将结束的项目中使用到了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 }

服务器端代码：

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 }
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 }

服务器端代码：

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 }

lt26w
关注
网络编程 基于Socket的多文件传输程序实现(一)
Baishu的专栏
11-20 4962
[0] 前言-写在开始之前 新人，Java学习中，文章中遗漏错误之处，欢迎斧正 个人博客，完全原创 转载请注明出处。 项目全代码地址：GitHub 最近的学习了IO流和网络编程相关的API.IO流时学会了如何进行本地文件之间的读写操作,而网络编程的Socket类则实现了两台计算机间的数据联通交流.每次学习了新知识,就会忍不住的进行脑洞和实践.因此本文旨在利用两个知识点进行网络编
Android 基于TCP的 Socket 编程实现（结合 okio）
yhao的博客
03-31 3万+
两个进程如果要进行通讯最基本的一个前提就是能够唯一的标识一个进程，在本地进程通讯中我们可以使用 PID 来唯一标识一个进程，但 PID 只在本地是唯一的，网络中两个进程 PID 冲突几率很大，这时我们就需要通过其他手段来唯一标识网络中的进程了，我们知道 IP 层的 ip 地址可以唯一标示主机，而 TCP 层协议和端口号结合就可以唯一标示主机的一个进程了。
Java网络编程 多点聊天chatting 服务器+客户端
04-17
在局域网实现多人聊天功能，通过TCP协议提供简单和快速的网络传输服务来保证聊天的实时性。 程序基于C/S结构，可实现多个客户端与服务端的通信，或者说是建立了一个聊天室，可以实现多人聊天，双方通过确认端口号和局域网IP来实现连接，服务端可以设置最大连接人数，客户端可以断开连接。
循序渐进Socket网络编程（多客户端、信息共享、文件传输）
04-13 816
ddd 前言：在最近一个即将结束的项目中使用到了Socket编程，用于调用另一系统进行处理并返回数据。故把Socket的基础知识总结梳理一遍。 一、TCP/IP协议 　　既然是网络编程，涉及几个系统之间的交互，那么首先要考虑的是如何准确的定位到网络上的一台或几台主机，另一个是如何进行可靠高效的数据传输。这里就要使用到TCP/IP协议。 　　TCP/IP协议（传输控制协议）由网络层的IP协议
java网络编程Socket单服务器与多客户端
coolsunxu的博客
10-13 578
Client package sunxu.util; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; import java.awt.Font; import java.awt.event.ActionEvent; import java.awt.eve
Java通信原理（3）——多客户端连接（1）
最新发布
qq_64037280的博客
04-01 2024
Java、TCP/IP、Socket、通信
java socket 多线程网络传输多个文件
07-14
java socket 多线程网络传输多个文件
Java八股文
earn_est的博客
03-07 1万+
我是2022届双非软件工程应届生，目前在准备秋招，总结了一篇不错的八股文，如果你正好需要可以关注一下，共同学习；超链接如下： Java后端八股文（CSDN不再同步） 语雀地址 Hello, interviewer. My name is . I graduated from Zhengzhou University of Light Industry, majoring in software engineering and I will graduate next year. I have exper
快手java开发面试经验大全
begefefsef的博客
05-20 1万+
1.自我介绍 2.java集合、hashmap详细介绍、关键参数、线程安全的集合、队列和栈、用两个栈实现队列算法 3.jvm结构 4.多线程锁：synchronized、reentrantlock、countdownlatch、锁升级 5.mysql隔离级别 6.线程池有哪些、核心参数、线程池运行机制 7.threadlocal 8.写线程安全单例模式，volatile原理、 9.写单词拆分问题 10.反问 好像叫基础平台部门。java岗。 总体来说，快手的一二面会根据难度循序渐进，并且会出一两个由易到难的
我爱Java
yiqinianmo的博客
02-25 2850
1、 Java 基础知识 1.1 重载和重写的区别 重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。 1.2 String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？ 可变
能真实运行的两个Java文件传输实例
07-16
能真实运行的两个Java文件传输实例，采用TCP方式，方便集成到即时聊天工具
java局域网内文件传输，一对多文件传输
11-05
java多播组实现的文件传输，c/s模式的文件传输，在同一局域网内，开一个服务器，可以向多个客户端发送文件
PrintWriter writer = new PrintWriter(socket.getOutputStream())出现的问题
weixin_44765605的博客
06-07 2437
PrintWriter writer = new PrintWriter(socket.getOutputStream()); 今天在做作业的时候，这个东西卡了我很久。。。 问题： 我的服务端一直接收不到客户端的信息，但是debug的时候，客户端发送信息是全部发送出去了的，而服务端却一直阻塞在等待信息中。后来通过查找资料和试验，我才解决了这个问题。     问题代码： 客户端发送信息： writer.write(tUsername.getText()); writer.write(tP
java用socket客户端和服务器之间通信，传输文件经典例子（详细分析）
透明大脑
08-29 1万+
参考：http://blog.csdn.net/hlhakey/article/details/47030295
java socket 传多个文件下载,Socket编程多文件传输
weixin_39639049的博客
03-13 544
有子曰：“其为人也孝弟，而好犯上者，鲜矣；不好犯上，而好作乱者，未之有也。君子务本，本立而道生。孝弟也者，其为仁之本与！”项目介绍：基于TCP协议实现多文件传输将F盘test文件加下的所有文件发送到D盘下的FTP文件夹里思路：socket发送单个文件，然后通过for循环来实现多文件传输。简单做法(这里就简单说下思路，没实现)：_1) socket与服务器建立连接_2) 然后发送一个文件_3) so...
C# socket编程实践——简单聊天室
Mature
01-09 1374
整体结构 关于怎么具体一步步使用socket我就不说了，有兴趣同学可以看看你得学会并且学得会的Socket编程基础知识，看看我们服务器的结构，我写了一个TcpHelper类来处理服务器操作 首先定义 一个ClientInfo类存放Client信息 /// /// 启动服务器，监听客户端请求 /// /// 服务器端进程口号
浅谈java中的ServerSocket和Socket的通信原理实现聊天及多人聊天
Mikyou的专栏
08-22 1万+
聊天，QQ，微信，陌陌很多的即时通讯的软件，不管是桌面端还是移动端，在当今社交的时代都是不可或缺的一部分。这时候说Socket和ServerSocket感觉有点老调重弹感觉，相信很多人早就知道如何使用了，而且利用这个通信原理可能已经开发出很多优秀的通信软件吧，但是我感觉这个对于刚接触java网络编程的人来说，学会Socket通信实现聊天软件，是必须的一步，了解其中的原理更是非常重要的一步，对，很多
11个Java 开源 socket框架
ljheee的博客
12-20 3万+
Ice的Java版，Netty2作者的后续之作Apache MINA，Crmky的Cindy之外，还有个超简单的QuickServer，让你专心编写自己的业务代码，不用编写一行TCP代码。 一、QuickServer 是一个免费的开源Java库，用于快速创建健壮的多线程、多客户端TCP服务器应用程序。使用QuickServer，用户可以只集中处理应用程序的逻辑/协议。 二、Nett
Java Socket实现多个客户端连接同一个服务端
热门推荐
大智若愚的Giraffe
08-30 4万+
使用Socket实现多个客户端和同一客户端通讯；首先客户端连接服务端发送一条消息，服务端接收到消息后进行处理，完成后再回复客户端一条消息。本人通过自己的思维编写了一份服务端和客户端实现的代码，望能与大家相互学习，共同进步。   服务端代码 import java.io.BufferedReader; import java.io.IOException; import java.i
Java Socket文件传输：客户端与服务端实现详解
"Java Socket实现文件传输的示例代码提供了客户端和服务端的实现方式，用于在Java中通过Socket进行文件的发送和接收。" 在Java编程中，Socket是一种网络通信机制，它允许两个应用程序通过网络进行数据交换。在这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值