【JAVA】UDP与TCP套接字编程

一、UDP数据报套接字编程

1、DatagramSocket API

2、DatagramPacket API

3、InetSocketAddress API

4、示例一

5、示例二

二、TCP流套接字编程

1、ServerSocket API

2、Socket API

3、TCP中的长短连接

4、示例一

5、示例二

一、UDP数据报套接字编程

1、DatagramSocket API

DatagramSocket是UDP Socket，用于发送和接收UDP数据报。

DatagramSocket的构造方法有：

方法签名	方法说明
DatagramSocket()	创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）
DatagramSocket(int port)	创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）

DatagramSocket的方法有：

方法签名	方法说明
void receive(DatagramPacket p)	从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p)	从此套接字发送数据报（不会阻塞等待，直接发送）
void close()	关闭此数据报套接字

2、DatagramPacket API

DatagramPacket是UDP Socket发送和接收的数据报。

DatagramPacket的构造方法有：

方法签名	方法说明
DatagramPacket(byte[] buf, int length)	构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数length）
DatagramPacket(byte[] buf, int length, SocketAddress address)	构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号

DatagramPacket的方法有：

方法签名	方法说明
InetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()	获取数据报中的数据

构造UDP发送的数据报时，需要传入SocketAddress，该对象可以使用InetSocketAddress来创建。

3、InetSocketAddress API

InetSocketAddress（SocketAddress的子类）构造方法有：

方法签名	方法说明
InetSocketAddress(InetAddress addr, int port)	创建一个Socket地址，包含IP地址和端口号

4、示例一

通过客户端向服务端发送数据，服务端接收数据之后将数据处理一下然后返回客户端。

UDP客户端

import java.io.IOException;
import java.net.*;
import java.util.Scanner;public class UdpEchoClient {private DatagramSocket socket = null;private String serverIp = "";private int serverport = 0;public UdpEchoClient(String ip,int port) throws SocketException {// 创建这个对象, 不能手动指定端口.socket = new DatagramSocket();// 由于 UDP 自身不会持有对端的信息. 就需要在应用程序里, 把对端的情况给记录下来.// 这里咱们主要记录对端的 ip 和 端口 .serverIp = ip;serverport = port;}public void start() throws IOException {System.out.println("客户端启动！");Scanner scanner = new Scanner(System.in);while(true){// 1. 从控制台读取数据, 作为请求System.out.print("->");String request = scanner.next();// 2. 把请求内容构造成 DatagramPacket 对象, 发给服务器.DatagramPacket packet = new DatagramPacket(request.getBytes(),request.getBytes().length, InetAddress.getByName(serverIp),serverport);socket.send(packet);// 3. 尝试读取服务器返回的响应了.DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);socket.receive(responsePacket);// 4. 把响应, 转换成字符串, 并显示出来.String response = new String(responsePacket.getData(),0,responsePacket.getLength());System.out.println(response);}}public static void main(String[] args) throws IOException{UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);client.start();}
}

UDP服务端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;public class UdpEchoServer {// 创建一个 DatagramSocket 对象. 后续操作网卡的基础.private DatagramSocket socket = null;public UdpEchoServer(int port) throws SocketException {// 这么写就是手动指定端口socket = new DatagramSocket(port);// 这么写就是让系统自动分配端口// socket = new DatagramSocket();}public void start() throws IOException {// 通过这个方法来启动服务器.System.out.println("服务器启动!");while(true){// 1. 读取请求并解析.DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);socket.receive(requestPacket);// 当前完成 receive 之后, 数据是以 二进制 的形式存储到 DatagramPacket 中了.// 要想能够把这里的数据给显示出来, 还需要把这个二进制数据给转成字符串.String request = new String(requestPacket.getData(), 0, requestPacket.getLength());// 2. 根据请求计算响应(一般的服务器都会经历的过程)//    由于此处是回显服务器, 请求是啥样, 响应就是啥样.String response = process(request);// 3. 把响应写回到客户端.//    搞一个响应对象, DatagramPacket//    往 DatagramPacket 里构造刚才的数据, 再通过 send 返回.DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length, requestPacket.getSocketAddress());socket.send(responsePacket);// 4. 打印一个日志, 把这次数据交互的详情打印出来.System.out.printf("[%s:%d] req=%s, resp=%s\n", requestPacket.getAddress().toString(), requestPacket.getPort(), request, response);}}public String process(String request) {return request;}public static void main(String[] args) throws IOException {UdpEchoServer server = new UdpEchoServer(9090);server.start();}
}

我们对上面的服务端进行封装一下，做一个非常简单的翻译器出来：

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;public class UdpDictServer extends UdpEchoServer{private Map<String,String> dict = new HashMap<>();public UdpDictServer(int port) throws SocketException {super(port);dict.put("dog", "小狗");dict.put("cat", "小猫");dict.put("pig", "小猪");}// 重写 process 方法, 在重写的方法中完成翻译的过程.// 翻译本质上就是 "查表"@Overridepublic String process(String request){return dict.getOrDefault(request, "该词在词典中不存在!");}public static void main(String[] args) throws IOException {UdpDictServer server = new UdpDictServer(9090);server.start();}
}

5、示例二

构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务：

客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
发送请求：将该相对路径作为数据报发送到服务端
服务端接收并处理请求：根据该请求数据，作为本地目录的路径，列出下一级子文件及子文件夹
服务端返回响应：遍历子文件和子文件夹，每个文件名一行，作为响应的数据报，返回给客户端
客户端接收响应：简单的打印输出所有的响应内容，即文件列表。

为了解决空字符或长度不足数据丢失的问题，客户端服务端约定好统一的协议：这里简单的设计为ASCII结束字符\3表示报文结束。以下为整个客户端服务端的交互执行流程：

以下为客户端与服务端的代码：

UDP服务端

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Array;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;public class UdpServer {private static final int PORT=8888;private static final String BASE_PATH = "E:/TMP";public static void main(String[] args) throws IOException{DatagramSocket  socket = new DatagramSocket(PORT);while(true){byte[] requestData = new byte[1024];DatagramPacket requestPacket = new DatagramPacket(requestData,requestData.length);System.out.println("------------------------------------------");System.out.println("等待接收UDP数据报...");socket.receive(requestPacket);System.out.printf("客户端IP：%s%n",requestPacket.getAddress().getHostAddress());System.out.printf("客户端端口号：%s%n", requestPacket.getPort());for(int i = 0;i< requestData.length;i++){byte b = requestData[i];if(b == '\3'){String request = new String(requestData,0,i);System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH + request);File dir = new File(BASE_PATH + request);File[] children = dir.listFiles();StringBuilder response = new StringBuilder();if(children != null){for(File child : children){response.append(child.getName()+'\n');}}response.append("\3");byte[] responseData = response.toString().getBytes(StandardCharsets.UTF_8);System.out.println(response);DatagramPacket responsePacket = new DatagramPacket(responseData,responseData.length,requestPacket.getSocketAddress());socket.send(responsePacket);break;}}}}
}

