从 Socket 到 Spring Boot：理解 Java 中的网络通信

Source: Dev.to

请提供您希望翻译的具体文本内容，我将按照要求保留源链接、格式和代码块，仅翻译正文部分为简体中文。

分布式系统之间的通信

当我们谈论系统之间的通信，尤其是在分布式应用的上下文中时，实际上是在处理一套经常被框架和高级抽象隐藏的概念。理解这些基础有助于更好地认识 API、Web 服务器和集成在“底层”是如何真正工作的。

网络协议

在实际操作中，当一个系统与另一个系统对话时，并不存在“魔法”：有一层层协议栈，每一层都解决特定的问题。

TCP/IP 的作用

• 传输层（TCP/IP 模型）。
• 负责确保从一个点发送的数据能够正确到达另一端。

TCP 提供：

1. 基于连接的通信
2. 可靠的交付
3. 数据顺序保证
4. 在出现错误时自动重传

因此，它在完整性和一致性至关重要的场景中被广泛使用，例如 HTTP 通信。

摘要： TCP 是一种基于连接的协议，提供两个计算机之间可靠的数据流。

UDP 协议

• 不建立连接，从而降低延迟。
• 适用于丢包不会影响系统的情况（例如：音视频流、在线游戏）。
• 在某些情况下，TCP 的可靠性反而会对服务造成不必要的开销。

端口和寻址

• IP 标识机器。
• 端口 标识机器内部的具体应用。
• TCP 和 UDP 使用端口将数据转发到正确的进程。

端点 = IP + 端口 的组合。
每个 TCP 连接通过两个端点（客户端和服务器）唯一标识。

什么是 Socket？

在 Java 中，java.net 包提供了主要的抽象：

• 当你在 Java 中使用 Socket 时，已经在使用 TCP（协议）。
• HTTP 是运行在 TCP 之上的应用层协议，内部使用 socket。换句话说，HTTP 只是一套通过 TCP socket 传输的请求‑响应消息约定。

浏览器访问网页时 HTTP 在“底层”是如何工作的

1. 浏览器创建一个 TCP socket。
2. 连接到服务器的特定端口（例如：80 或 443）。
3. 通过 socket 发送 HTTP 请求。
4. 服务器接收原始字节流。
5. 服务器解析 HTTP 协议。
6. 服务器生成 HTTP 响应并通过 socket 发送。
7. 浏览器接收、解析并渲染页面。
8. 连接可以关闭，也可以保持打开（keep‑alive），这取决于 HTTP 版本和请求头。

Java 网络编程

更高级的抽象层

• 通过 URL 加载图片
• 访问 HTTP API
• 下载网络资源

在这些情况下，Java 完全隐藏了 socket、TCP 和网络细节。

当我们需要更多控制时

• TCP： Socket 与 ServerSocket
• UDP： DatagramSocket 与 DatagramPacket

基于 socket 的客户端‑服务器通信（TCP 模型）

// Servidor
ServerSocket serverSocket = new ServerSocket(4001);
Socket clientSocket = serverSocket.accept();

PrintStream out = new PrintStream(clientSocket.getOutputStream());
BufferedReader reader = new BufferedReader(
        new InputStreamReader(clientSocket.getInputStream()));

String inputLine;
while ((inputLine = reader.readLine()) != null) {
    out.println("Server received: " + inputLine);
}

// Cliente
Socket socket = new Socket("localhost", 4001);
Scanner scanner = new Scanner(System.in);
PrintStream out = 

Source: …

new PrintStream(socket.getOutputStream());
BufferedReader reader = new BufferedReader(
        new InputStreamReader(socket.getInputStream()));

String message = scanner.nextLine();
out.println(message);               // 发送到服务器
String response = reader.readLine(); // 读取响应
System.out.println("Response: " + response);

支持多客户端

while (true) {
    Socket client = serverSocket.accept();   // 接受新连接
    new Thread(() -> handleClient(client)).start(); // 每个线程处理一个套接字
}

应用层协议

使用协议可以定义：

• 消息格式
• 交互顺序
• 可能的状态
• 有效的响应

在实际系统中，协议可以表示命令、状态、错误和业务流程。

Source: …

通过 Socket 与 Spring Boot 的通信

当我们开始使用 Spring Boot 等框架时，常常会忘记在众多抽象之下，一切仍然归结为网络上的字节交换。理解这种演进不仅有助于编写更好的代码，也能让我们在做架构决策时更加理性。

1️⃣ 起点：TCP 与 Socket

在 Java 中，使用 TCP 最直接的方式就是通过 socket。直接操作 socket 时，开发者需要自行处理所有细节：

1. 打开连接
2. 读取和写入字节
3. 定义消息格式
4. 管理多连接（线程）
5. 处理故障和连接关闭

虽然这种方式功能强大，但很快就会变得难以维护。每个应用都会自行实现“协议”，代码高度耦合于网络基础设施。

