目录
一、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();}}
}