UDP客户端

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Array;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;public class UdpServer {private static final int PORT=8888;private static final String BASE_PATH = "E:/TMP";public static void main(String[] args) throws IOException{DatagramSocket  socket = new DatagramSocket(PORT);while(true){byte[] requestData = new byte[1024];DatagramPacket requestPacket = new DatagramPacket(requestData,requestData.length);System.out.println("------------------------------------------");System.out.println("等待接收UDP数据报...");socket.receive(requestPacket);System.out.printf("客户端IP：%s%n",requestPacket.getAddress().getHostAddress());System.out.printf("客户端端口号：%s%n", requestPacket.getPort());for(int i = 0;i< requestData.length;i++){byte b = requestData[i];if(b == '\3'){String request = new String(requestData,0,i);System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH + request);File dir = new File(BASE_PATH + request);File[] children = dir.listFiles();StringBuilder response = new StringBuilder();if(children != null){for(File child : children){response.append(child.getName()+'\n');}}response.append("\3");byte[] responseData = response.toString().getBytes(StandardCharsets.UTF_8);System.out.println(response);DatagramPacket responsePacket = new DatagramPacket(responseData,responseData.length,requestPacket.getSocketAddress());socket.send(responsePacket);break;}}}}
}

上述的代码中，我们为什么没有写close呢？

socket是文件描述符表中的一个表项。每次打开一个文件，就会占用一个位置。而文件描述符，是在pcb上的。(跟随进程的)

这个socket在整个程序运行过程中都是需要使用的（不能提前关闭）。当socket不需要使用的时候，程序就要结束了。进程结束，此时文件描述符表就会销毁了（PCB 都销毁了）。随着销毁的过程，套接字就被系统自动回收了。

那么什么时候会出现资源泄露呢？

代码中频繁的打开文件，但是不关闭。在一个进程的运行过程中，不断积累打开的文件，逐渐消耗掉文件描述符表里的内容，最终就消耗殆尽了。但是如果进程的生命周期很短，打开一下没多久就关闭了，谈不上泄露。
文件资源泄露这样的问题，在服务器这边是比较严重的，在客户端这边一般来说影响不大。

