java ee--网络编程套接字

Java 网络编程与 Socket 套接字全解

目录

  • 写在前面:我们为什么要谈网络编程
  • 一、什么是网络编程
  • 二、网络编程中的基本概念
    • [2.1 发送端与接收端](#2.1 发送端与接收端)
    • [2.2 请求与响应](#2.2 请求与响应)
    • [2.3 客户端与服务端](#2.3 客户端与服务端)
    • [2.4 经典的客户端/服务端模型(C/S 模型)](#2.4 经典的客户端/服务端模型(C/S 模型))
  • [三、Socket 套接字:网络通信的基本操作单元](#三、Socket 套接字:网络通信的基本操作单元)
    • [3.1 概念](#3.1 概念)
    • [3.2 Socket 的分类](#3.2 Socket 的分类)
  • [四、Java 的通信模型](#四、Java 的通信模型)
    • [4.1 UDP 数据报通信模型](#4.1 UDP 数据报通信模型)
    • [4.2 TCP 流套接字通信模型](#4.2 TCP 流套接字通信模型)
    • [4.3 Socket 编程的注意事项](#4.3 Socket 编程的注意事项)
  • [五、UDP 数据报套接字编程实战](#五、UDP 数据报套接字编程实战)
    • [5.1 核心 API](#5.1 核心 API)
    • [5.2 代码示例:UDP Echo Server(回显服务器)](#5.2 代码示例:UDP Echo Server(回显服务器))
    • [5.3 代码示例:UDP Echo Client(回显客户端)](#5.3 代码示例:UDP Echo Client(回显客户端))
    • [5.4 进阶:UDP 字典服务器(UdpDictServer)](#5.4 进阶:UDP 字典服务器(UdpDictServer))
  • [六、TCP 流套接字编程实战](#六、TCP 流套接字编程实战)
    • [6.1 核心 API](#6.1 核心 API)
    • [6.2 代码示例:TCP Echo Server](#6.2 代码示例:TCP Echo Server)
    • [6.3 代码示例:TCP Echo Client](#6.3 代码示例:TCP Echo Client)
  • 七、从单线程到线程池:让服务器扛住并发
    • [7.1 引入多线程:每个客户端一个线程](#7.1 引入多线程:每个客户端一个线程)
    • [7.2 引入线程池:避免频繁创建/销毁线程](#7.2 引入线程池:避免频繁创建/销毁线程)
  • 八、长连接与短连接
  • 结语:把网络编程串成一条线

写在前面:我们为什么要谈网络编程

我们在浏览器里点开一个在线视频,画面就流畅地播放起来;在手机银行里点一下转账,余额就立刻变化。这些看似理所当然的操作,背后都指向同一件事------通过网络,把一台主机上的数据,送到另一台主机上 。视频、网页、文档、消息......这些"能在网络里被获取的数据",统称网络资源。而本地打开一个视频文件和在线打开一个视频,本质上没有区别,唯一的差别是资源的来源:前者来自本地磁盘,后者来自网络。

网络之于本地,最大的价值就是资源的极大丰富------本地能存储的数据终究有限,而网络把全世界的主机连成一张网,让任何一台机器都能按需获取几乎无限的外部资源。

那么问题来了:数据是怎么在两台机器之间"跑"起来的?答案是网络编程。

我的理解:网络编程听起来高深,其实内核只有一句话------让不同的进程,借助网络,把数据从一端搬到另一端。剩下的所有 API、协议、模型,都是为了把这句朴素的话落地、做快、做稳。

全文我将按"是什么 → 怎么连 → 怎么写代码 → 怎么扛并发"的顺序,从基础概念一路讲到 TCP 高并发,最后回到对网络编程的整体思考。


一、什么是网络编程

网络编程,指网络上的主机,通过不同的进程,以编程的方式实现网络通信(也叫网络数据传输)。

这里有一个关键而容易被忽视的点:判断是不是"网络编程",唯一必须满足的条件是"进程不同"。也就是说,哪怕是同一台主机上,只要数据是基于网络、在不同进程之间传输的,就属于网络编程。

现实中,开发调试阶段我们常常就在一台主机上开两个进程 来模拟通信------一个发、一个收。这完全合法。但我们心里要始终清楚:网络编程真正的目的,是服务于网络上不同主机之间的数据传输。

我们可以把这两个进程的角色固定下来理解:

  • 进程 A :编程来获取网络资源的一方;
  • 进程 B :编程来提供网络资源的一方。

我的理解:很多人初学时纠结"到底算不算网络编程",其实是把"跨主机"和"跨进程"搞混了。记住那条铁律就够了------进程不同即可,同机也行。开发期同机双进程、上线后跨机多进程,是同一种模型的两种部署形态。


二、网络编程中的基本概念

在写第一行代码之前,必须先建立一套准确的"词汇表"。这套词汇决定了你后面理解一切通信模型的天花板。

2.1 发送端与接收端

在一次网络数据传输中:

  • 发送端 :数据的发送方进程,称为发送端;它所在的主机是网络通信中的源主机。
  • 接收端 :数据的接收方进程,称为接收端;它所在的主机是网络通信中的目的主机。
  • 收发端:发送端和接收端两端,合称收发端。

这里有一个必须刻进脑子里 的提醒:发送端和接收端只是相对概念,它只在"某一次数据传输、产生了一个明确数据流向"之后才有意义。同一次会话里,你这一刻是发送端,下一刻可能就是接收端。

2.2 请求与响应

获取一个网络资源,通常涉及两次网络数据传输:

  • 第一次:请求数据的发送(我告诉你我要什么);
  • 第二次:响应数据的发送(我把你要的东西给你)。

这就像在快餐店点一份炒饭:你先发起请求"点一份炒饭",然后快餐店给出对应响应"递上这份炒饭"。一问一答,构成一次完整的资源获取。

我的理解:很多初学者会困惑"明明只发了一次消息,为什么说两次传输"。关键就在于把"传输方向"而非"消息条数"作为计数单位。请求和响应是方向相反的两条独立链路,理解了这一点,后面 UDP 里"只有请求、没有响应"和"完整问答"的区别才看得明白。

2.3 客户端与服务端

把视角从"单次数据流向"抬升到"长期角色分工",就有了客户端与服务端:

  • 服务端 :在常见的网络数据传输场景下,提供服务的一方进程,对外提供持续服务。
  • 客户端 :获取服务的一方进程。

"服务"主要体现为两类动作:

  • 客户端获取服务端的资源;
  • 客户端把资源保存到服务端。

用银行来类比最直观:

  • 银行提供存款 服务:用户(客户端)把资源(现金)保存到银行(服务端);
  • 银行提供取款 服务:用户(客户端)从银行(服务端)获取银行替用户保管的资源(现金)。

2.4 经典的客户端/服务端模型(C/S 模型)

最常见的场景里,客户端是给用户用的程序,服务端是提供服务的程序。一次完整交互的标准四步如下:

  1. 客户端先发送请求到服务端;
  2. 服务端根据请求数据,执行相应的业务处理;
  3. 服务端返回响应:发送业务处理结果;
  4. 客户端根据响应数据,展示处理结果(展示获取到的资源,或提示保存结果)。

我的理解:这"四步循环"几乎是所有应用层协议的骨架。无论是 HTTP、数据库连接,还是你后面要写的 Echo 程序,本质都在跑这个循环。把 C/S 模型吃透,等于拿到了一把万能钥匙。


三、Socket 套接字:网络通信的基本操作单元

3.1 概念

Socket(套接字) ,是由系统提供、用于网络通信的技术,是基于 TCP/IP 协议进行网络通信的基本操作单元。基于 Socket 套接字进行网络程序开发,就是网络编程。

可以把 Socket 理解成网络世界里的"收发器插座":应用程序不直接摆弄网卡和网线,而是把数据交给 Socket,由操作系统和网络协议栈负责把字节送上网络、送达对端。

3.2 Socket 的分类

Socket 主要按传输层协议划分为三类:

(1)流套接字------使用传输层 TCP 协议

TCP,即 Transmission Control Protocol(传输控制协议),是传输层协议。TCP 的特点如下:

  • 有连接:通信前必须先建立连接(三次握手);
  • 可靠传输:保证数据不丢、不乱序、不损坏;
  • 面向字节流:把数据看作一串无结构的字节流;
  • 有接收缓冲区,也有发送缓冲区;
  • 大小不限:数据量不受单次报文硬上限约束。

关于"字节流",可以简单理解为:传输数据是基于 IO 流的。流式数据的特征是------在 IO 流没有关闭的情况下,它是无边界的数据,可以多次发送,也可以分开多次接收。

我的理解:TCP 的"面向字节流"是把双刃剑。它带来灵活------不必为每条消息预设边界;也带来一个经典难题------粘包/拆包 :既然流没有边界,接收方怎么知道一条消息到哪结束?这正是后面 TCP 示例里反复强调"用换行符 \n 分隔消息"的深层原因。

(2)数据报套接字------使用传输层 UDP 协议

UDP,即 User Datagram Protocol(用户数据报协议),是传输层协议。UDP 的特点如下:

  • 无连接:不建立连接,直接发;
  • 不可靠传输:不保证送达、不保证顺序;
  • 面向数据报:以"数据报"为单位收发;
  • 有接收缓冲区,无发送缓冲区;
  • 大小受限:一次最多传输约 64k。

关于"数据报",可以简单理解为:传输数据是一块一块 的。发送一块数据若是 100 个字节,就必须一次性发送,接收方也必须一次性接收 100 个字节,不能拆成 100 次、每次收 1 个字节。

我的理解:TCP 与 UDP 的本质分歧,就是"字节流 "与"数据报 "的分歧。UDP 自带边界,天然没有粘包问题,所以代码简单;代价是把可靠性完全抛给应用自己。TCP 抹平边界、提供可靠,代价是协议栈复杂、有粘包隐患。没有谁绝对更好,只有谁更贴合场景。

(3)原始套接字

原始套接字用于自定义传输层协议,用于读写内核未处理的 IP 协议数据。本课程不深入,了解即可。

一张表看清 TCP 与 UDP:

维度 TCP(流套接字) UDP(数据报套接字)
是否连接 有连接 无连接
可靠性 可靠传输 不可靠传输
数据单位 面向字节流 面向数据报
发送缓冲区 有 无
接收缓冲区 有 有
大小限制 不限 单次约 64k
典型场景 文件、网页、需要可靠的数据 直播、语音、查询类轻量请求

四、Java 的通信模型

4.1 UDP 数据报通信模型

UDP 具有"无连接、面向数据报"的特征:每次都不建立连接,一次发送全部数据报、一次接收全部数据报。

Java 中使用 UDP 通信,主要基于 DatagramSocket 类创建数据报套接字,并用 DatagramPacket 作为发送或接收的 UDP 数据报。

一次"只有请求、没有响应"的简单收发,发送端要做的:

  1. 创建 DatagramSocket;
  2. 构造要发送的内容 DatagramPacket:包含发送的数据(byte[])以及目的 IP、端口号等其他信息;
  3. socket.send(packet) 发送数据报(不阻塞,直接发出)。

接收端要做的:

  1. 创建 DatagramSocket;
  2. 构造接收容器 DatagramPacket:里面放一个空的字节数组 byte[] 用来接收数据;
  3. socket.receive(packet) 等待接收(阻塞式等待),数据到来后填充进容器,并可从中取出发送端 IP、端口。

但上面只是"单向请求"。一个真正的服务端,核心价值在于对多个客户端请求做出响应。完整的请求/响应流程是:

  1. 客户端:send 发出请求数据报;
  2. 服务端:receive 阻塞等待 → 收到请求,receive 向下执行;
  3. 服务端:根据收到的数据,执行业务处理;
  4. 服务端:send 发出响应数据报;
  5. 客户端:receive 收到响应,向下执行。

其核心逻辑总结成一句话:根据响应数据决定下一步怎么做(具体做什么,由业务定)。

4.2 TCP 流套接字通信模型

TCP 模型与 UDP 最大的不同是:通信前要建立连接,连接建立后双方基于"流"反复收发。

Server(服务端)侧:

  1. 创建 ServerSocket,绑定端口;
  2. accept() 等待接收请求;
  3. 接收到连接后,创建一个已建立连接的 Socket;
  4. 通过这个 Socket 拿到 InputStream / OutputStream,与客户端收发数据;
  5. 通信结束 socket.close(),关闭 Socket 与相关资源。

Client(客户端)侧:

  1. 创建 Socket,主动连接服务端、发送请求;
  2. 通过 Socket 的 OutputStream 发送、InputStream 接收;
  3. 结束通信,关闭 Socket 与相关资源。

两侧通过"相互通信"协作,最终以一方调用 socket.close() 结束。

4.3 Socket 编程的注意事项

一次完整通信,链路上要标识清楚这几样东西:源 IP、源端口、目的 IP、目的端口、进程、应用层协议。基于此,有以下几条实践要点:

  1. 客户端与服务端 :开发时经常基于一台主机开两个进程 充当客户端和服务端,但真实场景一般是不同主机。

  2. 目的 IP 与目的端口号 :它们标识了一次数据传输要送达的终点主机 和终点进程------IP 找到机器,端口找到机器上的那个进程。

  3. 应用层协议也要设计 :Socket 编程用的是流套接字或数据报套接字(基于 TCP / UDP),但应用层协议同样需要考虑------数据按什么格式编码、怎么划分边界,这些要在后续专门设计。

  4. 端口被占用的问题(高频报错,务必掌握):

    如果一个进程 A 已经绑定了一个端口,再启动进程 B 去绑定同一个端口,就会报错,这就是"端口被占用 "。Java 进程遇到端口被占用时会抛出类似 Address already in use: bind 的异常。

    排查方式(Windows 为例):先确认进程 B 绑的是哪个端口,再查这个端口被谁占用------

    • 在 cmd 中输入 netstat -ano | findstr 端口号,可显示占用该端口的进程 pid;
    • 在任务管理器中,通过 pid 找到对应进程。

    解决方式:

    • 如果占用端口的进程 A 不需要运行,关闭 A,再启动需要绑定该端口的 B;
    • 如果 A 必须运行,则修改 B 的绑定端口,换一个未被使用的端口。

我的理解:端口被占用是 Java 网络编程新手的"第一大劝退报错"。它其实没有任何玄学,本质就是"一个端口同一时刻只能被一个进程监听 "。学会 netstat -ano | findstr,你就从"重启大法"毕业了。更深一层,这也呼应了"目的 IP + 目的端口唯一定位一个进程"这件事------端口是进程在网络上的门牌号,门牌号不能重复。


五、UDP 数据报套接字编程实战

5.1 核心 API

DatagramSocket

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

构造方法:

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

实例方法:

方法签名 方法说明
void receive(DatagramPacket p) 从此套接字接收数据报(若没收到,会阻塞等待)
void send(DatagramPacket p) 从此套接字发送数据报包(不阻塞,直接发送)
void close() 关闭此数据报套接字
DatagramPacket

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

构造方法:

方法签名 方法说明
DatagramPacket(byte[] buf, int length) 构造一个用于接收 的数据报,接收的数据保存在字节数组 buf 中,接收指定长度 length
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) 构造一个用于发送 的数据报,发送的数据为字节数组 buf(从 offset 起 length 个字节);address 指定目的主机的 IP 和端口号

实例方法:

方法签名 方法说明
InetAddress getAddress() 接收时,返回发送端 主机 IP;发送时,返回接收端主机 IP
int getPort() 接收时,返回发送端 端口;发送时,返回接收端端口
byte[] getData() 获取数据报中的数据

注意:构造发送 数据报时需要传入 SocketAddress,该对象可用 InetSocketAddress 创建。

InetSocketAddress

InetSocketAddress(SocketAddress 的子类)构造方法:

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

5.2 代码示例:UDP Echo Server(回显服务器)

回显(Echo)程序的含义:服务器收到什么,就原样返回什么 。process 里响应内容和请求完全一样。

java 复制代码
import java.io.IOException;
import java.net.*;

public class UdpEchoServer {
    private DatagramSocket socket = null;

    // 参数是服务器要绑定的端口
    public UdpEchoServer(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);
            socket.receive(requestPacket);  // 阻塞等待请求到来
            // 前提:后续客户端发的数据就是文本字符串
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
            // 2. 根据请求,计算出响应
            String response = process(request);
            // 3. 把响应写回客户端:告知网卡要发的内容、发给谁
            DatagramPacket responsePacket = new DatagramPacket(
                    response.getBytes(),
                    response.getBytes().length,
                    requestPacket.getSocketAddress());  // 直接复用请求包里的来源地址
            socket.send(responsePacket);
            // 记录日志,方便观察程序执行效果
            System.out.printf("[%s:%d] req: %s, resp: %s%n",
                    requestPacket.getAddress().getHostAddress(),
                    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();
    }
}

逐点拆解三个核心环节:

  1. 读取请求 :先建一个 4096 字节的接收容器,receive 阻塞等到请求到达,再把字节数组按实际长度 getLength() 转成字符串。
  2. 计算响应 :调用 process,回显程序直接原样返回。
  3. 写回响应 :构造响应数据报时,目的地址直接取自请求包的 getSocketAddress()------请求从哪来,响应就回到哪去,这是 Echo 模型最巧妙的地方。

5.3 代码示例:UDP Echo Client(回显客户端)

java 复制代码
import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    // 服务器的 ip 和端口
    public UdpEchoClient(String ip, int port) throws SocketException {
        serverIp = ip;
        serverPort = port;
        // 不指定端口,让系统自动分配一个空闲端口(客户端惯例)
        socket = new DatagramSocket();
    }

    // 反复从控制台读取输入,构造成 UDP 请求发给服务器,再显示响应
    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("客户端启动!");
        while (true) {
            // 1. 从控制台读取用户输入
            System.out.print("-> ");
            String request = scanner.next();
            // 2. 构造请求对象并发送给服务器
            DatagramPacket requestPacket = new DatagramPacket(
                    request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            // 3. 读取服务器响应并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            // 4. 显示到屏幕
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        // 本机回环地址:127.0.0.1 表示"本机"
        UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
        // 若连接远程服务器,换成公网 IP,例如:new UdpEchoClient("42.192.83.143", 9090);
        client.start();
    }
}

运行方式:先启动 Server,再启动 Client,在客户端输入任意文本,服务器原样返回。

5.4 进阶:UDP 字典服务器(UdpDictServer)

写一个"英译汉"的服务器。只需重写 process,其余收发流程完全复用 UdpEchoServer 的 start------这正是面向对象继承复用的威力。

java 复制代码
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("hello", "你好");
        dict.put("world", "世界");
        dict.put("network", "网络");
    }

    // 复用之前的代码,只调整"根据请求计算响应"这一步
    @Override
    public String process(String request) {
        // 把请求对应单词的翻译返回回去;查不到给提示
        return dict.getOrDefault(request, "该词没有查询到!");
    }

    public static void main(String[] args) throws IOException {
        UdpDictServer server = new UdpDictServer(9090);
        // start 不需要重写,直接复用父类的 start
        server.start();
    }
}

说明:讲义原稿里 dict.put(...) 夹带了不规范的示例词,这里替换成了正常的英汉映射(如 hello→你好),保证示例干净、可公开传播。
我的理解:字典服务器的价值,不在"英译汉"这个功能,而在它示范了一种工程范式------把会变化的部分(业务逻辑)单独抽成可重写的方法,把不变的部分(收发流程)固化在父类。这正是"模板方法模式"的雏形,也是为什么真实框架里到处是"你只需要实现某个接口/重写某个方法"的原因。


六、TCP 流套接字编程实战

和 UDP 类似,下面用 TCP 实现一个简单的回显 + 英译汉功能。

6.1 核心 API

ServerSocket

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

构造方法:

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

实例方法:

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

Socket 是客户端 Socket,也是服务端在 accept() 接收到客户端连接请求后返回的服务端 Socket 。无论客户端还是服务端,Socket 都是双方建立连接后,保存对端信息、用来与对方收发数据的对象。

构造方法:

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

实例方法:

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

我的理解:accept() 是理解 TCP 模型的枢纽 。ServerSocket 只负责"在门口接客",每接到一个新客户端,就返回一个全新的、专属的 Socket。从此这条连接上的所有收发都走这个专属 Socket,而 ServerSocket 自己继续回门口等下一个客人。一个 ServerSocket 对应一张名片(端口),N 个 Socket 对应 N 条独立连接------这就是高并发的物理基础。

补充一点 TCP 的本质:TCP 是面向连接的,建立连接靠"三次握手",断开靠"四次挥手" 。客户端 new Socket(...) 的那一刻,就触发了三次握手,连接才算真正建立;这是它与 UDP"零握手、直接发"最直观的差异。

6.2 代码示例:TCP Echo Server

java 复制代码
import java.io.*;
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 阻塞,直到有客户端连进来
            Socket clientSocket = serverSocket.accept();
            processConnection(clientSocket);  // 处理这一条连接
        }
    }

    // 处理一条连接的完整逻辑
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端上线!%n",
                clientSocket.getInetAddress().getHostAddress(), clientSocket.getPort());
        // Socket 内部包含两个字节流,取出来完成读写
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {

            // 一次连接中,可能涉及多次请求/响应
            while (true) {
                // 1. 读取请求并解析:为方便读取,直接用 Scanner
                Scanner scanner = new Scanner(inputStream);
                if (!scanner.hasNext()) {
                    // 读取完毕,客户端下线
                    System.out.printf("[%s:%d] 客户端下线!%n",
                            clientSocket.getInetAddress().getHostAddress(), clientSocket.getPort());
                    break;
                }
                // 隐含约定:客户端发的请求是文本数据,且带有换行分隔符
                String request = scanner.next();
                // 2. 根据请求计算响应
                String response = process(request);
                // 3. 把响应写回客户端:用 PrintWriter 包一下输出流
                PrintWriter writer = new PrintWriter(outputStream);
                // 用 println 而非 print,是为了在结尾加上 \n,方便客户端按行读取
                writer.println(response);
                // 必须刷新缓冲区,确保数据真的发出去
                writer.flush();
                // 日志:打印当前请求详情
                System.out.printf("[%s:%d] req: %s, resp: %s%n",
                        clientSocket.getInetAddress().getHostAddress(),
                        clientSocket.getPort(), request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 在 finally 中关闭,确保当前 socket 被及时释放
            try {
                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();
    }
}

三个最容易踩的坑,这里全部点破:

  1. Scanner 与"按分隔符切分" :TCP 是字节流、没有边界,scanner.next() 默认按空白(空格/换行)切词。这要求客户端发来的每条请求必须以分隔符(这里用换行)结尾,否则收发对不齐------这正是"粘包/拆包"问题在代码里的具体表现。
  2. println 而不是 print :为的是在响应末尾补一个 \n,让客户端能用 Scanner 按行读出完整一条响应。
  3. flush() 不能忘 :PrintWriter 默认有缓冲,不 flush 数据可能还卡在缓冲区里没真正发出。这是 TCP 程序"明明写了代码却收不到"的头号元凶。

6.3 代码示例:TCP Echo Client

java 复制代码
import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket socket = null;

    // 与服务器通信,要先知道服务器在哪
    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        // 这一行 new 完成的同时,就触发了 TCP 三次握手,连接建立
        socket = new Socket(serverIp, serverPort);
    }

    public void start() {
        System.out.println("客户端启动");
        Scanner scannerConsole = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            while (true) {
                // 1. 从控制台读取字符串
                System.out.print("-> ");
                String request = scannerConsole.next();
                // 2. 把请求发送给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 用 println 带上换行,服务器就能用 scanner.next() 读到完整一条
                printWriter.println(request);
                // 不要忘记 flush,确保数据真的发出去
                printWriter.flush();
                // 3. 从服务器读取响应
                Scanner scannerNetwork = new Scanner(inputStream);
                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();
    }
}

我的理解:把 UDP 和 TCP 两份 Echo 代码摆在一起看,会得到一个很本质的结论------UDP 每次都是"无状态的一来一回",TCP 则是"有状态的一条长会话" 。UDP 客户端/服务端都不关心"上一次是谁",每次自带目的地;TCP 一旦 connect 成功,这条连接就记住了对端,之后读写全靠 Socket 内部的两条流。理解了"有连接/无连接"这一条,两套代码的所有差异都能自洽地推出来。


七、从单线程到线程池:让服务器扛住并发

上面 TCP 服务器的 start 里,accept() 拿到连接后同步调用 processConnection。这意味着:在处理完一个客户端之前,服务器没空去 accept 下一个客户端。一旦某个客户端长时间占用,后面的客户端就只能干等------单线程无法同时响应多个客户端。

7.1 引入多线程:每个客户端一个线程

java 复制代码
// 启动服务器
public void start() throws IOException {
    System.out.println("服务器启动!");
    while (true) {
        Socket clientSocket = serverSocket.accept();
        Thread t = new Thread(() -> {
            processConnection(clientSocket);
        });
        t.start();  // 给每个客户端分配一个独立线程去处理
    }
}

主线程只负责 accept 接客,每接到一条连接就新起一个线程专门处理它,主线程立刻回去等下一个客户端。这样多个客户端就能被并行服务。

7.2 引入线程池:避免频繁创建/销毁线程

为每个连接都新建线程,在连接量大、连接频繁短促时,创建和销毁线程本身的开销会很可观 。改进办法是引入线程池:复用一组线程,谁空闲谁干活。

java 复制代码
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 启动服务器
public void start() throws IOException {
    System.out.println("服务器启动!");
    ExecutorService service = Executors.newCachedThreadPool();
    while (true) {
        Socket clientSocket = serverSocket.accept();
        // 用线程池来处理连接,避免频繁创建销毁线程
        service.submit(new Runnable() {
            @Override
            public void run() {
                processConnection(clientSocket);
            }
        });
    }
}

我的理解:单线程 → 多线程 → 线程池,是服务端并发演进的三级台阶 ,而它背后是一条朴素工程规律------当"创建成本"高于"复用成本"时,就该池化复用 。线程如此,数据库连接池、对象池、线程池,本质是同一套思想。更进一步(属于本课延伸知识):当并发量真的极大、成千上万连接长驻时,"每连接一线程"的 BIO(同步阻塞 IO) 模型会因为线程数暴涨而撑不住,于是工业界转向 NIO(同步非阻塞 IO)------用少数线程监听大量连接的就绪事件,这正是 Netty、Tomcat NIO 等高性能框架的地基。


八、长连接与短连接

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

  • 短连接 :每次接收到数据并返回响应后,就关闭连接。即短连接只能一次收发数据。
  • 长连接 :不关闭连接,一直保持连接状态,双方不停地收发数据。即长连接可以多次收发数据。

两者的区别如下:

维度 短连接 长连接
建连/关连耗时 每次请求/响应都要建立、关闭连接 只在第一次建立连接,之后直接传输,效率更高
谁主动发请求 一般是客户端主动向服务端发 客户端或服务端都可主动发
使用场景 请求频率不高的场景,如浏览网页 通信频繁的场景,如聊天室、实时游戏

扩展了解:

  • 基于 BIO(同步阻塞 IO) 的长连接,会一直占用系统资源------每个连接都要不停地阻塞等待接收数据,因此每个连接都得占用一个线程。对于并发要求很高的服务端系统,这种消耗是无法承受的。
  • "一次阻塞等待对应一次请求/响应,不停处理"正是长连接的特性:一直不关连接、不停地处理请求。
  • 实际应用时,服务端一般基于 NIO(同步非阻塞 IO) 来实现长连接,性能可以极大提升。

我的理解:长连接与短连接的选择,本质是"建连成本 vs 资源占用 "的权衡。短连接把成本摊到每一次请求(频繁握手挥手),换来了"用完即走、不占资源";长连接一次性付出建连成本,换来后续传输的高效与双向通信能力,代价是空闲连接持续占用资源。HTTP/1.0 默认短连接、HTTP/1.1 默认长连接(Connection: keep-alive),WebSocket 服务于实时长连接------这些都是这条权衡在真实协议里的投影。


结语:把网络编程串成一条线

回头把整篇串起来,网络编程其实就是一条不断"抽象向上、复用向下"的链路:

  • 为什么做:网络提供了远胜本地的丰富资源,而所有资源都靠网络编程来传输。
  • 是什么:网络编程 = 不同进程借网络传数据;核心抽象是 Socket 这个"基本操作单元"。
  • 怎么连:先用发送端/接收端、请求/响应、客户端/服务端这三组概念把"谁给谁发、谁向谁要"说清楚;再落到 C/S 模型的"请求---处理---响应---展示"四步循环。
  • 两种传输性格:TCP 可靠、面向字节流、有连接,适合不能出错的数据;UDP 简单、面向数据报、无连接,适合轻量、高频、能容忍丢包的场景。
  • 怎么写代码 :UDP 用 DatagramSocket + DatagramPacket,每次自带目的地;TCP 用 ServerSocket.accept() 接客、每个连接一个专属 Socket,靠字节流反复收发------而 \n 分隔与 flush 这两个细节,正是字节流"无边界"带来的必修课。
  • 怎么扛并发:单线程 → 多线程 → 线程池 → (延伸)NIO,配合长/短连接的选择,最终决定一台服务器能同时服务多少人。

如果说这篇讲义给我最大的启发,那是一句话:网络编程难的不是 API,而是"边界感"和"成本感"。 "边界感"提醒你:TCP 的字节流没有边界,你得自己用协议划清每条消息;"成本感"提醒你:每一次握手、每一次新建线程、每一条长驻连接,都在悄悄消耗资源。把这两点放进心里,所有看似琐碎的注意事项------端口不能重复、flush 不能忘、长连接吃资源、BIO 撑不住高并发------都会从"要背的规则"变成"理所当然的推论"。这,才是学完 Socket 之后最该带走的东西。


相关推荐
2401_868534781 小时前
逻辑网络设计
网络·python
如夏倾城4 小时前
BGP(Border Gateway Protocol 边界网关协议)
运维·服务器·网络·gateway·信息与通信
CoderYanger6 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第一弹)
java·数据库·spring·面试·java-ee·tomcat·mybatis
小乖写代码7 小时前
帧协议(TCP) · TCP Framing
网络·网络协议·tcp/ip·tcp
如夏倾城1 天前
VRRP(虚拟路由器冗余协议Virtual Router Redundancy Protocol)
网络·python·网络协议·安全·智能路由器·负载均衡·信息与通信
张小姐的猫1 天前
【基于 WebSocket 的多用户网页五子棋】—— 认识第三方库Websocketpp
网络·websocket·网络协议
LightBreeze20021 天前
IS-IS 基本概念详解——报文类型、地址结构与网络拓扑
网络·lsp·路由协议·net·is-is
JianZhen✓1 天前
IM 聊天列表为什么总“消息乱跳“:有序插入、时间轴派生、本地截断、已读回执
开发语言·前端·php
FungLeo1 天前
FengCMS · PHP+MySQL 升级实录· 代码审计怎么闭环:REVIEW到 CLOSURE 四件套,12 个域90 篇修复文档跟到底
开发语言·mysql·php·代码审计·fengcms