JavaEE：网络编程套接字
文章目录
- 一、网络编程基础
-
- 1、为什么需要网络编程
- 2、什么是网络编程
- 3、网络编程中的基本概念
-
- ① 发送端和接收端
- ② 请求和相应
- ③ 客户端和服务端
- ④ 常见的客户端服务端模型
- 二、Socket套接字
-
- 1、概念
- 2、分类
-
- ① 流套接字（TCP）
- ② 数据报套接字（UDP）
- ③ 原始套接字
- 三、UDP数据报套接字编程
-
- 1、DatagramSocket API
- 2、DatagramPacket API
- 3、InetSocketAddress API
- 4、示例一：一发一收（无响应）
-
- ① UDP服务端
- ② UDP客户端
- 5、示例二：请求响应
-
- ① UDP服务端
- ② UDP客户端
- 四、TCP流套接字编程
-
- 1、ServerSocket API
- 2、Socket API
- 3、TCP中的长短连接
- 4、示例一：一发一收（长连接）
-
- ① TCP服务端
- ② TCP客户端
- 5、示例二：请求响应（长连接）
-
- ① TCP服务端
- ② TCP客户端
一、网络编程基础
1、为什么需要网络编程
与本地打开视频文件类似，只是视频文件这个资源的来源是网络。
相比本地资源来说，网络提供了更为丰富的网络资源：
所谓的网络资源，其实就是在网络中可以获取的各种数据资源。
而所有的网络资源，都是通过网络编程来进行数据传输的。
2、什么是网络编程
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。
进程具有隔离性（每个进程都有自己独立的虚拟地址空间）.
进程间通信，借助一个每个进程都能访问到的公共区域，完成数据交换.
网络编程，也就是一种进程 间通信的方式，借助的公共区域就是 网卡.（当下最主流的方式）
3、网络编程中的基本概念
① 发送端和接收端
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。
② 请求和相应
请求：客户端给服务器发送的数据.
响应：服务器给客户端返回的数据.
③ 客户端和服务端
客户端：主动发送网络数据的一方.
服务器：被动接受网络数据的一方.
④ 常见的客户端服务端模型
- 一问一答（最常见的方式，比如：浏览网页）
客户端给服务器发一个请求
服务器给客户端返回一个响应 - 多问一答（更少见一些，比如：上传文件）
客户端给服务器发多个请求
服务器给客户端返回一个响应 - 一问多答（不多不少，比如：下载文件）
客户端给服务器发一个请求
服务器给客户端返回多个响应 - 多问多答（比如：远程控制，有些串流）
客户端给服务器发多个请求
服务器给客户端返回多个响应
二、Socket套接字
1、概念
Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。
2、分类
Socket套接字主要针对传输层协议划分为如下三类：
流套接字（TCP）、数据报套接字（UDP）、原始套接字.
① 流套接字（TCP）
TCP，即Transmission Control Protocol（传输控制协议），传输层协议。
TCP 特点：
- 有连接（打电话：先建立连接，然后再通信）
- 可靠传输（数据对方是否收到，发送方能够感知）
- 面向字节流
- 全双工（双向通信，一个管道，能 A->B，B->A 同时进行）
对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。
② 数据报套接字（UDP）
UDP，即User Datagram Protocol（用户数据报协议），传输层协议。
UDP 特点：
- 无连接（发微信：不必建立连接，直接通信即可）
- 不可靠传输（数据对方是否收到，发送方无法感知）
- 面向数据报
- 全双工（单向通信，一个管道，同一时刻，要么 A->B，要么 B->A，不能同时进行）
对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。
③ 原始套接字
原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
我们不学习原始套接字，简单了解即可。
三、UDP数据报套接字编程
1、DatagramSocket API
DatagramSocket：socke类，本质上相当于是一个 “文件”，在系统中，还有一种特殊的 socket 文件，对应到网卡设备.
构造一个 DatagramSocket 对象，就相当于是打开了一个 内核中的 socket 文件.
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 数据报，UDP 是面向数据报的协议，传输数据，就是以 DatagramPacket 为基本单位.
DatagramPacket 构造方法：
| 方法签名 | 方法说明 |
|---|---|
| DatagramPacket(byte[] buf, int length) | 构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数 length） |
| DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) | 构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号 |
DatagramPacket 方法：
| 方法签名 | 方法说明 |
|---|---|
| InetAddress getAddress() | 从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址 |
| int getPort() | 从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号 |
| byte[] getData() | 获取数据报中的数据 |
3、InetSocketAddress API
InetSocketAddress：IP 地址 + 端口号.
InetSocketAddress （ SocketAddress 的子类 ）构造方法：
| 方法签名 | 方法说明 |
|---|---|
| InetSocketAddress(InetAddress addr, int port) | 创建一个Socket地址，包含IP地址和端口号 |
4、示例一：一发一收（无响应）
① UDP服务端
package network;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UDP_demo1_Server {
private DatagramSocket socket = null;
public UDP_demo1_Server(int port) throws SocketException {
socket = new DatagramSocket(port);
}
// 启动服务器
public void start() throws IOException {
System.out.println("服务器启动！");
while (true) {
// 1. 读取客户端发来的请求.
DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
System.out.println("---------------------------------------------------");
System.out.println("等待接收UDP数据报...");
socket.receive(requestPacket);
// 2. 对请求进行解析，把 DatagramPacket 转成一个 String
String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
System.out.printf("IP: %s\n",requestPacket.getAddress().getHostAddress());
System.out.printf("端口号: %s\n",requestPacket.getPort());
System.out.printf("req: %s\n",request);
}
}
public static void main(String[] args) throws IOException {
// 真正启动服务器
UDP_demo1_Server server = new UDP_demo1_Server(8000);
server.start();
}
}
② UDP客户端
package network;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
public class UDP_demo1_Client {
private DatagramSocket socket = null;
public UDP_demo1_Client() throws SocketException {
socket = new DatagramSocket();
}
public void start() throws IOException {
Scanner scanner = new Scanner(System.in);
while (true) {
// 1. 让客户端从控制台读取一个请求数据.
System.out.print("> ");
String request = scanner.next();
// 2. 把这个字符串请求发送给服务器，构造 DatagramPacket
// 构造的 Packet 既要包含 要传输的数据，又要包含把数据发到哪里
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
InetAddress.getByName("127.0.0.1"), 8000);
// 3. 把数据报发给服务器.
socket.send(requestPacket);
}
}
public static void main(String[] args) throws IOException {
UDP_demo1_Client client = new UDP_demo1_Client();
client.start();
}
}
5、示例二：请求响应
① UDP服务端
package network;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UDPEchoServer {
// 要想创建 UDP 服务器，首先要先打开一个 socket 文件.
private DatagramSocket socket = null;
public UDPEchoServer(int port) throws SocketException {
// 绑定一个端口：把这个进程和一个端口号，关联起来
// 一个操作系统上，有很多端口号：0~65535
// 端口号相当于用来在网络上区分进程的身份标识符
// 分配端口号的过程：
// 1. 程序员手动绑定
// socket = new DatagramSocket(port);
// 2. 系统自动分配（系统自动分配一个闲置的端口）
// socket = new DatagramSocket();
// 一个端口，在通常情况下，是不能被同一个主机上的多个进程同时绑定的
// 如果同时绑定，就会抛出 SocketException 异常.
socket = new DatagramSocket(port);
}
// 启动服务器
public void start() throws IOException {
System.out.println("服务器启动！");
while (true) {
// 1. 读取客户端发来的请求.
// receive 是尝试读取，不是说调用了就一定能读取到！
// 如果客户端没有发来请求，receive 就会阻塞等待.
// receive 的参数属于输出型参数
// 调用 receive 之前，需要构造一个空的 DatagramPacket
DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(requestPacket);
// 2. 对请求进行解析，把 DatagramPacket 转成一个 String
String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
// 3. 根据请求，处理相应
String response = process(request);
// 4. 把响应构造成 DatagramPacket 对象.
// 构造响应对象，要搞清楚，对象要发给谁，谁发的请求，就把响应发给谁
// response.getBytes().length 表示字节数
// response..length 表示字符数
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
requestPacket.getSocketAddress());
// 5. 把这个 DatagramPacket 对象 返回给客户端.
socket.send(responsePacket);
System.out.printf("[%s:%d] req=%s; resp=%s\n", requestPacket.getAddress().toString(), requestPacket.getPort(),
request, response);
}
}
// 通过这个方法，实现根据请求计算响应 这个过程
// 由于是回显服务器，所以不涉及其他逻辑
// 但是如果是其他服务器，就可以在 process 里，加上其他逻辑处理
public String process(String req) {
return req;
}
public static void main(String[] args) throws IOException {
// 真正启动服务器
// 端口号 0~65535 随便写，但是一般来说 1024 一下的端口，都是系统保留.
UDPEchoServer server = new UDPEchoServer(8000);
server.start();
}
}
② UDP客户端
package network;
import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class UDPEchoClient {
private DatagramSocket socket = null;
public UDPEchoClient() throws SocketException {
// 客户端的端口号，一般都是由操作系统自动分配的
// 虽然手动指定也许，习惯上还是自动分配比较好
// ①服务器，端口一般是手动指定的
// 如果自动分配，客户端就不知道服务器的端口是什么了！
// ②客户端，端口一般是自动分配的
// 客户端程序是安装在用户的电脑上的，用户电脑当前运行哪些程序，是不可控的
// 如果手动指定端口号，说不定这个端口就和其他程序冲突了，代码就无法运行了
socket = new DatagramSocket();
}
public void start() throws IOException {
Scanner scanner = new Scanner(System.in);
while (true) {
// 1. 让客户端从控制台读取一个请求数据.
System.out.print("> ");
String request = scanner.next();
// 2. 把这个字符串请求发送给服务器，构造 DatagramPacket
// 构造的 Packet 既要包含 要传输的数据，又要包含把数据发到哪里
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
InetAddress.getByName("127.0.0.1"), 8000);
// 3. 把数据报发给服务器.
socket.send(requestPacket);
// 4. 从服务器读取响应数据
DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(responsePacket);
// 5. 把响应的数据获取出来，转成字符串
String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
System.out.printf("req: %s; resp: %s\n", request, response);
}
}
public static void main(String[] args) throws IOException {
UDPEchoClient client = new UDPEchoClient();
client.start();
}
}
四、TCP流套接字编程
1、ServerSocket API
ServerSocket 是创建 TCP 服务端 Socket 的 API.
accept 没有参数，返回值是一个 Socket 对象， 功能是等待有客户端和服务器建立上连接.
accept 则会把这个连接获取到进程中，进一步的通过返回值的 Socket 对象来和客户端进行交互
ServerSocket 构造方法：
| 方法签名 | 方法说明 |
|---|---|
| ServerSocket(int port) | 创建一个服务端流套接字Socket，并绑定到指定端口 |
ServerSocket 方法：
| 方法签名 | 方法说明 |
|---|---|
| Socket accept() | 开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket 对象，并基于该Socket建立与客户端的连接，否则阻塞等待 |
| void close() | 关闭此套接字 |
2、Socket API
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端 Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
这里的传输数据，不是直接通过 Socket 对象，而是 Socket 内部包含了输入流 对象（接收）输出流 对象（发送）。
Socket 构造方法：
| 方法签名 | 方法说明 |
|---|---|
| Socket(String host, int port) | 创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接 |
Socket 方法：
| 方法签名 | 方法说明 |
|---|---|
| InetAddress getInetAddress() | 返回套接字所连接的地址 |
| InputStream getInputStream() | 返回此套接字的输入流 |
| OutputStream getOutputStream() | 返回此套接字的输出流 |
3、TCP中的长短连接
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
4、示例一：一发一收（长连接）
① TCP服务端
package network;
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;
public class Tcp_demo1_Server {
private ServerSocket serverSocket = null;
public Tcp_demo1_Server(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动！");
while (true) {
Socket clientSocket = serverSocket.accept();
processConnect(clientSocket);
}
}
private void processConnect(Socket clientSocket) throws IOException {
System.out.printf("[%s:%d] 建立连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
Scanner scanner = new Scanner(inputStream);
PrintWriter printWriter = new PrintWriter(outputStream);
while (true) {
if (!scanner.hasNext()) {
// 连接断开，当客户端断开连接的时候，此时 hasNext 就会返回 false
System.out.printf("[%s:%d] 断开连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
break;
}
// 1. 读取请求并解析
String request = scanner.next();
// 2. 返回字符串
String response = process(request);
System.out.printf("[%s:%d] req: %s！\n",
clientSocket.getInetAddress().toString(), clientSocket.getPort(),
request);
}
}finally {
clientSocket.close();
}
}
public String process(String req) {
return req;
}
public static void main(String[] args) throws IOException {
Tcp_demo1_Server server = new Tcp_demo1_Server(8000);
server.start();
}
}
② TCP客户端
package network;
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 Tcp_demo1_Client {
private Socket socket = null;
public Tcp_demo1_Client() throws IOException {
socket = new Socket("127.0.0.1", 8000);
}
public void start() throws IOException {
// 由于实现的是长连接，一个连接会处理 N 个请求和响应
Scanner scanner = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
Scanner scannerNet = new Scanner(inputStream);
PrintWriter printWriter = new PrintWriter(outputStream);
while (true) {
// 1. 从控制台读取用户的输入.
System.out.print("> ");
String request = scanner.next();
// 2. 把请求发送到服务器
printWriter.println(request);
printWriter.flush();
// 3. 把结果显示到界面上
System.out.printf("req: %s\n", request);
}
}
}
public static void main(String[] args) throws IOException {
Tcp_demo1_Client client = new Tcp_demo1_Client();
client.start();
}
}
5、示例二：请求响应（长连接）
① TCP服务端
package network;
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;
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("服务器启动！");
while (true) {
// accept 进行的工作，是拉客
// 对于操作系统来说，建立 TCP 连接，是内核的工作.
// accept 是等连接建立好了，把这个连接拿到 应用程序 中.
// 如果当前连接还没有建立，accept 就会阻塞
Socket clientSocket = serverSocket.accept();
// 不再直接调用了，而是创建一个新的线程，让新线程来调用
// processConnect(clientSocket);
Thread t=new Thread(()->{
try {
processConnect(clientSocket);
} catch (IOException e) {
e.printStackTrace();
}
});
t.start();
}
}
// 通过这个方法，给当前连上的客户端，提供服务！
// 一个连接过来了，服务方式可能有两种
// 1. 一个连接只进行一次数据交互（一个请求+一个响应） 短连接
// 2. 一个连接进行多次数据交互（N个请求+N个响应） 长连接
// 此处我们来写长连接的版本
private void processConnect(Socket clientSocket) throws IOException {
System.out.printf("[%s:%d] 建立连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
Scanner scanner = new Scanner(inputStream);
PrintWriter printWriter = new PrintWriter(outputStream);
// 这里是长连接的写法，需要通过 循环 来获取到多次交互的情况
while (true) {
if (!scanner.hasNext()) {
// 连接断开，当客户端断开连接的时候，此时 hasNext 就会返回 false
System.out.printf("[%s:%d] 断开连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
break;
}
// 1. 读取请求并解析
String request = scanner.next();
// 2. 根据请求计算响应
String response = process(request);
// 3. 把响应写回给客户端
printWriter.println(response);
// 刷新一下缓冲区，避免数据没有真的发出去
printWriter.flush();
System.out.printf("[%s:%d] req: %s; resp: %s！\n",
clientSocket.getInetAddress().toString(), clientSocket.getPort(),
request, response);
}
}finally {
// 加在这里是更稳妥的做法
// clientSocket 用完之后，要关闭，clientSocket 和 ServerSocket 不同
// ServerSocket 的生命周期，是跟随整个程序的！
// clientSocket 的生命周期，只是当前连接！
// 如果不关闭，就会造成资源泄漏
// ServerSocket 只有一个; clientSocket 会有无数个：每个客户端的连接都是一个！
clientSocket.close();
}
}
public String process(String req) {
return req;
}
public static void main(String[] args) throws IOException {
TcpEchoServer server = new TcpEchoServer(8000);
server.start();
}
}
② TCP客户端
package network;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoClient {
private Socket socket = null;
public TcpEchoClient() throws IOException {
// new 这个对象，需要和服务器建立连接
// 要想建立连接，就得知道服务器在哪里！！
socket = new Socket("127.0.0.1", 8000);
}
public void start() throws IOException {
// 由于实现的是长连接，一个连接会处理 N 个请求和响应
Scanner scanner = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
Scanner scannerNet = new Scanner(inputStream);
PrintWriter printWriter = new PrintWriter(outputStream);
while (true) {
// 1. 从控制台读取用户的输入.
System.out.print("> ");
String request = scanner.next();
// 2. 把请求发送到服务器
printWriter.println(request);
printWriter.flush();
// 3. 从服务器读取响应
String response = scannerNet.next();
// 4. 把结果显示到界面上
System.out.printf("req: %s; resp: %s\n", request, response);
}
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient client = new TcpEchoClient();
client.start();
}
}