二、TCP流套接字编程

1、ServerSocket API

ServerSocket是创建TCP服务端Socket的API。

ServerSocket构造方法是：

方法签名	方法说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定到指定端口

ServerSocket的一般方法有：

方法签名	方法说明
Socket accept()	开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接，否则阻塞等待
void close()	关闭此套接字

2、Socket API

Socket是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。

不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。

Socket的构造方法有：

方法签名	方法说明
Socket(String host, int port)	创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接

Socket的一般方法有：

方法签名	方法说明
InetAddress getInetAddress()	返回套接字所连接的地址
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

3、TCP中的长短连接

TCP发送数据时，需要先建立连接，什么时候关闭连接就决定它是短连接还是长连接：

短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

对比以上长短连接，两者区别如下：

建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

4、示例一

我们模仿UDP示例一来写一下TCP服务端与客户端：

TCP服务端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class TcpEchoServer {private ServerSocket serverSocket = null;public TcpEchoServer(int port) throws IOException {serverSocket = new ServerSocket(port);}public void start() throws IOException {System.out.println("服务器启动!");ExecutorService service = Executors.newCachedThreadPool();while (true) {// 通过 accept 方法, 把内核中已经建立好的连接拿到应用程序中.// 建立连接的细节流程都是内核自动完成的. 应用程序只需要 "捡现成" 的.Socket clientSocket = serverSocket.accept();// 此处不应该直接调用 processConnection, 会导致服务器不能处理多个客户端.// 创建新的线程来调用更合理的做法.// 这种做法可行, 不够好
//            Thread t = new Thread(() -> {
//                processConnection(clientSocket);
//            });
//            t.start();// 更好一点的办法, 是使用线程池.service.submit(new Runnable() {@Overridepublic void run() {processConnection(clientSocket);}});}}// 通过这个方法, 来处理当前的连接.public void processConnection(Socket clientSocket) {// 进入方法, 先打印一个日志, 表示当前有客户端连上了.System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress(), clientSocket.getPort());// 接下来进行数据的交互.try (InputStream inputStream = clientSocket.getInputStream();OutputStream outputStream = clientSocket.getOutputStream()) {// 使用 try ( ) 方式, 避免后续用完了流对象, 忘记关闭.// 由于客户端发来的数据, 可能是 "多条数据", 针对多条数据, 就循环的处理.while (true) {Scanner scanner = new Scanner(inputStream);if (!scanner.hasNext()) {// 连接断开了. 此时循环就应该结束System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress(), clientSocket.getPort());break;}// 1. 读取请求并解析. 此处就以 next 来作为读取请求的方式. next 的规则是, 读到 "空白符" 就返回.String request = scanner.next();// 2. 根据请求, 计算响应.String response = process(request);// 3. 把响应写回到客户端.//    可以把 String 转成字节数组, 写入到 OutputStream//    也可以使用 PrintWriter 把 OutputStream 包裹一下, 来写入字符串.PrintWriter printWriter = new PrintWriter(outputStream);//    此处的 println 不是打印到控制台了, 而是写入到 outputStream 对应的流对象中, 也就是写入到 clientSocket 里面.//    自然这个数据也就通过网络发送出去了. (发给当前这个连接的另外一端)//    此处使用 println 带有 \n 也是为了后续 客户端这边 可以使用 scanner.next 来读取数据.printWriter.println(response);//    此处还要记得有个操作, 刷新缓冲区. 如果没有刷新操作, 可能数据仍然是在内存中, 没有被写入网卡.printWriter.flush();// 4. 打印一下这次请求交互过程的内容System.out.printf("[%s:%d] req=%s, resp=%s\n", clientSocket.getInetAddress(), clientSocket.getPort(),request, response);}} catch (IOException e) {e.printStackTrace();} finally {try {// 在这个地方, 进行 clientSocket 的关闭.// processConnection 就是在处理一个连接. 这个方法执行完毕, 这个连接也就处理完了.clientSocket.close();} catch (IOException e) {e.printStackTrace();}}}public String process(String request) {// 此处也是写的回显服务器. 响应和请求是一样的.return request;}public static void main(String[] args) throws IOException {TcpEchoServer server = new TcpEchoServer(9090);server.start();}
}

TCP客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;public class TcpEchoClient {private Socket socket = null;public TcpEchoClient(String serverIp, int serverPort) throws IOException {// 需要在创建 Socket 的同时, 和服务器 "建立连接", 此时就得告诉 Socket 服务器在哪里~~// 具体建立连接的细节, 不需要咱们代码手动干预. 是内核自动负责的.// 当我们 new 这个对象的时候, 操作系统内核, 就开始进行 三次握手 具体细节, 完成建立连接的过程了.socket = new Socket(serverIp, serverPort);}public void start() {// tcp 的客户端行为和 udp 的客户端差不多.// 都是:// 3. 从服务器读取响应.// 4. 把响应显示到界面上.Scanner scanner = new Scanner(System.in);try (InputStream inputStream = socket.getInputStream();OutputStream outputStream = socket.getOutputStream()) {PrintWriter writer = new PrintWriter(outputStream);Scanner scannerNetwork = new Scanner(inputStream);while (true) {// 1. 从控制台读取用户输入的内容System.out.print("-> ");String request = scanner.next();// 2. 把字符串作为请求, 发送给服务器//    这里使用 println, 是为了让请求后面带上换行.//    也就是和服务器读取请求, scanner.next 呼应writer.println(request);writer.flush();// 3. 读取服务器返回的响应.String response = scannerNetwork.next();// 4. 在界面上显示内容了.System.out.println(response);}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) throws IOException {TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);client.start();}
}

5、示例二

构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务：

客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
发送请求：使用客户端Socket的输出流发送TCP报文。即输入的相对路径。
服务端接收并处理请求：使用服务端Socket的输入流来接收请求报文，根据请求的路径，列出下一级子文件及子文件夹。
服务端返回响应：使用服务端Socket的输出流来发送响应报文。即遍历子文件和子文件夹，每个文件名一行，返回给客户端。
客户端接收响应：使用客户端Socket的输入流来接收响应报文。简单的打印输出所有的响应内容，即文件列表。

以下为服务端和客户端代码：

TCP服务端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;public class TCPsockServer {//服务器socket要绑定固定的端口private static final int PORT = 8888;//本地文件目录要展示的根路径private static final String BASE_PATH = "E:/TMP";public static void main(String[] args) throws IOException {// 1.创建一个服务端ServerSocket，用于收发TCP报文ServerSocket server = new ServerSocket(PORT);// 不停的等待客户端连接while(true) {System.out.println("---------------------------------------------------");System.out.println("等待客户端建立TCP连接...");// 2.等待客户端连接，注意该方法为阻塞方法Socket socket = server.accept();System.out.printf("客户端IP：%s%n", socket.getInetAddress().getHostAddress());System.out.printf("客户端端口号：%s%n", socket.getPort());// 5.接收客户端的数据，需要从客户端Socket中的输入流获取InputStream is = socket.getInputStream();// 为了方便获取字符串内容，可以将以上字节流包装为字符流BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));// 客户端请求只发送一行数据，我们也只需要读取一行String request = br.readLine();// 6.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列出下一级子文件//请求的文件列表目录System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH + request);File dir = new File(BASE_PATH + request);//获取下一级子文件，子文件夹File[] children = dir.listFiles();// 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据OutputStream os = socket.getOutputStream();// 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));// 7-1.返回的响应内容：每个文件及目录名称为一行if(children != null){for (File child : children) {pw.println(child.getName());}}// 7-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区pw.flush();// 7-3.双方关闭连接：服务端是关闭客户端socket连接socket.close();}}
}

TCP客户端

import java.io.*;
import java.net.Socket;
import java.util.Scanner;public class TCPsockClient {//服务端IP或域名private static final String SERVER_HOST = "localhost";//服务端Socket进程的端口号private static final int SERVER_PORT = 8888;public static void main(String[] args) throws IOException {// 准备要发送的数据：这里调整为键盘输入作为发送的内容Scanner scanner = new Scanner(System.in);while(true) {System.out.println("---------------------------------------------------");System.out.println("请输入要展示的目录：");// 每输入新行（回车），就作为发送的TCP请求报文String request = scanner.nextLine();// 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接Socket socket = new Socket(SERVER_HOST, SERVER_PORT);// 发送TCP数据，是通过socket中的输出流进行发送OutputStream os = socket.getOutputStream();// 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));// 发送数据：pw.println(request);// 有缓冲区的IO操作，真正传输数据，需要刷新缓冲区pw.flush();// 接收返回的响应数据：通过socket中的输入流获取System.out.println("接收到服务端响应：");InputStream is = socket.getInputStream();// 为了方便获取字符串内容，可以将以上字节流包装为字符流BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));String line;// 一直读取到流结束：TCP是基于流的数据传输，一定要服务端关闭Socket输出流才表示客户端接收的IO输入流结束while ((line = br.readLine()) != null) {System.out.println(line);}// 双方关闭连接：客户端关闭socket连接socket.close();}}
}