使用 socket 的完整服务器和客户端示例

// Server.java
import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(4001);
             Socket clientSocket = serverSocket.accept();
             PrintStream out = new PrintStream(clientSocket.getOutputStream());
             BufferedReader reader = new BufferedReader(
                     new InputStreamReader(clientSocket.getInputStream()))) {

            String inputLine;
            while ((inputLine = reader.readLine()) != null) {
                out.println("Server received: " + inputLine);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// Client.java
import java.io.*;
import java.net.*;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 4001);
             Scanner scanner = new Scanner(System.in);
             PrintStream out = new PrintStream(socket.getOutputStream());
             BufferedReader reader = new BufferedReader(
                     new InputStreamReader(socket.getInputStream()))) {

            System.out.print("Enter message: ");
            String message = scanner.nextLine();

            out.println(message);               // 发送给服务器
            String response = reader.readLine(); // 读取响应
            System.out.println("Response: " + response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

为什么要迁移到 Spring Boot 等框架？

• 底层抽象： Spring 负责连接、线程池、超时等细节。
• 标准化： 使用 REST、WebFlux、Spring MVC，这些已经实现了成熟的应用层协议。
• 测试便利： Mock 与集成测试更为简洁。
• 可扩展性： 与 Tomcat、Jetty、Undertow 等应用服务器以及 Docker/Kubernetes 容器的集成更加顺畅。

理解 TCP、UDP 与 socket，就是理解系统之间通信的基础。Spring、Tomcat 以及 HTTP 等协议的出现，都是为了简化开发者的工作，但它们都依赖这些底层概念。当我们学习 socket 时，就能明白 HTTP 解决了什么问题，为什么会有 Web 服务器，以及分布式系统到底是如何对话的。

String response = reader.readLine(); // 读取服务器响应
System.out.println("Resposta do servidor: " + response);
} catch (IOException e) {
    throw new RuntimeException(e);
}
}
}

2 – HTTP：标准化通信

• 方法：GET、POST、PUT、PATCH、DELETE
• 头部
• 状态码
• 请求和响应的格式

这样，客户端和服务器就能“说同一种语言”，浏览器得以实现，API 也能够以一致的方式出现。

重要：HTTP 并不取代 socket；它仅仅组织通过 socket 传输的内容。

3 – Servlet API：Java 进入 Web 世界的入口

• 开发者开始使用 HttpServletRequest、HttpServletResponse 以及 doGet、doPost 等方法。
• 不再需要手动打开套接字、手工解析 HTTP 请求“手工”或直接处理连接并发。
• 关注点转向 HTTP 请求，而不是网络本身。

4 – Servlet 容器：Tomcat 的作用

仍然需要：

1. 监听端口
2. 管理线程
3. 实现 Servlet API
4. 控制应用的生命周期

这就是 Servlet 容器（Tomcat、Jetty、Undertow 等）的职责。

以 Tomcat 为例

• 打开 TCP 套接字
• 处理 HTTP
• 实例化 servlet
• 将执行委托给应用代码

5 – Web Servers: 处理大规模连接

主要职责：

• 关闭 TCP 和 TLS 连接
• 充当 reverse proxy
• 高性能提供静态内容
• 保护并减轻应用容器的负载

这些服务器不解决应用的业务逻辑；它们负责基础设施，而不是领域。

6 – Java 中的首次 Web 抽象

随着时间的推移，在 servlet 中编写 HTML 被证明效率不高。出现了 JSP 和 JSF 等技术，它们帮助更好地分离视图层，但也带来了：

• 复杂性
• 耦合
• 维护困难

7 – Spring 框架：解耦与组织

Spring 诞生是为了解决 Java 开发中的结构性问题：

• 高耦合
• 测试困难
• 刚性依赖

在 Web 环境（Spring MVC）中，开发者

• 不需要继承 HttpServlet
• 使用 controllers（控制器）
• 通过注解定义路由
• 明确分离职责

Spring 仍然运行在 Servlet API 和一个 容器（Tomcat 或其他）之上，但几乎完全抽象了这些细节。

8 – Spring Boot：最大生产力

即使使用 Spring，配置仍然很繁琐。Spring Boot 出现是为了简化一切：

• 自动配置
• 嵌入式服务器
• 简单启动
• 更少的样板代码

现在，只需

java -jar app.jar

应用程序即可运行，内置 Tomcat，甚至开发者都感觉不到。

结论

通信与编程的演进

TCP → Socket → HTTP → Servlet API → Spring → Spring Boot

基础设施的演进

Web Servers (Apache/Nginx) → Servlet Containers (Tomcat/Jetty)

每一层都降低了复杂性，提高了生产力，并使开发者远离底层细节，但理解这些抽象背后的实现能够区分仅仅使用框架的人和真正架构系统的人。

归根结底，所有的 HTTP 请求仍然始于并结束于一个 TCP 套接字，即使我们在使用 Spring Boot。