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 模型)
最常见的场景里,客户端是给用户用的程序,服务端是提供服务的程序。一次完整交互的标准四步如下:
- 客户端先发送请求到服务端;
- 服务端根据请求数据,执行相应的业务处理;
- 服务端返回响应:发送业务处理结果;
- 客户端根据响应数据,展示处理结果(展示获取到的资源,或提示保存结果)。
我的理解:这"四步循环"几乎是所有应用层协议的骨架。无论是 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 数据报。
一次"只有请求、没有响应"的简单收发,发送端要做的:
- 创建
DatagramSocket; - 构造要发送的内容
DatagramPacket:包含发送的数据(byte[])以及目的 IP、端口号等其他信息; socket.send(packet)发送数据报(不阻塞,直接发出)。
接收端要做的:
- 创建
DatagramSocket; - 构造接收容器
DatagramPacket:里面放一个空的字节数组byte[]用来接收数据; socket.receive(packet)等待接收(阻塞式等待),数据到来后填充进容器,并可从中取出发送端 IP、端口。
但上面只是"单向请求"。一个真正的服务端,核心价值在于对多个客户端请求做出响应。完整的请求/响应流程是:
- 客户端:
send发出请求数据报; - 服务端:
receive阻塞等待 → 收到请求,receive向下执行; - 服务端:根据收到的数据,执行业务处理;
- 服务端:
send发出响应数据报; - 客户端:
receive收到响应,向下执行。
其核心逻辑总结成一句话:根据响应数据决定下一步怎么做(具体做什么,由业务定)。
4.2 TCP 流套接字通信模型
TCP 模型与 UDP 最大的不同是:通信前要建立连接,连接建立后双方基于"流"反复收发。
Server(服务端)侧:
- 创建
ServerSocket,绑定端口; accept()等待接收请求;- 接收到连接后,创建一个已建立连接的
Socket; - 通过这个
Socket拿到InputStream/OutputStream,与客户端收发数据; - 通信结束
socket.close(),关闭 Socket 与相关资源。
Client(客户端)侧:
- 创建
Socket,主动连接服务端、发送请求; - 通过
Socket的OutputStream发送、InputStream接收; - 结束通信,关闭 Socket 与相关资源。
两侧通过"相互通信"协作,最终以一方调用 socket.close() 结束。
4.3 Socket 编程的注意事项
一次完整通信,链路上要标识清楚这几样东西:源 IP、源端口、目的 IP、目的端口、进程、应用层协议。基于此,有以下几条实践要点:
-
客户端与服务端 :开发时经常基于一台主机开两个进程 充当客户端和服务端,但真实场景一般是不同主机。
-
目的 IP 与目的端口号 :它们标识了一次数据传输要送达的终点主机 和终点进程------IP 找到机器,端口找到机器上的那个进程。
-
应用层协议也要设计 :Socket 编程用的是流套接字或数据报套接字(基于 TCP / UDP),但应用层协议同样需要考虑------数据按什么格式编码、怎么划分边界,这些要在后续专门设计。
-
端口被占用的问题(高频报错,务必掌握):
如果一个进程 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();
}
}
逐点拆解三个核心环节:
- 读取请求 :先建一个 4096 字节的接收容器,
receive阻塞等到请求到达,再把字节数组按实际长度getLength()转成字符串。 - 计算响应 :调用
process,回显程序直接原样返回。 - 写回响应 :构造响应数据报时,目的地址直接取自请求包的
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();
}
}
三个最容易踩的坑,这里全部点破:
Scanner与"按分隔符切分" :TCP 是字节流、没有边界,scanner.next()默认按空白(空格/换行)切词。这要求客户端发来的每条请求必须以分隔符(这里用换行)结尾,否则收发对不齐------这正是"粘包/拆包"问题在代码里的具体表现。println而不是print:为的是在响应末尾补一个\n,让客户端能用Scanner按行读出完整一条响应。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 之后最该带走的东西。