默认分类不用-171主机测评-第4页

肾脏微组织原位修复理论：从不可逆生物学实体到可迭代工程模块的本体论转换

2026-06-03master阅读(39)

基于Casz1-Tbx2-Gata3分化通路、气体囊泡声镊操控与超声空化点击化学的形式化理论框架

学科交叉：肾发育生物学 · 声学物理 · 点击化学 · 数学物理 · 组织工程 · 控制论

方法论框架：形式化定义 → 数学推导 → 定理证明 → 文献互证 → 工程映射

摘要

肾脏作为功能整体具有不可替代性，但其作为细胞集合体在理论上可被重构。现行治疗范式——血液透析（功能替代，非结构修复）与肾移植（全器官替换，受供体短缺与免疫排斥制约）——均未能解决这一根本矛盾。本文基于2024-2026年三项关键技术突破——(i) Casz1-Tbx2-Gata3转录因子级联实现>85%肾单位祖细胞分化纯度，(ii) 气体囊泡（Gas Vesicle, GV）声学报告基因增强声镊实现体内微米级细胞空间操控，(iii) 超声空化驱动的生物正交点击化学实现原位水凝胶固化——系统论证了"微组织原位修复"（Microtissue In-Situ Repair, MISR）技术的哲学基础与临床落地逻辑。本文的核心命题是：MISR技术体系的本质在于实现了肾脏从"不可逆的生物学实体"（Irreversible Biological Entity, IBE）向"可迭代的工程学模块"（Iterable Engineering Module, IEM）的本体论转换，从而在逻辑上彻底闭合了经典肾脏病学中"不可逆纤维化→需全器官替换"的核心悖论。本文采用"形式化定义→数学推导→定理证明→文献互证→工程映射"的五维展开模式，为后续物理信息生成引擎（Physics-Informed Generation Engine, PIGE）、验证闭环与多目标优化（Validation Closed-Loop & Multi-Objective Optimization, VCL-MOO）以及工业交付与系统重构（Industrial Delivery & System Reconstruction, IDSR）提供可计算、可审计、可演进的理论基座。

关键词：肾脏微组织原位修复；本体论转换；Casz1-Tbx2-Gata3通路；气体囊泡声镊；超声空化点击化学；物理信息神经网络；形式化理论

1. 形式化定义与公理体系

1.1 基本概念的形式化

定义 1.1（肾脏生物学实体，Kidney Biological Entity, KBE）

设肾脏为一个七元组：

K

=

(

N

,

V

,

I

,

T

,

E

,

M

,

F

)

\\mathcal{K} = (\\mathcal{N}, \\mathcal{V}, \\mathcal{I}, \\mathcal{T}, \\mathcal{E}, \\mathcal{M}, \\mathcal{F})

$K = (N, V, I, T, E, M, F)$

其中：

$\\mathcal{N} = \\{n_1, n_2, \\ldots, n_N\\} N={n1,n2,…,nN} 为肾单位集合（ N ≈ 10 6 N \\approx 10^6 N≈106 在人类肾脏中）$
$\\mathcal{V} = \\{v_1, v_2, \\ldots, v_{N_v}\\} V={v1,v2,…,vNv} 为血管网络集合，每个 v i v_i vi 为一段血管节段$
$\\mathcal{I} = \\{i_1, i_2, \\ldots, i_{N_i}\\} I={i1,i2,…,iNi} 为间质成分集合，包括成纤维细胞、免疫细胞和细胞外基质（ECM）$
$\\mathcal{T} T 为肾小管系统， T : N → R L \\mathcal{T} : \\mathcal{N} \\rightarrow \\mathbb{R}^{L} T:N→RL 将每个肾单位映射到其肾小管节段的功能状态向量$
$\\mathcal{E} E 为内分泌功能映射， E : K × R + → R m \\mathcal{E} : \\mathcal{K} \\times \\mathbb{R}^+ \\rightarrow \\mathbb{R}^m E:K×R+→Rm 描述EPO、肾素、活性维生素D等的分泌$
$\\mathcal{M} M 为代谢功能映射$
$\\mathcal{F} : \\mathcal{K} \\rightarrow \\{\\text{functional}, \\text{failing}, \\text{failed}\\} F:K→{functional,failing,failed} 为全局功能状态函数$

公理 1.1（功能整体性公理）

肾脏作为功能整体不可替代。即：不存在一个外源性装置

D

\\mathcal{D}

$D$ 使得对所有可行的输入血流

b

(

t

)

\\mathbf{b}(t)

$b (t)$ ，有：

∥

F

(

K

,

b

)

−

F

(

D

,

b

)

∥

<

ε

\\|\\mathcal{F}(\\mathcal{K}, \\mathbf{b}) – \\mathcal{F}(\\mathcal{D}, \\mathbf{b})\\| < \\varepsilon

$∥ F (K, b) - F (D, b) ∥ < ε$

对所有功能维度同时成立，其中

ε

\\varepsilon

$ε$ 为临床可接受的误差阈值。

评注 1.1：此公理排除了透析（仅部分替代

N

\\mathcal{N}

$N$ 的滤过功能，无法替代

E

\\mathcal{E}

$E$ 和

T

\\mathcal{T}

$T$ 的复合功能）和机械人工肾（仅滤过+有限重吸收，远未达到

ε

\\varepsilon

$ε$ -接近）。这是临床现实的数学表达。

公理 1.2（细胞可重构性公理）

肾脏作为细胞集合体在理论上可被重构。即：存在一个有限维的构型空间

C

\\mathcal{C}

$C$ 和一个映射

Φ

:

C

→

K

\\Phi : \\mathcal{C} \\rightarrow \\mathcal{K}

$Φ : C \to K$ ，使得：

Φ

(

c

∗

)

=

K

∗

\\Phi(\\mathbf{c}^*) = \\mathcal{K}^*

$Φ (c^{*}) = K^{*}$

其中

K

∗

\\mathcal{K}^*

$K^{*}$ 为功能可接受的肾脏构型。

评注 1.2：此公理奠定了微组织原位修复的逻辑基础——它表明"全器官替换"并非修复的唯一路径。只要能够在构型空间

C

\\mathcal{C}

$C$ 中沿正确轨迹移动，即可实现功能恢复。

定义 1.2（不可逆生物学实体，Irreversible Biological Entity, IBE）

一个生物学实体

B

\\mathcal{B}

$B$ 被称为不可逆的，如果其损伤映射

D

:

B

→

B

′

\\mathcal{D} : \\mathcal{B} \\rightarrow \\mathcal{B}'

$D : B \to B^{'}$ 满足：

∄

R

∈

T

repair

s.t.

∥

F

(

R

(

B

′

)

−

F

(

B

)

∥

<

ε

\\nexists \\; \\mathcal{R} \\in \\mathcal{T}_{\\text{repair}} \\; \\text{s.t.} \\; \\|\\mathcal{F}(\\mathcal{R}(\\mathcal{B}')) – \\mathcal{F}(\\mathcal{B})\\| < \\varepsilon

$∄ R \in T_{repair} s.t. ∥ F (R (B^{'})) - F (B) ∥ < ε$

其中

T

repair

\\mathcal{T}_{\\text{repair}}

$T_{repair}$ 为当前可用修复技术的集合。

定义 1.3（可迭代工程模块，Iterable Engineering Module, IEM）

一个工程模块

E

\\mathcal{E}

$E$ 被称为可迭代的，如果存在一个改进算子序列

{

U

k

}

k

=

1

∞

\\{\\mathcal{U}_k\\}_{k=1}^{\\infty}

${U_{k}}_{k = 1}^{\infty}$ 使得：

lim

⁡

k

→

∞

∥

F

(

U

k

∘

⋯

∘

U

1

(

E

0

)

−

F

target

∥

=

0

\\lim_{k \\to \\infty} \\|\\mathcal{F}(\\mathcal{U}_k \\circ \\cdots \\circ \\mathcal{U}_1(\\mathcal{E}_0)) – \\mathcal{F}_{\\text{target}}\\| = 0

$k \to \infty lim ∥ F (U_{k} \circ \dots \circ U_{1} (E_{0})) - F_{target} ∥ = 0$

且每次迭代

U

k

\\mathcal{U}_k

$U_{k}$ 的计算成本有界：

cost

(

U

k

)

<

C

<

∞

\\text{cost}(\\mathcal{U}_k) < C < \\infty

$cost (U_{k}) < C < \infty$ 。

核心命题 1.1（本体论转换命题）

MISR技术体系实现了以下转换：

IBE

(

K

)

→

Casz1-Tbx2-Gata3

⊕

GV-声镊

⊕

超声点击化学

IEM

(

K

)

\\text{IBE}(\\mathcal{K}) \\xrightarrow{\\text{Casz1-Tbx2-Gata3} \\; \\oplus \\; \\text{GV-声镊} \\; \\oplus \\; \\text{超声点击化学}} \\text{IEM}(\\mathcal{K})

$IBE (K) Casz1-Tbx2-Gata3 \oplus GV- 声镊 \oplus 超声点击化学$

IEM(K)

其中

⊕

\\oplus

$\oplus$ 表示技术协同集成。

1.2 公理体系

公理 1.3（分化可控性公理）

存在一个转录因子组合

T

=

(

T

1

,

T

2

,

…

,

T

m

)

\\mathbf{T} = (T_1, T_2, \\ldots, T_m)

$T = (T_{1}, T_{2}, \dots, T_{m})$ 和一个诱导协议

P

\\mathcal{P}

$P$ ，使得任意多能干细胞或谱系限定祖细胞

s

\\mathbf{s}

$s$ 可以被诱导为肾单位谱系目标细胞

t

\\mathbf{t}

$t$ 的概率满足：

P

(

type

(

P

(

s

)

=

t

)

≥

η

P(\\text{type}(\\mathcal{P}(\\mathbf{s})) = \\mathbf{t}) \\geq \\eta

$P (type (P (s)) = t) \geq η$

其中

η

>

0.85

\\eta > 0.85

$η > 0.85$ （对应>85%分化纯度）。

文献支撑：参见 §4.1。

公理 1.4（空间可控性公理）

存在一个声场构型空间

A

\\mathcal{A}

$A$ 和一个操控映射

Ψ

:

A

×

R

3

×

R

+

→

R

3

\\Psi : \\mathcal{A} \\times \\mathbb{R}^3 \\times \\mathbb{R}^+ \\rightarrow \\mathbb{R}^3

$Ψ : A \times R^{3} \times R^{+} \to R^{3}$ ，使得给定目标空间分布

ρ

target

(

x

)

\\rho_{\\text{target}}(\\mathbf{x})

$ρ_{target} (x)$ 和初始细胞分布

ρ

0

(

x

)

\\rho_0(\\mathbf{x})

$ρ_{0} (x)$ ，存在声场参数

a

∈

A

\\mathbf{a} \\in \\mathcal{A}

$a \in A$ 和一个有限时间

T

<

∞

T < \\infty

$T < \infty$ 使得：

∥

Ψ

(

a

,

⋅

,

T

)

(

ρ

0

)

−

ρ

target

∥

L

1

<

δ

\\|\\Psi(\\mathbf{a}, \\cdot, T)(\\rho_0) – \\rho_{\\text{target}}\\|_{L^1} < \\delta

$∥Ψ (a, \cdot, T) (ρ_{0}) - ρ_{target} ∥_{L^{1}} < δ$

其中

δ

\\delta

$δ$ 为空间精度容差（目标：

δ

<

10

μ

m

\\delta < 10 \\; \\mu\\text{m}

$δ < 10 μ m$ ）。

文献支撑：参见 §4.2。

公理 1.5（原位固化可控性公理）

存在一个生物相容的水凝胶前体溶液

H

\\mathcal{H}

$H$ 和一个超声触发协议

U

\\mathcal{U}

$U$ ，使得在目标空间区域

Ω

⊂

R

3

\\Omega \\subset \\mathbb{R}^3

$Ω \subset R^{3}$ 内：

U

(

H

,

Ω

)

=

H

gel

∣

Ω

\\mathcal{U}(\\mathcal{H}, \\Omega) = \\mathcal{H}_{\\text{gel}}|_{\\Omega}

$U (H, Ω) = H_{gel} ∣_{Ω}$

即仅目标区域发生凝胶化，边界精度

∥

∂

Ω

actual

−

∂

Ω

target

∥

<

ϵ

gel

\\|\\partial\\Omega_{\\text{actual}} – \\partial\\Omega_{\\text{target}}\\| < \\epsilon_{\\text{gel}}

$∥ \partial Ω_{actual} - \partial Ω_{target} ∥ < ϵ_{gel}$ 。

文献支撑：参见 §4.3。

1.3 肾病悖论的形式化

悖论 1.1（不可逆纤维化-全器官替换悖论，Irreversible Fibrosis Paradox, IFP）

定义纤维化程度函数

ϕ

:

K

×

R

+

→

[

0

,

1

]

\\phi : \\mathcal{K} \\times \\mathbb{R}^+ \\rightarrow [0,1]

$ϕ : K \times R^{+} \to [0, 1]$ ，满足：

单调性：

\\phi(t_2) \\geq \\phi(t_1) ϕ(t2​)≥ϕ(t1​) 对所有 t 2 > t 1 t_2 > t_1 t2​>t1​ 成立（纤维化在现有治疗下不可逆）

临界性：存在阈值

\\phi_c \\in (0,1) ϕc​∈(0,1) 使得 F ( K ) = failed \\mathcal{F}(\\mathcal{K}) = \\text{failed} F(K)=failed 当 ϕ > ϕ c \\phi > \\phi_c ϕ>ϕc​

替换困境：当前

\\mathcal{T}_{\\text{repair}} = \\{\\text{transplant}, \\text{dialysis}\\} Trepair​={transplant,dialysis}，均不满足 ε \\varepsilon ε-功能等价

IFP 的核心逻辑链：

[

CKD进展

]

⇒

[

ϕ

(

t

)

↗

]

⇒

[

F

(

K

)

↘

]

⇒

[

ESRD

]

⇒

[

全器官替换

]

[\\text{CKD进展}] \\Rightarrow [\\phi(t) \\nearrow] \\Rightarrow [\\mathcal{F}(\\mathcal{K}) \\searrow] \\Rightarrow [\\text{ESRD}] \\Rightarrow [\\text{全器官替换}]

$[CKD 进展] \Rightarrow [ϕ (t) ↗] \Rightarrow [F (K) ↘] \Rightarrow [ESRD] \Rightarrow [全器官替换]$

IFP的闭合条件：MISR技术体系引入微组织修复算子

R

micro

\\mathcal{R}_{\\text{micro}}

$R_{micro}$ ，使得：

ϕ

(

R

micro

(

K

)

<

ϕ

c

\\phi(\\mathcal{R}_{\\text{micro}}(\\mathcal{K})) < \\phi_c

$ϕ (R_{micro} (K)) < ϕ_{c}$

打破单调性链条，使逻辑链重构为：

[

CKD进展

]

⇒

[

ϕ

(

t

)

↗

]

⇒

[

R

micro

干预

]

⇒

[

ϕ

↘

]

⇒

[

F

(

K

)

↗

]

[\\text{CKD进展}] \\Rightarrow [\\phi(t) \\nearrow] \\Rightarrow [\\mathcal{R}_{\\text{micro}} \\text{干预}] \\Rightarrow [\\phi \\searrow] \\Rightarrow [\\mathcal{F}(\\mathcal{K}) \\nearrow]

$[CKD 进展] \Rightarrow [ϕ (t) ↗] \Rightarrow [R_{micro} 干预] \Rightarrow [ϕ ↘] \Rightarrow [F (K) ↗]$

2. 数学建模：微组织修复的偏微分方程框架

2.1 细胞分化动力学的反应-扩散-对流方程

考虑修复微环境中的细胞状态演化。设

u

(

x

,

t

)

=

(

u

1

,

u

2

,

…

,

u

K

)

T

u(\\mathbf{x}, t) = (u_1, u_2, \\ldots, u_K)^T

$u (x, t) = (u_{1}, u_{2}, \dots, u_{K})^{T}$ 为

x

∈

Ω

⊂

R

3

\\mathbf{x} \\in \\Omega \\subset \\mathbb{R}^3

$x \in Ω \subset R^{3}$ 处在时刻

t

$t$ 的

K

$K$ 种细胞类型的密度向量。

定义 2.1（微组织修复的细胞动力学方程）

∂

u

∂

t

=

D

∇

2

u

⏟

扩散

−

∇

⋅

(

v

u

)

⏟

对流（声镊驱动）

+

R

(

u

;

T

,

p

)

⏟

反应（分化/增殖/凋亡）

+

S

(

x

,

t

)

⏟

源项（外源细胞注入）

\\frac{\\partial u}{\\partial t} = \\underbrace{D\\nabla^2 u}_{\\text{扩散}} – \\underbrace{\\nabla \\cdot (\\mathbf{v}u)}_{\\text{对流（声镊驱动）}} + \\underbrace{\\mathbf{R}(u; \\mathbf{T}, \\mathbf{p})}_{\\text{反应（分化/增殖/凋亡）}} + \\underbrace{\\mathbf{S}(\\mathbf{x}, t)}_{\\text{源项（外源细胞注入）}}

$\frac{\partial u}{\partial t} = 扩散$

D∇2u−对流（声镊驱动）

∇⋅(vu)+反应（分化/增殖/凋亡）

R(u;T,p)+源项（外源细胞注入）

S(x,t)

其中：

$\\text{diag}(D_1, \\ldots, D_K) D=diag(D1,…,DK) 为扩散系数矩阵$
$\\mathbf{v}(\\mathbf{x}, t) v(x,t) 为声场诱导的对流速度场（由声镊产生，参见 §2.2）$
$\\mathbf{R}(u; \\mathbf{T}, \\mathbf{p}) = (R_1, \\ldots, R_K)^T R(u;T,p)=(R1,…,RK)T 为反应项，依赖于转录因子组合 T \\mathbf{T} T 和微环境参数 p = ( p O 2 , p pH , p Wnt , p FGF , … ) \\mathbf{p} = (p_{\\text{O}_2}, p_{\\text{pH}}, p_{\\text{Wnt}}, p_{\\text{FGF}}, \\ldots) p=(pO2,ppH,pWnt,pFGF,…)$
$\\mathbf{S}(\\mathbf{x}, t) S(x,t) 为外源性细胞注入的时空分布$

反应项的具体形式（基于Casz1-Tbx2-Gata3通路）：

定义肾单位祖细胞向特定谱系的分化反应为：

R

NPC

→

Pod

=

k

1

⋅

f

Casz1

(

c

1

)

⋅

u

NPC

⋅

(

1

−

u

total

/

K

carry

)

R

NPC

→

PT

=

k

2

⋅

f

Tbx2

(

c

2

)

⋅

u

NPC

⋅

(

1

−

u

total

/

K

carry

)

R

NPC

→

DT

=

k

3

⋅

f

Gata3

(

c

3

)

⋅

u

NPC

⋅

(

1

−

u

total

/

K

carry

)

\\begin{aligned} R_{\\text{NPC}\\to\\text{Pod}} &= k_1 \\cdot f_{\\text{Casz1}}(c_1) \\cdot u_{\\text{NPC}} \\cdot (1 – u_{\\text{total}}/K_{\\text{carry}}) \\\\ R_{\\text{NPC}\\to\\text{PT}} &= k_2 \\cdot f_{\\text{Tbx2}}(c_2) \\cdot u_{\\text{NPC}} \\cdot (1 – u_{\\text{total}}/K_{\\text{carry}}) \\\\ R_{\\text{NPC}\\to\\text{DT}} &= k_3 \\cdot f_{\\text{Gata3}}(c_3) \\cdot u_{\\text{NPC}} \\cdot (1 – u_{\\text{total}}/K_{\\text{carry}}) \\end{aligned}

$R_{NPC \to Pod} R_{NPC \to PT} R_{NPC \to DT} = k_{1} \cdot f_{Casz1} (c_{1}) \cdot u_{NPC} \cdot (1 - u_{total} / K_{carry}) = k_{2} \cdot f_{Tbx2} (c_{2}) \cdot u_{NPC} \cdot (1 - u_{total} / K_{carry}) = k_{3} \cdot f_{Gata3} (c_{3}) \cdot u_{NPC} \cdot (1 - u_{total} / K_{carry})$

其中：

$f_{\\text{Casz1}}(c_1) = c_1^{n_1} / (K_{m1}^{n_1} + c_1^{n_1}) fCasz1(c1)=c1n1/(Km1n1+c1n1) 为Hill型激活函数$
$c_1, c_2, c_3 c1,c2,c3 分别为Casz1、Tbx2、Gata3的有效浓度$
NPC = Nephron Progenitor Cell（肾单位祖细胞）
Pod = Podocyte（足细胞），PT = Proximal Tubule（近端小管），DT = Distal Tubule（远端小管）

定理 2.1（分化纯度的Lyapunov稳定性）

定义分化纯度泛函：

P

[

u

]

=

∫

Ω

1

target

(

u

(

x

,

t

)

d

x

∫

Ω

u

total

(

x

,

t

)

d

x

P[u] = \\frac{\\int_{\\Omega} \\mathbb{1}_{\\text{target}}(u(\\mathbf{x}, t)) \\, d\\mathbf{x}}{\\int_{\\Omega} u_{\\text{total}}(\\mathbf{x}, t) \\, d\\mathbf{x}}

$P [u] = \frac{\int _{Ω} 1 _{target} ( u ( x , t )) d x}{\int _{Ω} u _{total} ( x , t ) d x}$

其中

1

target

\\mathbb{1}_{\\text{target}}

$1_{target}$ 为目标细胞类型的示性函数。在反应项满足合作性条件（所有

k

i

>

0

k_i > 0

$k_{i} > 0$ ）且无外源干扰的情况下，存在一个Lyapunov泛函：

V

[

u

]

=

∫

Ω

∑

i

=

1

K

u

i

(

x

)

ln

⁡

u

i

(

x

)

u

i

∗

(

x

)

d

x

V[u] = \\int_{\\Omega} \\sum_{i=1}^{K} u_i(\\mathbf{x}) \\ln \\frac{u_i(\\mathbf{x})}{u_i^*(\\mathbf{x})} \\, d\\mathbf{x}

$V [u] = \int_{Ω} i = 1 \sum K u_{i} (x) ln \frac{u _{i} ( x )}{u _{i}^{*} ( x )} d x$

使得

d

V

d

t

≤

0

\\frac{dV}{dt} \\leq 0

$\frac{d V}{d t} \leq 0$ ，且

d

V

d

t

=

0

\\frac{dV}{dt} = 0

$\frac{d V}{d t} = 0$ 当且仅当

u

=

u

∗

u = u^*

$u = u^{*}$ ，其中

u

∗

u^*

$u^{*}$ 为目标分化稳态。

证明概要：

V

$V$ 为相对熵（Kullback-Leibler散度），其单调递减性源于反应项的合作结构。在Casz1-Tbx2-Gata3通路完整激活的条件下，目标表型为系统的唯一全局吸引子。完整的谱系追踪实验验证参见文献[1,2]。

2.2 声镊操控的声辐射力场方程

定义 2.2（声辐射力场）

对于不可压缩牛顿流体中的球形细胞（半径

a

$a$ ），Gor’kov势给出时间平均声辐射力：

F

rad

=

−

∇

U

\\mathbf{F}_{\\text{rad}} = -\\nabla U

$F_{rad} = - \nabla U$

其中Gor’kov势为：

U

=

4

π

a

3

[

f

1

⟨

p

2

⟩

2

ρ

0

c

0

2

−

f

2

3

ρ

0

⟨

v

2

⟩

4

]

U = \\frac{4\\pi a^3}{3} \\left[ f_1 \\frac{\\langle p^2 \\rangle}{2\\rho_0 c_0^2} – f_2 \\frac{3\\rho_0 \\langle \\mathbf{v}^2 \\rangle}{4} \\right]

$U = \frac{4 π a ^{3}}{3} [f_{1} \frac{⟨ p ^{2} ⟩}{2 ρ _{0} c _{0}^{2}} - f_{2} \frac{3 ρ _{0} ⟨ v ^{2} ⟩}{4}]$

f

1

=

1

−

ρ

0

c

0

2

ρ

p

c

p

2

,

f

2

=

2

(

ρ

p

−

ρ

0

)

2

ρ

p

+

ρ

0

f_1 = 1 – \\frac{\\rho_0 c_0^2}{\\rho_p c_p^2}, \\quad f_2 = \\frac{2(\\rho_p – \\rho_0)}{2\\rho_p + \\rho_0}

$f_{1} = 1 - \frac{ρ _{0} c _{0}^{2}}{ρ _{p} c _{p}^{2}}, f_{2} = \frac{2 ( ρ _{p} - ρ _{0} )}{2 ρ _{p} + ρ _{0}}$

其中

p

$p$ 为声压场，

v

\\mathbf{v}

$v$ 为声质点速度，

ρ

0

,

c

0

\\rho_0, c_0

$ρ_{0}, c_{0}$ 为流体密度和声速，

ρ

p

,

c

p

\\rho_p, c_p

$ρ_{p}, c_{p}$ 为细胞（颗粒）密度和声速，

⟨

⋅

⟩

\\langle \\cdot \\rangle

$⟨ \cdot ⟩$ 表示时间平均。

气体囊泡增强效应：

表达气体囊泡的细胞具有显著降低的有效密度

ρ

p

GV

\\rho_p^{\\text{GV}}

$ρ_{p}^{GV}$ 和有效声速

c

p

GV

c_p^{\\text{GV}}

$c_{p}^{GV}$ ，使得：

ρ

p

GV

ρ

p

≪

1

,

c

p

GV

c

p

≪

1

\\frac{\\rho_p^{\\text{GV}}}{\\rho_p} \\ll 1, \\quad \\frac{c_p^{\\text{GV}}}{c_p} \\ll 1

$<span class=\"vlist-t vlist-t$

微服务组件源码2——Spring Ribbon原理（基于RibbonLoadBalancerClient）

2026-06-03master阅读(22)

1、基本原理（LoadBalancerClient + 拦截器）

Ribbon 负载组件的内部就是集成了 LoadBalancerClient 负载均衡客户端，所以 Ribbon 负载均衡的原理本质也跟上面介绍的 LoadBalancerClient 原理一致，负载均衡器 Ribbon 默认会通过 Eureka Client 向 Eureka 服务端的服务注册列表中获取服务的信息，并缓存一份在本地 JVM 中，根据缓存的服务注册列表信息，可以通过 LoadBalancerClient 来选择不同的服务实例，从而实现负载均衡。主要做如下的增强处理：

基本用法就是注入一个 RestTemplate，并使用@LoadBalance注解标注 RestTemplate，从而使RestTemplate具备负载均衡的能力。当 Spring 容器启动时，使用@LoadBalanced 注解修饰的 RestTemplate 会被添加拦截器 LoadBalancerInterceptor，拦截器会拦截 RestTemplate 发送的请求，转而执行LoadBalancerInterceptor 中的 intercept() 方法，并在 intercept()方法中使用LoadBalancerClient 处理请求，从而达到负载均衡的目的。

那么 RestTemplate 添加 @LoadBalanced 注解后，为什么会被拦截呢？这是因为 LoadBalancerAutoConfiguration 类维护了一个被 @LoadBalanced 修饰的 RestTemplate 列表，在初始化过程中，通过调用 customizer.customize(restTemplate) 方法为 RestTemplate 添加了 LoadBalancerInterceptor 拦截器，该拦截器中的方法将远程服务调用的方法交给了 LoadBalancerClient 去处理，从而达到了负载均衡的目的。

Ribbon会提供一个serviceId对应的服务实例，此外就不会做其他事了，基于此服务实例进行远程调用、返回结果处理等都是由RestTemplate去处理的

2、自动配置概述

2.1、RibbonAutoConfiguration

* 收集@RibbonClients注解信息封装为RibbonClientSpecification（功能和@LoadBalancerClients注解类似）

会收集注册@RibbonClients、RibbonClient注解，name和指定的配置类（包括默认）为RibbonClientSpecification(String name, Class<?>[] configuration)类

@Configuration
@RibbonClient(name = "orderService",configuration = HelloRibbonConfiguration.class)

@RibbonClients(defaultConfiguration = MyRibbonConfiguration.class)
public class RibbonConfiguration {}

* 创建SpringClientFactory extends NamedContextFactory<RibbonClientSpecification>命名上下文

①会基于容器中List<RibbonClientSpecification> configurations（上一步注册的配置集合），为每一个指定的name 创建一个上下文，父上下文为顶层Spring容器

每个上下文里包含可独自指定的RibbonClientSpecification配置和默认配置类RibbonClientConfiguration，如IClientConfig客户端配置、IRule策略的配置、超时配置等

②其中在RibbonClientConfiguration里的IClientConfig客户端配置的默认配置为DefaultClientConfigImpl，它还会加载文件配置的信息

从Spring env中加载“ribbon.配置项”这类全局默认配置、和加载“client名.ribbon.配置项”这类针对某个Client的配置信息

* 创建RibbonLoadBalancerClient(springClientFactory()) 用户使用的顶级LoadBalancerClient 接口对象

①List<RibbonClientSpecification>收集全局配置和单个服务的配置信息

②SpringClientFactory会为每一个服务创建独立的上下文

③new RibbonLoadBalancerClient(springClientFactory())

@Configuration
@Conditional(org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration.RibbonClassesConditions.class)
//其内RibbonClientConfigurationRegistrar会收集注册@RibbonClients、RibbonClient注解内的那么，name和指定的配置类（包括默认）为RibbonClientSpecification
@RibbonClients
@AutoConfigureAfter(name = "org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration")
//把@LoadBalanced 注解修饰的 RestTemplate 会被添加拦截器LoadBalancerInterceptor(loadBalancerClient, requestFactory)
@AutoConfigureBefore({ LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class })
@EnableConfigurationProperties({ RibbonEagerLoadProperties.class, ServerIntrospectorProperties.class })
public class RibbonAutoConfiguration {

    @Autowired(required = false)
    private List<RibbonClientSpecification> configurations = new ArrayList<>();
    @Autowired
    private RibbonEagerLoadProperties ribbonEagerLoadProperties;
    @Bean
    public HasFeatures ribbonFeature() {
        return HasFeatures.namedFeature("Ribbon", Ribbon.class);
    }
    //客户端配置容器工厂：会为每一个ClientName和指定的配置类(包含了默认配置类RibbonClientConfiguration)创建一个独立的上下文
    @Bean
    public SpringClientFactory springClientFactory() {
        SpringClientFactory factory = new SpringClientFactory();
        factory.setConfigurations(this.configurations);
        return factory;
    }
    //使用客户端配置容器工厂创建顶层对象，RibbonLoadBalancerClient，实现了LoadBalancerClient接口
    @Bean
    @ConditionalOnMissingBean(LoadBalancerClient.class)
    public LoadBalancerClient loadBalancerClient() {
        return new RibbonLoadBalancerClient(springClientFactory());
    }

//略

}

//SpringClientFactory

public class SpringClientFactory extends NamedContextFactory<RibbonClientSpecification> {

static final String NAMESPACE = "ribbon";

    public SpringClientFactory() {
        super(RibbonClientConfiguration.class, NAMESPACE, "ribbon.client.name");
    }

    public ILoadBalancer getLoadBalancer(String name) {
        return getInstance(name, ILoadBalancer.class);
    }

    //通过NamedContextFactory获取指定容器内的某个type实例，获取不到时，会通过IClientConfig进行创建，
    //调用容器的autowireBean进属性注入，但是最终实例不会放入容器中
    @Override
    public <C> C getInstance(String name, Class<C> type) {
        C instance = super.getInstance(name, type);
        if (instance != null) {
            return instance;
        }
        IClientConfig config = getInstance(name, IClientConfig.class);
        return instantiateWithConfig(getContext(name), type, config);
    }

    //略
}

2.2、RibbonClientConfiguration默认配置(serviceId维度)

* 是默认的Ribbon客户端配置类，在创建SpringClientFactory是指定的默认配置类

* 每个独立的服务ID上下文中都会注入此类配置的信息

– 指定了robbin会用到的所有组件的bean

– 同时还import指定了具体的httpClient的自动配置

@Import({ HttpClientConfiguration.class, OkHttpRibbonConfiguration.class,
RestClientRibbonConfiguration.class, HttpClientRibbonConfiguration.class })

2.2.1、Name容器中6大可配置组件

Spring Ribbon的6大可配置组件类及默认配置

自动化配置接口	描述	默认实现	说明
IClientConfig	Ribbon的客户端配置	com.netflix.client.config.DefaultClientConfigImpl	对如下组件及其他信息的配置项
IRule	Ribbon的负载均衡策略	com.netflix.loadbalancer.ZoneAvoidanceRule	该策略能在多区域环境下选出最佳区域的实例进行访问
IPing	Ribbon的实例检查策略	com.netflix.loadbalancer.NoOpPing	该检查策略是一个特殊的实现，实际上它并不会检查实例是否可用，而是始终返回true，默认所有的实例都是可用的
ServerList<Server>	服务实例清单维护机制	com.netflix.loadbalancer.ConfigurationBasedServerList
ServerListFilter<Server>	服务实例清单过滤机制	org.springframework.cloud.netflix.ribbon.ZonePreferenceServerListFilter	该策略能够优先过滤出与请求调用方处于同一个区域的服务清单
ILoadBalancer	（负载均衡器主类）	com.netflix.loadbalancer.ZoneAwareLoadBalancer	该策略具备服务感知能力，封装了如上几个组件

与Eureka、Ncaos集成

* 当在Spring Cloud中同时引入Spring Cloud Eureka 和 Spring Cloud Ribbon 时，会触发Eureka对于Ribbon的自动化配置，那么Ribbon的相关默认实现类就会有所变化。

自动化配置接口	描述	默认实现	说明
IPing	Ribbon的实例检查策略	com.netflix.niws.loadbalancer.NIWSDiscoveryPing	该实现将实例检查的任务交给服务治理框架来进行维护
ServerList<Server>	服务实例清单维护机制	com.netflix.niws.loadbalancer.DiscoveryEnabledNIWSServerList	该实现会将服务清单列表交给Eureka来维护

在与Spring Cloud Eureka结合使用时，我们的配置会更简单，例如上一步中提到的客户端配置EUREKA-CLIENT.ribbon.listOfServers，就不需要再这么麻烦的进行配置，

因为Eureka的自动配置类会为我们维护所有实例的清单。

我们也可以通过参数配置来禁用Eureka对Ribbon服务实例的维护实现：ribbon.eureka.enabled=false

* 同样的，当在Spring Cloud中同时引入Spring Cloud Nacos和 Spring Cloud Ribbon 时，且禁用了Eureka，此时也会只有Nacos自定义的实现类覆盖关默认实现类

例如我们希望使用Nacos的IRule实现，那么在配置类中加上

@Bean
  public IRule ribbonRule() {
      return new NacosRule();
  }

// Spring Cloud Ribbon中对RibbonClient的默认配置类

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
//具体通信工具配置HttpClient
@Import({ HttpClientConfiguration.class, OkHttpRibbonConfiguration.class,
RestClientRibbonConfiguration.class, HttpClientRibbonConfiguration.class })
public class RibbonClientConfiguration {

    public static final int DEFAULT_CONNECT_TIMEOUT = 1000;
    public static final int DEFAULT_READ_TIMEOUT = 1000;
    public static final boolean DEFAULT_GZIP_PAYLOAD = true;

    @RibbonClientName
    private String name = "client";

    @Autowired
    private PropertiesFactory propertiesFactory;

    @Bean
    @ConditionalOnMissingBean
    public IClientConfig ribbonClientConfig() {
        DefaultClientConfigImpl config = new DefaultClientConfigImpl();
        config.loadProperties(this.name);
        config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT);
        config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT);
        config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD);
        return config;
    }

    @Bean
    @ConditionalOnMissingBean
    public IRule ribbonRule(IClientConfig config) {
        if (this.propertiesFactory.isSet(IRule.class, name)) {
            return this.propertiesFactory.get(IRule.class, config, name);
        }
        ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
        rule.initWithNiwsConfig(config);
        return rule;
    }

    //各个组件的默认实现
    @Bean
    @ConditionalOnMissingBean
    public IPing ribbonPing(IClientConfig config) {
        if (this.propertiesFactory.isSet(IPing.class, name)) {
            return this.propertiesFactory.get(IPing.class, config, name);
        }
        return new DummyPing();
    }

    @Bean
    @ConditionalOnMissingBean
    @SuppressWarnings("unchecked")
    public ServerList<Server> ribbonServerList(IClientConfig config) {
        if (this.propertiesFactory.isSet(ServerList.class, name)) {
            return this.propertiesFactory.get(ServerList.class, config, name);
        }
        ConfigurationBasedServerList serverList = new ConfigurationBasedServerList();
        serverList.initWithNiwsConfig(config);
        return serverList;
    }

@Bean
@ConditionalOnMissingBean
public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
      ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
      IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
   if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
      return this.propertiesFactory.get(ILoadBalancer.class, config, name);
   }
   return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
         serverListFilter, serverListUpdater);
}

//略

}

2.2.2、OkHttpRibbonConfiguration （例）

配置具体的通信工具，例如当项目存在OkHttpClient类且存在配置属性ribbon.okhttp.enabled，会加载这个配置类

* OkHttpLoadBalancingClient和RetryableOkHttpLoadBalancingClient实现类bean

是实现负载均衡功能中顶级接口com.netflix.client.IClient

* OkHttpClientConfiguration

是存粹的OkHttpClient的配置，包括配置连接池、生成OkHttpClient对象

注意这里OkHttpClient的生成，会从IClientConfig config配置中获取Ribbon相关的配置（超时配置），设置在OkHttpClient中

注：基于RestTemplate使用ribbon的方法内，是没有用到此配置的bean。是直接借助RestTemplate的通信功能进行访问。Ribbon值提供serverInstan的选择

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty("ribbon.okhttp.enabled")
@ConditionalOnClass(name = "okhttp3.OkHttpClient")
public class OkHttpRibbonConfiguration {

@RibbonClientName
private String name = "client";

   @Bean
   @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
   @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
   public RetryableOkHttpLoadBalancingClient retryableOkHttpLoadBalancingClient(
         IClientConfig config, ServerIntrospector serverIntrospector,
         ILoadBalancer loadBalancer, RetryHandler retryHandler,
         LoadBalancedRetryFactory loadBalancedRetryFactory, OkHttpClient delegate,
         RibbonLoadBalancerContext ribbonLoadBalancerContext) {
      RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient(
            delegate, config, serverIntrospector, loadBalancedRetryFactory);
      client.setLoadBalancer(loadBalancer);
      client.setRetryHandler(retryHandler);
      client.setRibbonLoadBalancerContext(ribbonLoadBalancerContext);
      Monitors.registerObject("Client_" + this.name, client);
      return client;
   }

   @Bean
   @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
   @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
   public OkHttpLoadBalancingClient okHttpLoadBalancingClient(IClientConfig config,
         ServerIntrospector serverIntrospector, ILoadBalancer loadBalancer,
         RetryHandler retryHandler, OkHttpClient delegate) {
      OkHttpLoadBalancingClient client = new OkHttpLoadBalancingClient(delegate, config,
            serverIntrospector);
      client.setLoadBalancer(loadBalancer);
      client.setRetryHandler(retryHandler);
      Monitors.registerObject("Client_" + this.name, client);
      return client;
   }

@Configuration(proxyBeanMethods = false)
protected static class OkHttpClientConfiguration {

private OkHttpClient httpClient;

      @Bean
      @ConditionalOnMissingBean(ConnectionPool.class)
      public ConnectionPool httpClientConnectionPool(IClientConfig config,
            OkHttpClientConnectionPoolFactory connectionPoolFactory) {
         RibbonProperties ribbon = RibbonProperties.from(config);
         int maxTotalConnections = ribbon.maxTotalConnections();
         long timeToLive = ribbon.poolKeepAliveTime();
         TimeUnit ttlUnit = ribbon.getPoolKeepAliveTimeUnits();
         return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
      }

      @Bean
      @ConditionalOnMissingBean(OkHttpClient.class)
      public OkHttpClient client(OkHttpClientFactory httpClientFactory,
            ConnectionPool connectionPool, IClientConfig config) {
         RibbonProperties ribbon = RibbonProperties.from(config);
         this.httpClient = httpClientFactory.createBuilder(false)
               .connectTimeout(ribbon.connectTimeout(), TimeUnit.MILLISECONDS)
               .readTimeout(ribbon.readTimeout(), TimeUnit.MILLISECONDS)
               .followRedirects(ribbon.isFollowRedirects())
               .connectionPool(connectionPool).build();
         return this.httpClient;
      }

      @PreDestroy
      public void destroy() {
         if (httpClient != null) {
            httpClient.dispatcher().executorService().shutdown();
            httpClient.connectionPool().evictAll();
         }
      }

}

2.3、LoadBalancerAutoConfiguration

* 把标注了@LoadBalanced注解的所有RestTemplate实例，添加一个LoadBalancerInterceptor(loadBalancerClient, requestFactory)

– loadBalancerClient是在RibbonAutoConfiguration中指定的RibbonLoadBalancerClient(springClientFactory()) 类型bean

– requestFactory是本配置类中指定的LoadBalancerRequestFactory类型bean

– @LoadBalanced注解就是@Qualifier类注解，用于匹配bean的标志

@Qualifier
public @interface LoadBalanced {}

* 执行RestTemplates时，会被这个拦截器拦截，

①LoadBalancerRequestFactory会根据传递进来的ClientHttpRequestExecution创建具体通信工具封装后的LoadBalancerRequest

②RestTemplates可以设置ClientHttpRequestFactory，默认为SimpleClientHttpRequestFactory来创建ClientHttpRequest

③LoadBalancerClient负载均衡器会根据serviceName选择合适的路径，进行请求

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {

    @LoadBalanced
    @Autowired(required = false)
    private List<RestTemplate> restTemplates = Collections.emptyList();

@Autowired(required = false)
private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();

    //把标注的了@LoadBalanced所有RestTemplate，添加一个LoadBalancerInterceptor(loadBalancerClient, requestFactory)
    @Bean
    public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
            final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
        return () -> restTemplateCustomizers.ifAvailable(customizers -> {
            for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
                for (RestTemplateCustomizer customizer : customizers) {
                    customizer.customize(restTemplate);
                }
            }
        });
    }

    @Bean
    @ConditionalOnMissingBean
    public LoadBalancerRequestFactory loadBalancerRequestFactory(
            LoadBalancerClient loadBalancerClient) {
        return new LoadBalancerRequestFactory(loadBalancerClient, this.transformers);
    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
    static class LoadBalancerInterceptorConfig {

        @Bean
        public LoadBalancerInterceptor ribbonInterceptor(
                LoadBalancerClient loadBalancerClient,
                LoadBalancerRequestFactory requestFactory) {
            return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
        }

        @Bean
        @ConditionalOnMissingBean
        public RestTemplateCustomizer restTemplateCustomizer(
                final LoadBalancerInterceptor loadBalancerInterceptor) {
            return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
        }

}

//略

}

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {

    private LoadBalancerClient loadBalancer;
    private LoadBalancerRequestFactory requestFactory;
    public LoadBalancerInterceptor(LoadBalancerClient loadBalancer,
                                   LoadBalancerRequestFactory requestFactory) {
        this.loadBalancer = loadBalancer;
        this.requestFactory = requestFactory;
    }

    public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
        // for backwards compatibility
        this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
    }

    //执行RestTemplates时，会被这个拦截器拦截，
    //LoadBalancerRequestFactory会根据传递进来的ClientHttpRequestExecution创建具体通信工具封装后的LoadBalancerRequest
    //   RestTemplates可以设置ClientHttpRequestFactory，默认为SimpleClientHttpRequestFactory来创建ClientHttpRequest
    //LoadBalancerClient负载均衡器会根据serviceName选择合适的路径，进行请求
    //
    @Override
    public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
                                        final ClientHttpRequestExecution execution) throws IOException {
        final URI originalUri = request.getURI();
        String serviceName = originalUri.getHost();
        return this.loadBalancer.execute(serviceName,
                this.requestFactory.createRequest(request, body, execution));
    }

3、Name容器中6大可配置组件

3.1、概述

Spring Ribbon的6大可配置组件类及默认配置

自动化配置接口	描述	默认实现	说明
IClientConfig	Ribbon的客户端配置	com.netflix.client.config.DefaultClientConfigImpl	对如下组件及其他信息的配置项
IRule	Ribbon的负载均衡策略	com.netflix.loadbalancer.ZoneAvoidanceRule	该策略能在多区域环境下选出最佳区域的实例进行访问
IPing	Ribbon的实例检查策略	com.netflix.loadbalancer.NoOpPing	该检查策略是一个特殊的实现，实际上它并不会检查实例是否可用，而是始终返回true，默认所有的实例都是可用的
ServerList<Server>	服务实例清单维护机制	com.netflix.loadbalancer.ConfigurationBasedServerList
ServerListFilter<Server>	服务实例清单过滤机制	org.springframework.cloud.netflix.ribbon.ZonePreferenceServerListFilter	该策略能够优先过滤出与请求调用方处于同一个区域的服务清单
ILoadBalancer	（负载均衡器主类）	com.netflix.loadbalancer.ZoneAwareLoadBalancer	该策略具备服务感知能力，封装了如上几个组件

3.2、IClientConfig配置项组件

3.2.1、IClientConfig接口

* ClientName和NameSpace的获取

这是为了隔离不同的服务调用端的配置

* 其他接口就是属性的增删改查

public interface IClientConfig {

   public String getClientName();
   public String getNameSpace();

public void loadProperties(String clientName);
public void loadDefaultValues();

   public Map<String, Object> getProperties();
   public boolean containsProperty(IClientConfigKey key);

   public String resolveDeploymentContextbasedVipAddresses();
   public int getPropertyAsInteger(IClientConfigKey key, int defaultValue);
   public String getPropertyAsString(IClientConfigKey key, String defaultValue);
   public boolean getPropertyAsBoolean(IClientConfigKey key, boolean defaultValue);
   public <T> T get(IClientConfigKey<T> key);
   public <T> T get(IClientConfigKey<T> key, T defaultValue);
   public <T> IClientConfig set(IClientConfigKey<T> key, T value);

}

3.2.2、DefaultClientConfigImpl实现类

* 作用是保存了所有的配置项，基于Archaius实现，支持动态的获取配置项的最新值

* 默认实现是DefaultClientConfigImpl，此类作用：

①保存各个组件的默认实现类，比如

public static final String DEFAULT_NFLOADBALANCER_RULE_CLASSNAME = "com.netflix.loadbalancer.AvailabilityFilteringRule";

public static final String DEFAULT_NFLOADBALANCER_CLASSNAME = "com.netflix.loadbalancer.ZoneAwareLoadBalancer";

注：此默认配置在DefaultClientConfigImpl和RibbonClientConfiguration （配置bean加入到独立的服务上下文中）均有指定

②保存各种属性的默认配置，支持动态比如

public static final int DEFAULT_READ_TIMEOUT = 5000;

public static final int DEFAULT_CONNECTION_MANAGER_TIMEOUT = 2000;

public static final int DEFAULT_CONNECT_TIMEOUT = 2000;

* loadProperties会加载环境对象中如下属性，保存到本地缓存Map<String, Object> properties，或者支持动态刷新的Map<String, DynamicStringProperty> dynamicProperties

①从Spring env中加载“ribbon.配置项”这类，作为默认配置

使用 ribbon.<key>=<value> 的形式配置，例如全局配置连接超时时间：

ribbon:

ConnectTimeout: 250

②和加载“client名.ribbon.配置项”这类针对某个Client的配置信息

指定客户端配置方式采用 <client>.ribbon.<key>=<value>，使用样例如下所示，同时，如果同时配置了全局配置和指定客户端配置，那么以指定客户端的配置为准。

EUREKA-CLIENT:

ribbon:

listOfServers: localhost:8001,localhost:8002

* 基本原理（更多原理见Archaius文档）

– 基于Archaius作为数据源根据，对于Springboot项目来说，由ArchaiusAutoConfiguration进行自动配置，这个数据源一般为ConfigurableEnvironmentConfiguration

此AbstractConfiguration实现类，以Spring容器的环境Environmen对象作为数据源进行获取，而不会对其进行反向设置

也会组合其他的数据源，一并配置到ConfigurationManager.install(config);

– 同时也注入了一个监听器ApplicationListener<EnvironmentChangeEvent>

当监听到环境配置修改时，会获取ConfigurableEnvironmentConfiguration中设置好的自动的动态刷新监听器，执行

listener.configurationChanged(new ConfigurationEvent(source, type,key, value, beforeUpdate));

这样Map<String, Object> properties，或者支持动态刷新的Map<String, DynamicStringProperty> dynamicProperties里对应的值就会被刷新

– config.loadProperties(clientname)方法会从ConfigurableEnvironmentConfiguration中在抽取出指定格式key的键值对作为新的AbstractConfiguration实现类

即SubsetConfiguration以实现数据源的隔离，例如SubsetConfiguration对抽象方法的实现，parent就是原始ConfigurableEnvironmentConfiguration配置

getParentKey(key)会拼接clientname前缀

public void addPropertyDirect(String key, Object value) {

parent.addProperty(getParentKey(key), value);

}

@Bean
@ConditionalOnMissingBean
public IClientConfig ribbonClientConfig() {
   DefaultClientConfigImpl config = new DefaultClientConfigImpl();
   config.loadProperties(this.name);
   config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT);
   config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT);
   config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD);
   return config;
}

public class DefaultClientConfigImpl implements IClientConfig {

    public static final Boolean DEFAULT_PRIORITIZE_VIP_ADDRESS_BASED_SERVERS = Boolean.TRUE;
    public static final String DEFAULT_NFLOADBALANCER_PING_CLASSNAME = "com.netflix.loadbalancer.DummyPing"; // DummyPing.class.getName();
    public static final String DEFAULT_NFLOADBALANCER_RULE_CLASSNAME = "com.netflix.loadbalancer.AvailabilityFilteringRule";
    public static final String DEFAULT_NFLOADBALANCER_CLASSNAME = "com.netflix.loadbalancer.ZoneAwareLoadBalancer";
    public static final boolean DEFAULT_USEIPADDRESS_FOR_SERVER = Boolean.FALSE;
    public static final String DEFAULT_CLIENT_CLASSNAME = "com.netflix.niws.client.http.RestClient";
    public static final String DEFAULT_VIPADDRESS_RESOLVER_CLASSNAME = "com.netflix.client.SimpleVipAddressResolver";
    public static final int DEFAULT_MAX_TOTAL_TIME_TO_PRIME_CONNECTIONS = 30000;
    //略

    public void loadProperties(String restClientName) {
        //启用动态属性如果开启属性将具有动态性这里也是唯一一处将该值设置成true的地方
        //所以如果仅仅是默认值不支持动态属性的
        enableDynamicProperties = true;
        //设置clientName
        setClientName(restClientName);
        //加载默认属性
        //依赖Archaius获取对应key的配置值。但是但是有一点需要特别注意。这里的 ConfigurationManager.getConfigInstance().getString()方法获取的配置和
        //例如我们配置的值是a,b,c 那么getStringValue获取的值是a,b,c 而 getString()获取的却是 a！所以默认值字符串类型的配置里面出现逗号那就有问题了。
        //
        loadDefaultValues();
        //这里可以看到底层的配置还是通过 Archaius来配置的所以我们把配置写在classpath的config.properties中是生效的
        //对于subset这个方法举个例子可能会更清楚例如我们在config文件中的配置是 coredy.ribbon.ReadTimeout
        //我们调用subset(”coredy“) 那就会给我们返回所有以coredy开头的Configuration
        Configuration props = ConfigurationManager.getConfigInstance().subset(restClientName);
        //遍历得到的Configuration 将属性放到全局的配置里面properties
        for (Iterator<String> keys = props.getKeys(); keys.hasNext(); ) {
            String key = keys.next();
            String prop = key;
            try {

//指定了NameSpace的情况，默认你为ribbon，需要截断这个前缀
                if (prop.startsWith(getNameSpace())) {
                    prop = prop.substring(getNameSpace().length() + 1);
                }
                //特别注意这里是使用getStringValue(props, key)来获取值得
                //意为着你配置的属性是a,b,c 那么最终在全局配置properties里面的值也是a,b,c
                setPropertyInternal(prop, getStringValue(props, key));
            } catch (Exception ex) {
                throw new RuntimeException(String.format("Property %s is invalid", prop));
            }
        }

        //略
}

3.3、ServerList<Server>获取指定serviceId服务列表组件

3.3.1、ServerList<T extends Server>接口

* 定义获取指定serviceId服务列表的方法

public interface ServerList<T extends Server> {

//初始可用的服务列表
    public List<T> getInitialListOfServers();
    //经过ping进行心跳正常过滤后的最新可用的服务列表
    public List<T> getUpdatedListOfServers();

}

* 一个Server对象表示一个服务实例的信息

public class Server {

    public static final String UNKNOWN_ZONE = "UNKNOWN";
    private String host;
    private int port = 80;
    private String scheme;
    private volatile String id;//通常为 http域名+端口
    private volatile boolean isAliveFlag;
    private String zone = UNKNOWN_ZONE;
    private volatile boolean readyToServe = true;

    private MetaInfo simpleMetaInfo = new MetaInfo() {
        /**
         * 服务实例对应服务器的名称和服务组
         */

@Override
        public String getAppName() {
            return null;
        }
        @Override
        public String getServerGroup() {
            return null;
        }
        /**
         * 服务实例的别名
         */
        @Override
        public String getServiceIdForDiscovery() {
            return null;
        }

        @Override
        public String getInstanceId() {
            return id;
        }
    };

    public Server(String host, int port) {
        this(null, host, port);
    }

    public Server(String scheme, String host, int port) {
        this.scheme = scheme;
        this.host = host;
        this.port = port;
        this.id = host + ":" + port;
        isAliveFlag = false;
    }

//..

}

3.3.2、NacosServerList

@Bean
@ConditionalOnMissingBean
@SuppressWarnings("unchecked")
public ServerListFilter<Server> ribbonServerListFilter(IClientConfig config) {
   if (this.propertiesFactory.isSet(ServerListFilter.class, name)) {
      return this.propertiesFactory.get(ServerListFilter.class, config, name);
   }
   ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
   filter.initWithNiwsConfig(config);
   return filter;
}

* 继承AbstractServerList，这里值初始化了过滤器实现类

– 优先取NIWSServerListFilterClassName配置的，

– 如果为null，取NIWSServerListFilterClassName类

– 在RibbonClientConfiguration自动配置类中，默认配置为ZonePreferenceServerListFilter

* NacosServerList实现类

– 逻辑简单，直接借助Nacos提供的客户端NacosDiscoveryProperties 获取服务列表

List<Instance> instances = discoveryProperties.namingServiceInstance().selectInstances(serviceId, true);

– 再适配为ribbon需要的Server类型即可

– 一个iClientConfig.getClientName()，即一个ServiceId对应一个NacosServerList

public class NacosServerList extends AbstractServerList<NacosServer> {

private NacosDiscoveryProperties discoveryProperties;

private String serviceId;

   public NacosServerList(NacosDiscoveryProperties discoveryProperties) {
      this.discoveryProperties = discoveryProperties;
   }

   @Override
   public List<NacosServer> getInitialListOfServers() {
      return getServers();
   }

   @Override
   public List<NacosServer> getUpdatedListOfServers() {
      return getServers();
   }

   private List<NacosServer> getServers() {
      try {
         List<Instance> instances = discoveryProperties.namingServiceInstance()
               .selectInstances(serviceId, true);
         return instancesToServerList(instances);
      }
      catch (Exception e) {
         throw new IllegalStateException(
               "Can not get service instances from nacos, serviceId=" + serviceId,
               e);
      }
   }

   private List<NacosServer> instancesToServerList(List<Instance> instances) {
      List<NacosServer> result = new ArrayList<>();
      if (null == instances) {
         return result;
      }
      for (Instance instance : instances) {
         result.add(new NacosServer(instance));
      }

return result;
}

   public String getServiceId() {
      return serviceId;
   }

   @Override
   public void initWithNiwsConfig(IClientConfig iClientConfig) {
      this.serviceId = iClientConfig.getClientName();
   }
}

3.4、ServerListFilter<T extends Server>服务列表过滤组件

3.4.1、ServerListFilter接口

public interface ServerListFilter<T extends Server> {

public List<T> getFilteredListOfServers(List<T> servers);

}

3.4.2、ZoneAffinityServerListFilter实现类

* getFilteredListOfServers的实现逻辑，分两步过滤

– 初步过滤：

对指定serverId下的所有实例列表默认使用ZoneAffinityPredicate使用过滤：过滤配置指定zone的服务实例

一般的服务发现客户端会配置好这个zone值

– 对初步过滤的结果再次判断

①配置zoneAffinity（默认flase）和zoneExclusive（默认flase）均没有true时，不过滤zone，选择所有实例列表

②当zoneExclusive为true，使用初步过滤的（指定zone过滤）

③当zoneAffinity为true，表示需要再次过滤判断：基于LoadBalancerStats判断这些初步过滤的服务实例的状态是否符合配置的阈值

符合就使用过滤的，否则不过滤

((double) circuitBreakerTrippedCount) / instanceCount >= blackOutServerPercentageThreshold.get()

|| loadPerServer >= activeReqeustsPerServerThreshold.get()

|| (instanceCount – circuitBreakerTrippedCount) < availableServersThreshold.get())

public class ZoneAffinityServerListFilter<T extends Server> extends
AbstractServerListFilter<T> implements IClientConfigAware {

    private volatile boolean zoneAffinity = DefaultClientConfigImpl.DEFAULT_ENABLE_ZONE_AFFINITY;
    private volatile boolean zoneExclusive = DefaultClientConfigImpl.DEFAULT_ENABLE_ZONE_EXCLUSIVITY;
    private DynamicDoubleProperty activeReqeustsPerServerThreshold;
    private DynamicDoubleProperty blackOutServerPercentageThreshold;
    private DynamicIntProperty availableServersThreshold;
    private Counter overrideCounter;
    private ZoneAffinityPredicate zoneAffinityPredicate = new ZoneAffinityPredicate();

    private static Logger logger = LoggerFactory.getLogger(ZoneAffinityServerListFilter.class);

    String zone;

    public ZoneAffinityServerListFilter() {
    }

    public ZoneAffinityServerListFilter(IClientConfig niwsClientConfig) {
        initWithNiwsConfig(niwsClientConfig);
    }

    //从配置组件中获取属性
    @Override
    public void initWithNiwsConfig(IClientConfig niwsClientConfig) {
        String sZoneAffinity = "" + niwsClientConfig.getProperty(CommonClientConfigKey.EnableZoneAffinity, false);
        if (sZoneAffinity != null){
            zoneAffinity = Boolean.parseBoolean(sZoneAffinity);
        }
        String sZoneExclusive = "" + niwsClientConfig.getProperty(CommonClientConfigKey.EnableZoneExclusivity, false);
        if (sZoneExclusive != null){
            zoneExclusive = Boolean.parseBoolean(sZoneExclusive);
        }
        if (ConfigurationManager.getDeploymentContext() != null) {
            zone = ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone);
        }
        activeReqeustsPerServerThreshold = DynamicPropertyFactory.getInstance().getDoubleProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.maxLoadPerServer", 0.6d);
        blackOutServerPercentageThreshold = DynamicPropertyFactory.getInstance().getDoubleProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.maxBlackOutServesrPercentage", 0.8d);
        availableServersThreshold = DynamicPropertyFactory.getInstance().getIntProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.minAvailableServers", 2);
        overrideCounter = Monitors.newCounter("ZoneAffinity_OverrideCounter");
        Monitors.registerObject("NIWSServerListFilter_" + niwsClientConfig.getClientName());
    }

    @Override
    public List<T> getFilteredListOfServers(List<T> servers) {
        if (zone != null && (zoneAffinity || zoneExclusive) && servers !=null && servers.size() > 0){
            //初步过滤：使用指定zone过滤的
            List<T> filteredServers = Lists.newArrayList(Iterables.filter(
                    servers, this.zoneAffinityPredicate.getServerOnlyPredicate()));
            //再次过滤判断，符合才使用初步过滤的，否则放行所有
            if (shouldEnableZoneAffinity(filteredServers)) {
                return filteredServers;
            } else if (zoneAffinity) {
                overrideCounter.increment();
            }
        }
        return servers;
    }

    //zoneAffinity和zoneExclusive均没有true时，过滤
    //当zoneExclusive为true，使用初步过滤的（指定zone过滤）
    //当zoneAffinity为true，表示需要再次过滤：基于LoadBalancerStats判断这些初步过滤的服务实例的状态是否符合配置的阈值
    //                       符合就使用过滤的，否则不过滤
    private boolean shouldEnableZoneAffinity(List<T> filtered) {
        if (!zoneAffinity && !zoneExclusive) {
            return false;
        }
        if (zoneExclusive) {
            return true;
        }
        LoadBalancerStats stats = getLoadBalancerStats();
        if (stats == null) {
            return zoneAffinity;
        } else {
            ZoneSnapshot snapshot = stats.getZoneSnapshot(filtered);
            double loadPerServer = snapshot.getLoadPerServer();
            int instanceCount = snapshot.getInstanceCount();
            int circuitBreakerTrippedCount = snapshot.getCircuitTrippedCount();
            if (((double) circuitBreakerTrippedCount) / instanceCount >= blackOutServerPercentageThreshold.get()
                    || loadPerServer >= activeReqeustsPerServerThreshold.get()
                    || (instanceCount – circuitBreakerTrippedCount) < availableServersThreshold.get()) {
                return false;
            } else {
                return true;
            }

        }
    }

}

3.4.3、ZonePreferenceServerListFilter实现类

@Bean
@ConditionalOnMissingBean
@SuppressWarnings("unchecked")
public ServerListFilter<Server> ribbonServerListFilter(IClientConfig config) {
   if (this.propertiesFactory.isSet(ServerListFilter.class, name)) {
      return this.propertiesFactory.get(ServerListFilter.class, config, name);
   }
   ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
   filter.initWithNiwsConfig(config);
   return filter;
}

* 在RibbonClientConfiguration自动配置中，默认实现为ZonePreferenceServerListFilter

* ZonePreferenceServerListFilter继承ZoneAffinityServerListFilter

当ZoneAffinityServerListFilter过滤失败（即调用父类过滤后，的实例数不变）)时，使用指定zone（如有）进行过滤

public class ZonePreferenceServerListFilter extends ZoneAffinityServerListFilter<Server> {

private String zone;

   @Override
   public void initWithNiwsConfig(IClientConfig niwsClientConfig) {
      super.initWithNiwsConfig(niwsClientConfig);
      if (ConfigurationManager.getDeploymentContext() != null) {
         this.zone = ConfigurationManager.getDeploymentContext()
               .getValue(ContextKey.zone);
      }
   }

   @Override
   public List<Server> getFilteredListOfServers(List<Server> servers) {
      List<Server> output = super.getFilteredListOfServers(servers);
      if (this.zone != null && output.size() == servers.size()) {
         List<Server> local = new ArrayList<>();
         for (Server server : output) {
            if (this.zone.equalsIgnoreCase(server.getZone())) {
               local.add(server);
            }
         }
         if (!local.isEmpty()) {
            return local;
         }
      }
      return output;
   }

}

3.5、IPing连通性检测组件

//各个组件的默认实现
    @Bean
    @ConditionalOnMissingBean
    public IPing ribbonPing(IClientConfig config) {
        if (this.propertiesFactory.isSet(IPing.class, name)) {
            return this.propertiesFactory.get(IPing.class, config, name);
        }
        return new DummyPing();
    }

* 默认的逻辑始终为true,即不会进行ping处理

这时为了性能考虑，不需要主动的去ping每一个实例的连通性，因为在ZoneAwareLoadBalancer中会进行过滤，

如果实例有问题，那么必定存在socket相关的异常，那么就会触发此实例的断路，

public interface IPing {
public boolean isAlive(Server server);
}

public class DummyPing extends AbstractLoadBalancerPing {

public DummyPing() {
}

    public boolean isAlive(Server server) {
        return true;
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

3.6、IRule选取规则组件

3.6.1、IRule接口

由接口方法即可知道：核心方法为choose选择一个serverId下的一个服务实例，而且逻辑或基于ILoadBalancer实现类

public interface IRule{

    public Server choose(Object key);
    public void setLoadBalancer(ILoadBalancer lb);
    public ILoadBalancer getLoadBalancer();
}

3.6.2、ZoneAvoidanceRule实现类

3.6.2.1、主要流程

    @Bean
    @ConditionalOnMissingBean
    public IRule ribbonRule(IClientConfig config) {
        if (this.propertiesFactory.isSet(IRule.class, name)) {
            return this.propertiesFactory.get(IRule.class, config, name);
        }
        ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
        rule.initWithNiwsConfig(config);
        return rule;
    }

* 是RibbonAutoConfiguration指定的默认规则

* 其核心逻辑是：当前serviceId下的每一个服务实例经过其内配置的compositePredicate进行过滤后的候选服务实例集合，再进行轮询即可

注：每一服务实例都需要走一遍下面的流程，比如ZoneAvoidanceRule.getAvailableZones方法会调用多此（其实没必要）

– ZoneAvoidancePredicate校验

①基于LoadBalancerStats获取当前服务实例对应的zoneSnapshot

使用ZoneAvoidanceRule.getAvailableZones计算出可用有效的分区availableZones，再进行下一步AvailabilityPredicate的校验

getAvailableZones具体算法见下

②如果此服务实例对应的zone或者zoneSnapshot 不存在，那么会直接放行，进行下一步AvailabilityPredicate的校验

– AvailabilityPredicate校验

①所有实例不处于断路状态

②所有实例的活跃请求数小于niws.loadbalancer.availabilityFilteringRule.activeConnectionsLimit配置，默认为int最大值

– 两个Predicate校验都满足后，最为候选加入List<Server> eligible

如果最终候选为0，那么再遍历一次，符合AvailabilityPredicate这个校验即可

如果二次校验AvailabilityPredicate还是失败，那么默认全部实例放行

– 对最终结果List<Server> eligible进行轮询

public abstract class PredicateBasedRule extends ClientConfigEnabledRoundRobinRule {

public abstract AbstractServerPredicate getPredicate();

    @Override
    public Server choose(Object key) {
        ILoadBalancer lb = getLoadBalancer();
        //getPredicate()就是子类ZoneAvoidanceRule 的CompositePredicate compositePredicate
        Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
        if (server.isPresent()) {
            return server.get();
        } else {
            return null<span style=\"background-color:#ff

前端已死？BOSS直聘2024-2026真实数据曝光：AI时代前端工程师还能活多久？

2026-06-03master阅读(30)

📢 引言：每一次AI模型发布，都在"宣判"前端死亡？

🚨 预警：过去两年，前端圈的"死亡预警"从未停止。

从 OpenAI Codex、Claude Code 的横空出世，到 AI Agent 的爆发式增长，再到自动测试工具的日趋成熟，每一次AI技术的跃迁，都伴随着一波"行业消亡论"：

📅 AI冲击时间线

⏰ 时间节点🤖 AI事件💀 “死亡言论”

🔴 2024年初	GPT-4 Turbo发布，支持多模态代码生成	“前端切图、写组件的工作，AI 10分钟能顶人一天”#前端已死# 话题冲上技术热搜
🟠 2024年底	Claude Code 3.0上线，支持复杂前端项目完整开发	“初级前端毫无存在价值”
🟡 2025年中	AI Agent生态爆发，多智能体协作全流程	“后端已死”"测试已死"声音接踵而至
🟢 2026年初	Kimi 2.5 开源模型发布，Figma一键转React+TS	前端圈再次陷入"AI会不会彻底取代我们"的焦虑

😰 开发者的焦虑

💭 “深耕多年的技术，真的要被AI淘汰了吗？前端行业，真的走到尽头了吗？”

这些言论越传越凶，让不少前端开发者陷入自我怀疑…

🎯 本文目标

谣言止于数据 📊 —— 用 BOSS直聘2024-2026年真实招聘数据拆解AI浪潮下前端的真实生存现状，并明确：作为前端工程师，该如何提升核心竞争力，在AI时代站稳脚跟。

📊 第一部分：真相 —— BOSS直聘2024-2026数据，击碎"前端已死"谎言

判断一个行业是否"已死"，最核心的两个指标的是：

📈 招聘需求💰 薪资水平

市场是否持续需要人才

价值是否被认可

我们整理了BOSS直聘近三年（2024-2026）全国前端工程师的招聘数据：

📌 数据来源：BOSS直聘官方公开统计、职友集BOSS直聘岗位抽样数据，截至2026年4月

1️⃣ 招聘需求：总量稳增，结构优化

📋 招聘数据总览

📅 年份🏢 全国月均招聘岗位数👶 初级前端(1-2年)岗位占比🧑‍💼 中高级前端(3年+)岗位占比🤖 AI相关前端岗位占比(AI交互/大模型集成)

2024年	8.2万	48%	52%	15%
2025年	8.7万 ↑	35% ↓	65% ↑	38% ↑
2026年(截至4月)	9.2万 ↑↑	22% ↓↓	78% ↑↑	56% ↑↑

🎯 关键结论

✅ 招聘总量逐年递增 —— 2026年月均岗位较2024年增长 +12.2%，需求并未萎缩，反而持续扩大

⚠️ 初级岗位大幅下降 —— 从48%降至22%，AI淘汰"搬砖型"初级开发者

🚀 中高级岗位翻倍增长 —— 2026年超过一半岗位要求AI集成能力，行业向"高阶化、智能化"转型

📈 补充数据：2026年BOSS直聘显示前端职位达 9,247个，占全国招聘总量的 0.12%，较2025年增长 +61.5%

2️⃣ 薪资水平：整体上涨，高阶薪资差距拉大

💵 薪资数据总览

📅 年份💵 全国平均月薪👶 初级前端(1-2年)平均月薪🧑‍💼 中高级前端(3年+)平均月薪🤖 AI相关前端岗位平均月薪

2024年	18.6K	12.3K	25.8K	28.5K
2025年	20.1K ↑	12.8K _+4%	28.9K _+12%	35.2K _+23.5%
2026年(截至4月)	21.7K ↑_{较2024年+16.7%}	13.2K _+7.3%	32.5K _+25.9%	41.8K _+46.7%

📊 2026年最新薪资细节

📈 薪酬区间

覆盖范围：4.5K – 50K
72.4% 岗位月薪在 10K-50K
年薪可达 12-60W，高于多数互联网基础岗位

👔 经验薪资

1-3年：40.0K
3-5年：44.0K
5-10年：50.0K
经验越丰富，涨幅越明显

🏢 大厂薪资

阿里、字节、腾讯等 30% 前端岗位要求大模型开发能力
这类岗位平均月薪达 45K+
部分资深工程师年薪突破 70万

🎉 数据总结

✨ 前端不仅没死，反而在AI浪潮中实现了"优胜劣汰"

❌ 淘汰的是：只会做重复性工作的初级开发者 ✅ 崛起的是：具备核心能力的中高级前端、AI相关前端，薪资和需求都在大幅上涨！

🔍 第二部分：深度解析 —— 为什么"前端已死""后端已死"的声音层出不穷？

其实，“前端已死”“后端已死"的言论，本质不是AI真的能取代这些岗位，而是大家混淆了"AI能做什么"和"人类开发者能做什么”。

核心原因有 4点，每一点都戳中行业痛点：

❌ 误区 1️⃣：AI的"表面强大"，让大家低估了前端的核心价值

🤖 AI能做什么？

✅ 快速生成基础代码
✅ “一个带分页的表格组件”
✅ Figma设计稿转React代码

⚠️ 但这些都只是"前端工作的冰山一角"！

💡 实际案例：Claude Code生成的表格组件

// 🤖 Claude Code 生成的基础分页表格组件（仅实现基础功能）
import React, { useState } from 'react';

function PaginationTable({ data }) {
const [currentPage, setCurrentPage] = useState(1);
const pageSize = 10;
const totalPages = Math.ceil(data.length / pageSize);
const currentData = data.slice((currentPage – 1) * pageSize, currentPage * pageSize);

return (
<div>
<table border="1">
<thead><tr><th>ID</th><th>Name</th></tr></thead>
<tbody>
{currentData.map(item => (
<tr key={item.id}>
<td>{item.id}</td>
<td>{item.name}</td>
</tr>
))}
</tbody>
</table>
<button disabled={currentPage === 1} onClick={() => setCurrentPage(currentPage – 1)}>上一页</button>
<span>{currentPage}/{totalPages}</span>
<button disabled={currentPage === totalPages} onClick={() => setCurrentPage(currentPage + 1)}>下一页</button>
</div>
);
}

⚠️ 实际项目中的问题清单

❌ AI遗漏的问题🎯 前端工程师的价值

📱 移动端适配	响应式布局、触摸交互优化
🛡️ 异常处理	数据为空、接口报错、网络中断
⚡ 性能优化	大数据量卡顿、虚拟列表、懒加载
🎨 样式规范	符合项目设计系统、主题切换
🔐 权限控制	角色权限、数据权限、操作权限

🧠 关键洞察：2026年热门的 OpenAI Codex 与 Claude Code 协同工作模式，本质是"多智能体协作"，AI只是"工具节点"，而非"替代者"。

❌ 误区 2️⃣：行业转型期的"焦虑转移"，放大了"淘汰恐慌"

🔄 行业转型：从"野蛮生长" → “精细化发展”

📅 过去🆕 现在

会HTML/CSS/JS就能找到好工作	AI能搞定基础工作，门槛提高
初级岗位多	初级岗位减少，高阶岗位增加
重复性工作多	创造性、架构性工作为主

😰 焦虑传播链

被淘汰的开发者 ──→ 归咎于AI ──→ 传播"前端已死"言论
↓
求职的初级开发者 ──→ 看到AI生成代码 ──→ 陷入焦虑 ──→ 放大恐慌

💡 同理：“后端已死”“测试已死"的言论，本质也是如此 —— 淘汰的是"重复性工作者”，而非"核心价值创造者"。

❌ 误区 3️⃣：对"前端岗位"的认知偏差，误以为前端只是"写代码"

🎯 现代前端 ≠ “页面仔”

现代前端是：

🛡️ 用户体验的守护者
⚙️ 业务逻辑的实现者
🔗 跨端交互的连接器

📋 前端核心工作矩阵

🎨 领域🔧 具体工作🤖 AI能否替代

UX设计	交互逻辑、视觉适配、动效设计	❌ 需人类判断
业务逻辑	后端接口联调、数据处理、状态管理	❌ 需业务理解
性能优化	首屏加载、卡顿优化、内存管理	❌ 需场景判断
跨端适配	PC、移动端、小程序、桌面端	❌ 需多端经验
工程化	构建、打包、CI/CD、监控	❌ 需架构能力

🏢 行业观点：企业级前端开发的核心难点，从来都不是页面样式的还原，而是复杂业务逻辑的实现、多系统的数据流转、企业级的权限体系设计。

❌ 误区 4️⃣：媒体的"流量密码"，刻意渲染焦虑

📰 “前端已死”“AI取代程序员” = 流量密码

高话题度 → 引发关注和讨论
放大AI能力，弱化人类价值
编造虚假数据

📌 2026年Kimi 2.5发布后的真实数据

📰 媒体标题📊 实际情况

“前端人要失业了”	只是解放了重复性工作
“AI取代前端”	推动前端岗位向高阶化转型
“招聘需求暴跌”	需求反而增长 +61.5%

🚀 第三部分：核心 —— AI浪潮中，前端工程师如何自救？

🎯 核心理念

AI不是"敌人"，而是"工具"

前端工程师的自救，不是"抵制AI"，而是"学会用AI，提升自己的核心竞争力"

那些 AI无法替代的能力，才是我们的"铁饭碗"！

结合BOSS直聘2026年最新招聘要求、行业趋势，总结出 6个核心提升方向，每一点都附详细说明和代码示例。

🛠️ 方向 1️⃣：技术深耕 —— 从"会用"到"精通"

🎯 目标：掌握AI无法替代的底层能力

AI能生成基础代码，但无法精通底层原理、无法解决复杂的技术难题。

📚 重点提升领域

⚙️ 前端底层 JS引擎、DOM原理、事件循环

⚡ 性能优化首屏加载、大数据渲染、内存泄漏

📱 跨端开发 React Native、Flutter、小程序

🏗️ 工程化构建工具、CI/CD、微前端

🤖 大模型集成 GPT、Claude、Kimi API集成

🔧 架构设计状态管理、组件设计、模块化

💻 示例1：性能优化 —— 虚拟列表实现

🎯 场景：大数据量表格渲染优化 ⚠️ AI局限：能生成基础代码，但无法结合实际场景调整优化策略

// ⚡ 虚拟列表实现：前端性能优化的核心场景
import React, { useState, useRef, useEffect, useCallback } from 'react';

interface VirtualListProps {
data: Array<{ id: string; name: string }>;
itemHeight?: number;
}

export const VirtualList: React.FC<VirtualListProps> = ({
data,
itemHeight = 50
}) => {
const listRef = useRef<HTMLDivElement>(null);
const [scrollTop, setScrollTop] = useState(0);

// 📏 可视区域配置
const VIEW_HEIGHT = 500;
const MAX_VISIBLE_COUNT = Math.ceil(VIEW_HEIGHT / itemHeight);
const TOTAL_HEIGHT = data.length * itemHeight;

// 🎯 计算可视区域数据（核心优化逻辑）
const visibleData = React.useMemo(() => {
const startIndex = Math.floor(scrollTop / itemHeight);
const endIndex = Math.min(
startIndex + MAX_VISIBLE_COUNT + 2, // +2 缓冲避免滚动空白
data.length
);
return data.slice(Math.max(0, startIndex), endIndex);
}, [scrollTop, data, itemHeight, MAX_VISIBLE_COUNT]);

// 📍 偏移量计算
const offsetY = scrollTop – (scrollTop % itemHeight);

// 🖱️ 滚动事件处理（节流优化）
const handleScroll = useCallback((e: React.UIEvent<HTMLDivElement>) => {
setScrollTop(e.currentTarget.scrollTop);
}, []);

return (
<div
ref={listRef}
style={{
height: VIEW_HEIGHT,
overflow: 'auto',
border: '1px solid #e0e0e0',
borderRadius: '8px'
}}
onScroll={handleScroll}
>
{/* 📐 占位容器，维持滚动条高度 */}
<div style={{ height: TOTAL_HEIGHT, position: 'relative' }}>
{/* 🎨 可视区域内容 */}
<div style={{
position: 'absolute',
top: offsetY,
width: '100%'
}}>
{visibleData.map((item, index) => (
<div
key={item.id}
style={{
height: itemHeight,
lineHeight: `${itemHeight}px`,
borderBottom: '1px solid #f0f0f0',
paddingLeft: '16px',
backgroundColor: index % 2 === 0 ? '#fafafa' : '#fff',
display: 'flex',
alignItems: 'center'
}}
>
<span style={{
display: 'inline-block',
width: '60px',
color: '#666',
fontSize: '12px'
}}>
#{item.id}
</span>
<span style={{ fontWeight: 500 }}>{item.name}</span>
</div>
))}
</div>
</div>
</div>
);
};

💡 说明：虚拟列表是前端性能优化的核心场景，AI能生成基础代码，但无法根据实际数据量、业务场景（数据动态更新、筛选）调整优化策略。

💻 示例2：大模型集成 —— AI对话功能

🎯 场景：前端集成OpenAI API 🔥 2026年热门需求：BOSS直聘中 56% 前端岗位要求AI集成能力

// 🤖 前端集成OpenAI API：带权限校验、异常处理、用户体验优化
import React, { useState, useRef, useEffect } from 'react';
import axios, { AxiosError } from 'axios';

// 🔐 权限校验模块（AI无法结合项目权限体系设计）
const checkAIPermission = (): boolean => {
const token = localStorage.getItem('token');
if (!token) return false;

try {
const userInfo = JSON.parse(localStorage.getItem('userInfo') || '{}');
return userInfo?.permissions?.includes('ai:use') ?? false;
} catch {
return false;
}
};

// 💬 消息类型定义
interface ChatMessage {
role: 'user' | 'assistant';
content: string;
timestamp?: number;
}

export const AIChat: React.FC = () => {
const [inputValue, setInputValue] = useState('');
const [chatList, setChatList] = useState<ChatMessage[]>([]);
const [loading, setLoading] = useState(false);
const [error, setError] = useState('');
const chatEndRef = useRef<HTMLDivElement>(null);

// ⬇️ 自动滚动到底部
useEffect(() => {
chatEndRef.current?.scrollIntoView({ behavior: 'smooth' });
}, [chatList, loading]);

// 📤 发送消息
const sendMessage = async () => {
if (!inputValue.trim()) {
setError('💬 请输入提问内容');
return;
}

// 🔒 权限校验
if (!checkAIPermission()) {
setError('🚫 您没有使用AI对话的权限，请联系管理员');
return;
}

setLoading(true);
setError('');

const userMessage: ChatMessage = {
role: 'user',
content: inputValue,
timestamp: Date.now()
};

setChatList(prev => […prev, userMessage]);
setInputValue('');

try {
// 🌐 API调用（带超时控制）
const response = await axios.post(
'https://api.openai.com/v1/chat/completions',
{
model: 'gpt-4-turbo',
messages: […chatList, userMessage],
temperature: 0.7,
max_tokens: 2000
},
{
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${localStorage.getItem('openaiToken')}`
},
timeout: 15000 // ⏱️ 15秒超时
}
);

const assistantMessage: ChatMessage = {
role: 'assistant',
content: response.data.choices[0].message.content,
timestamp: Date.now()
};

setChatList(prev => […prev, assistantMessage]);
} catch (err) {
const axiosError = err as AxiosError;
setError(
axiosError.response?.data?.error?.message ||
'❌ AI对话失败，请检查网络后重试'
);
} finally {
setLoading(false);
}
};

// ⌨️ 回车发送
const handleKeyDown = (e: React.KeyboardEvent) => {
if (e.key === 'Enter' && !e.shiftKey) {
e.preventDefault();
sendMessage();
}
};

return (
<div style={{
maxWidth: '800px',
margin: '0 auto',
border: '1px solid #e0e0e0',
borderRadius: '12px',
boxShadow: '0 4px 20px rgba(0,0,0,0.08)',
backgroundColor: '#fff'
}}>
{/* 🎨 头部 */}
<div style={{
padding: '20px',
borderBottom: '1px solid #f0f0f0',
background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
borderRadius: '12px 12px 0 0',
color: 'white'
}}>
<h3 style={{ margin: 0, display: 'flex', alignItems: 'center', gap: '10px' }}>
<span>🤖</span> AI智能对话助手
</h3>
<p style={{ margin: '8px 0 0 0', opacity: 0.9, fontSize: '14px' }}>
基于 GPT–4 Turbo • 支持上下文理解
</p>
</div>

{/* 💬 聊天区域 */}
<div style={{
height: '400px',
overflow: 'auto',
padding: '20px',
backgroundColor: '#f8f9fa'
}}>
{chatList.length === 0 && (
<div style={{
textAlign: 'center',
color: '#999',
marginTop: '100px'
}}>
<div style={{ fontSize: '48px', marginBottom: '16px' }}>👋</div>
<p>开始你的第一次AI对话吧</p>
</div>
)}

{chatList.map((item, index) => (
<div key={index} style={{
marginBottom: '16px',
textAlign: item.role === 'user' ? 'right' : 'left'
}}>
<div style={{
display: 'inline-block',
maxWidth: '70%',
padding: '12px 16px',
borderRadius: item.role === 'user' ? '16px 16px 4px 16px' : '16px 16px 16px 4px',
backgroundColor: item.role === 'user' ? '#667eea' : '#fff',
color: item.role === 'user' ? 'white' : '#333',
boxShadow: '0 2px 8px rgba(0,0,0,0.1)',
lineHeight: '1.6'
}}>
{item.content}
</div>
<div style={{
fontSize: '12px',
color: '#999',
marginTop: '4px',
padding: item.role === 'user' ? '0 4px 0 0' : '0 0 0 4px'
}}>
{item.role === 'user' ? '👤 你' : '🤖 AI'}
</div>
</div>
))}

{loading && (
<div style={{ textAlign: 'center', padding: '20px' }}>
<div style={{
display: 'inline-flex',
alignItems: 'center',
gap: '8px',
color: '#667eea',
fontSize: '14px'
}}>
<span>🤔</span> AI正在思考…
</div>
</div>
)}

{error && (
<div style={{
textAlign: 'center',
color: '#e74c3c',
padding: '12px',
backgroundColor: '#fdf2f2',
borderRadius: '8px',
margin: '10px 0'
}}>
⚠️ {error}
</div>
)}

{/* ⌨️ 输入区域 */}
<div style={{
padding: '20px',
borderTop: '1px solid #f0f0f0',
display: 'flex',
gap: '12px'
}}>
<input
type="text"
value={inputValue}
onChange={(e) => setInputValue(e.target.value)}
onKeyDown={handleKeyDown}
placeholder="💭 请输入提问内容…"
style={{
flex: 1,
padding: '12px 16px',
border: '1px solid #e0e0e0',
borderRadius: '24px',
fontSize: '14px',
outline: 'none',
transition: 'all 0.3s'
}}
/>
<button
onClick={sendMessage}
disabled={loading || !inputValue.trim()}
style={{
padding: '12px 24px',
backgroundColor: loading || !inputValue.trim() ? '#ccc' : '#667eea',
color: 'white',
border: 'none',
borderRadius: '24px',
cursor: loading || !inputValue.trim() ? 'not-allowed' : 'pointer',
fontSize: '14px',
fontWeight: 500,
transition: 'all 0.3s'
}}
>
{loading ? '⏳' : '📤'} 发送
</button>
</div>
</div>
);
};

💡 说明：AI能生成基础API调用代码，但无法结合项目的权限体系、异常处理、节流控制、用户体验（自动滚动、加载状态）进行完善。

💻 示例3：跨端开发 —— React Native

📱 场景：跨端开发能力 📊 市场需求：BOSS直聘显示，3年+前端岗位中 60% 要求掌握跨端技术

// 📱 React Native 跨端组件示例
import React from 'react';
import { View, Text, StyleSheet, Platform, TouchableOpacity } from 'react-native';

// 🎯 跨端适配：根据不同平台调整样式和交互
const CrossPlatformCard = ({ title, content, onPress }) => {
return (
<TouchableOpacity
style={styles.container}
onPress={onPress}
activeOpacity={0.8}
>
<View style={styles.header}>
<Text style={styles.title}>{title}</Text>
{Platform.OS === 'ios' && <View style={styles.iosBadge} />}
</View>
<Text style={styles.content}>{content}</Text>
<View style={styles.footer}>
<Text style={styles.hint}>
{Platform.select({
ios: '👆 点击打开',
android: '👆 点击查看',
default: '👆 点击'
})}
</Text>
</View>
</TouchableOpacity>
);
};

const styles = StyleSheet.create({
container: {
backgroundColor: '#fff',
borderRadius: Platform.OS === 'ios' ? 12 : 8,
padding: 16,
margin: 8,
// 📱 平台特定阴影
…Platform.select({
ios: {
shadowColor: '#000',
shadowOffset: { width: 0, height: 2 },
shadowOpacity: 0.1,
shadowRadius: 8,
},
android: {
elevation: 4,
},
}),
},
header: {
flexDirection: 'row',
justifyContent: 'space-between',
alignItems: 'center',
marginBottom: 8,
},
title: {
fontSize: 18,
fontWeight: '600',
color: '#333',
},
iosBadge: {
width: 8,
height: 8,
borderRadius: 4,
backgroundColor: '#007AFF',
},
content: {
fontSize: 14,
color: '#666',
lineHeight: 20,
},
footer: {
marginTop: 12,
paddingTop: 12,
borderTopWidth: 1,
borderTopColor: '#f0f0f0',
},
hint: {
fontSize: 12,
color: '#999',
},
});

export default CrossPlatformCard;

🧠 方向 2️⃣：产品思维 —— 从"写代码"到"懂产品"

🎯 目标：理解用户需求，成为产品的共建者

AI能生成代码，但无法理解"用户为什么需要这个功能"“这个功能如何更贴合用户习惯”。

📚 重点提升方向

🎯 能力📖 具体行动💡 示例

需求分析	分析产品需求背后的用户痛点	为什么做这个按钮？用户点击目的是什么？
UX设计	优化交互逻辑，贴合用户习惯	加载状态、错误提示、操作反馈
沟通协作	主动与产品经理沟通，提技术建议	技术可行性评估、体验优化方案

💻 示例：产品思维落地 —— 登录按钮交互优化

🎯 产品需求：

登录按钮点击后禁用，避免重复提交
加载状态显示"登录中"
连续3次失败提示"忘记密码"
失败后3秒解锁按钮

import React, { useState, useCallback } from 'react';

interface LoginButtonProps {
onLogin: () => Promise<boolean>;
}

export const SmartLoginButton: React.FC<LoginButtonProps> = ({ onLogin }) => {
const [isLoading, setIsLoading] = useState(false);
const [isDisabled, setIsDisabled] = useState(false);
const [loginAttempts, setLoginAttempts] = useState(0);
const [showForgotPassword, setShowForgotPassword] = useState(false);

const handleLogin = useCallback(async () => {
if (isLoading || isDisabled) return;

setIsLoading(true);
setIsDisabled(true);

try {
const success = await onLogin();

if (success) {
// ✅ 登录成功：重置失败次数
setLoginAttempts(0);
setShowForgotPassword(false);
} else {
// ❌ 登录失败：累计失败次数
const newAttempts = loginAttempts + 1;
setLoginAttempts(newAttempts);

// 🚨 产品需求：超过3次提示忘记密码
if (newAttempts >= 3) {
setShowForgotPassword(true);
}

// ⏱️ 产品需求：失败后3秒解锁，避免频繁点击
setTimeout(() => {
setIsDisabled(false);
}, 3000);
}
} catch (error) {
// 🛡️ 异常处理
setTimeout(() => {
setIsDisabled(false);
}, 3000);
} finally {
setIsLoading(false);
}
}, [isLoading, isDisabled, loginAttempts, onLogin]);

return (
<div style={{ textAlign: 'center' }}>
<button
onClick={handleLogin}
disabled={isLoading || isDisabled}
style={{
padding: '14px 32px',
backgroundColor: isLoading || isDisabled ? '#ccc' : '#0071e3',
color: 'white',
border: 'none',
borderRadius: '10px',
cursor: isLoading || isDisabled ? 'not-allowed' : 'pointer',
fontSize: '16px',
fontWeight: 500,
transition: 'all 0.3s ease',
boxShadow: isLoading || isDisabled
? 'none'
: '0 4px 14px rgba(0, 113, 227, 0.3)',
transform: isLoading || isDisabled ? 'scale(1)' : 'scale(1)',
}}
onMouseEnter={(e) => {
if (!isLoading && !isDisabled) {
e.currentTarget.style.transform = 'scale(1.02)';
}
}}
onMouseLeave={(e) => {
e.currentTarget.style.transform = 'scale(1)';
}}
>
{isLoading ? (
<span>
<span style={{
display: 'inline-block',
animation: 'spin 1s linear infinite'
}}>⏳</span>
{' '}登录中…
</span>
) : (
'🔐 登录'
)}
</button>

{/* 🔗 忘记密码链接（产品需求：连续3次失败显示） */}
{showForgotPassword && (
<a
href="/forgot-password"
style={{
display: 'block',
marginTop: '12px',
color: '#0071e3',
fontSize: '14px',
textDecoration: 'none',
transition: 'color 0.3s'
}}
onMouseEnter={(e) => {
e.currentTarget.style.color = '#0051a3';
e.currentTarget.style.textDecoration = 'underline';
}}
onMouseLeave={(e) => {
e.currentTarget.style.color = '#0071e3';
e.currentTarget.style.textDecoration = 'none';
}}
>
❓ 忘记密码？点击找回
</a>
)}

{/* 📊 尝试次数提示（用户体验优化） */}
{loginAttempts > 0 && loginAttempts < 3 && (
<p style={{
marginTop: '8px',
fontSize: '12px',
color: '#e74c3c'
}}>
⚠️ 登录失败 {loginAttempts} 次，再失败 {3 – loginAttempts} 次将提示找回密码
</p>
)}
</div>
);
};

💡 说明：这个按钮的交互逻辑完全基于产品需求和用户习惯设计，AI无法自主判断这些细节。

🏗️ 方向 3️⃣：架构思维 —— 从"写组件"到"搭架构"

🎯 目标：掌控项目全局，设计可维护的架构

AI能生成单个组件，但无法设计前端项目的整体架构。

📊 市场需求：BOSS直聘2026年数据显示，中高级前端岗位中 70% 要求具备"前端架构设计能力"，薪资比普通中高级前端高 20%+

💻 示例1：接口封装架构

// 🌐 src/utils/request.ts – 全局接口请求封装（架构思维核心）
import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import { Message, MessageBox } from 'element-ui';
import store from '@/store';

// 🎯 创建axios实例
const service: AxiosInstance = axios.create({
baseURL: process.env.VUE_APP_BASE_API, // 🔧 环境变量区分开发/生产
timeout: 10000,
headers: {
'Content-Type': 'application/json;charset=utf-8'
}
});

// ⬆️ 请求拦截器：添加token、统一处理请求参数
service.interceptors.request.use(
(config: AxiosRequestConfig) => {
// 🔐 从vuex中获取token
const token = store.getters.token;
if (token) {
config.headers = config.headers || {};
config.headers['Authorization'] = `Bearer ${token}`;
}

// 📝 GET请求参数序列化 + 防缓存
if (config.method === 'get' && config.params) {
config.params = {
…config.params,
_t: Date.now() // 时间戳防缓存
};
}

// 📊 请求日志（开发环境）
if (process.env.NODE_ENV === 'development') {
console.log(`🚀 [Request] ${config.method?.toUpperCase()} ${config.url}`, config.params || config.data);
}

return config;
},
(error) => {
console.error('❌ Request Error:', error);
Message.error('请求发送失败，请检查网络');
return Promise.reject(error);
}
);

// ⬇️ 响应拦截器：统一处理响应、错误提示、token过期
service.interceptors.response.use(
(response: AxiosResponse) => {
const res = response.data;

// ✅ 统一判断接口返回状态
if (res.code !== 200) {
Message.error(res.message || '操作失败');

// 🔒 token过期处理
if (res.code === 401) {
MessageBox.confirm(
'🔐 登录已过期，请重新登录',
'系统提示',
{
confirmButtonText: '重新登录',
cancelButtonText: '取消',
type: 'warning'
}
).then(() => {
store.dispatch('user/logout').then(() => {
window.location.reload();
});
});
}

return Promise.reject(new Error(res.message || '操作失败'));
}

// 📊 响应日志（开发环境）
if (process.env.NODE_ENV === 'development') {
console.log(`✅ [Response] ${response.config.url}`, res.data);
}

return res.data;
},
(error) => {
// 🛡️ 统一处理网络错误
let message = '网络异常，请重试';

if (error.response) {
switch (error.response.status) {
case 400:
message = '❌ 请求参数错误';
break;
case 401:
message = '🔒 未授权，请重新登录';
break;
case 403:
message = '🚫 拒绝访问';
break;
case 404:
message = '🔍 请求地址不存在';
break;
case 408:
message = '⏱️ 请求超时';
break;
case 500:
message = '💥 服务器内部错误';
break;
case 502:
message = '🌐 网关错误';
break;
case 503:
message = '🔧 服务器维护中';
break;
case 504:
message = '⏱️ 网关超时';
break;
default:
message = error.response.data?.message || message;
}
} else if (error.message.includes('timeout')) {
message = '⏱️ 请求超时，请重试';
}

Message.error(message);
console.error('❌ Response Error:', error);
return Promise.reject(error);
}
);

// 📦 统一封装请求方法
export const request = {
get<T = any>(url: string, params?: object): Promise<T> {
return service({ method: 'get', url, params });
},
post<T = any>(url: string, data?: object): Promise<T> {
return service({ method: 'post', url, data });
},
put<T = any>(url: string, data?: object): Promise<T> {
return service({ method: 'put', url, data });
},
delete<T = any>(url: string, params?: object): Promise<T> {
return service({ method: 'delete', url, params });
},
// 📤 文件上传
upload<T = any>(url: string, file: File): Promise<T> {
const formData = new FormData();
formData.append('file', file);
return service({
method: 'post',
url,
data: formData,
headers: { 'Content-Type': 'multipart/form-data' }
});
}
};

export default service;

💻 示例2：通用组件封装架构

// 🎨 src/components/CommonButton/index.tsx – 全局通用按钮组件
import React from 'react';
import './index.css';

// 🎯 组件属性接口定义
interface CommonButtonProps {
/** 按钮类型 */
type?: 'primary' | 'success' | 'warning' | 'danger' | 'default';
/** 按钮尺寸 */
size?: 'large' | 'middle' | 'small';
/** 子元素 */
children: React.ReactNode;
/** 点击事件 */
onClick?: () => void;
/** 加载状态 */
loading?: boolean;
/** 禁用状态 */
disabled?: boolean;
/** 图标 */
icon?: React.ReactNode;
/** 块级按钮 */
block?: boolean;
/** 自定义类名 */
className?: string;
}

/**
* 🎨 通用按钮组件
*
* 设计原则：
* 1. 支持多种类型、尺寸、状态
* 2. 适配全局项目UI规范
* 3. 低耦合、高复用
*
* @example
* <CommonButton type="primary" size="large" onClick={handleClick}>
* 提交
* </CommonButton>
*/
const CommonButton: React.FC<CommonButtonProps> = ({
type = 'primary',
size = 'middle',
children,
onClick,
loading = false,
disabled = false,
icon = null,
block = false,
className = ''
}) => {
// 🎨 类型映射：结合项目UI规范
const typeMap = {
primary: 'common-btn–primary', // 🔵 主色：品牌色
success: 'common-btn–success', // 🟢 成功：绿色
warning: 'common-btn–warning', // 🟡 警告：黄色
danger: 'common-btn–danger', // 🔴 危险：红色
default: 'common-btn–default' // ⚪ 默认：灰色
};

// 📏 尺寸映射
const sizeMap = {
large: 'common-btn–large', // 📏 大：padding 16px 32px
middle: 'common-btn–middle', // 📏 中：padding 12px 24px（默认）
small: 'common-btn–small' // 📏 小：padding 8px 16px
};

// 🔧 构建类名
const buttonClass = [
'common-btn',
typeMap[type],
sizeMap[size],
block ? 'common-btn–block' : '',
loading ? 'common-btn–loading' : '',
className
].filter(Boolean).join(' ');

return (
<button
className={buttonClass}
onClick={onClick}
disabled={loading || disabled}
type="button"
>
{loading && (
<span className="common-btn__spinner">
<svg viewBox="0 0 1024 1024" focusable="false" data–icon="loading" width="1em" height="1em" fill="currentColor" aria–hidden="true">
<path d="M988 548c-19.9 0-36-16.1-36-36 0-59.4-11.6-117-34.6-171.3a440.45 440.45 0 00-94.3-139.9 437.71 437.71 0 00-139.9-94.3C629 83.6 571.4 72 512 72c-19.9 0-36-16.1-36-36s16.1-36 36-36c69.1 0 136.2 13.5 199.3 40.3C772.3 66 827 103 874 150c47 47 83.9 101.8 109.7 162.7 26.7 63.1 40.2 130.2 40.2 199.3.1 19.9-16 36-35.9 36z"></path>
</svg>
</span>
)}
{icon && <span className="common-btn__icon">{icon}</span>}
<span className="common-btn__content">{children}</span>
</button>
);
};

export default CommonButton;

💡 说明：架构思维的核心是"全局观"——接口统一封装（便于维护、复用、统一错误处理）、通用组件封装（低耦合、高复用），这些都是AI无法设计的。

💼 方向 4️⃣：业务能力 —— 从"懂技术"到"懂业务"

🎯 目标：成为业务伙伴，理解业务逻辑

AI能生成代码，但无法理解业务逻辑、无法结合业务场景进行开发。

📊 市场需求：BOSS直聘显示，2026年前端岗位招聘中，“熟悉业务逻辑"成为仅次于"技术能力"的第二大要求，大厂更倾向于招聘"懂业务的前端”

💻 示例：电商购物车核心业务逻辑

🛒 业务规则梳理：

✅ 商品可勾选，勾选才计算总价

➕➖ 商品数量可增减，最小为1，超过库存提示

☑️ 支持全选/取消全选

💰 勾选商品变化时，自动计算总价、总数量

🔐 未登录时，数据存本地；登录后，合并本地与服务器数据

🏷️ 折扣商品按折扣价计算

import React, { useState, useEffect, useCallback } from 'react';
import { request } from '@/utils/request';

// 🛒 购物车商品类型
interface CartItem {
id: string;
name: string;
image: string;
price: number;
discountPrice?: number;
quantity: number;
stock: number;
checked: boolean;
}

/**
* 🛒 电商购物车组件
*
* 核心业务逻辑：
* – 登录/未登录数据同步
* – 全选/单选逻辑
* – 数量控制（1 ~ stock）
* – 价格计算（原价 vs 折扣价）
* – 数据持久化（本地存储 + 服务器）
*/
export const ShoppingCart: React.FC = () => {
const [cartList, setCartList] = useState<CartItem[]>([]);
const [isAllChecked, setIsAllChecked] = useState(false);
const [totalPrice, setTotalPrice] = useState(0);
const [totalCount, setTotalCount] = useState(0);
const [isLogin] = useState(!!localStorage.getItem('token'));
const [loading, setLoading] = useState(false);

// 🔄 初始化购物车数据
useEffect(() => {
if (isLogin) {
fetchCartFromServer();
} else {
loadLocalCart();
}
}, [isLogin]);

// 📥 从服务器获取购物车
const fetchCartFromServer = async () => {
setLoading(true);
try {
const data = await request.get<CartItem[]>('/api/cart/list');
setCartList(data);
} catch (err) {
console.error('❌ 获取购物车失败：', err);
} finally {
setLoading(false);
}
};

// 💾 从本地存储加载
const loadLocalCart = () => {
const localCart = localStorage.getItem('localCart');
if (localCart) {
try {
setCartList(JSON.parse(localCart));
} catch {
console.error('❌ 本地购物车数据解析失败');
}
}
};

// 🔄 登录后合并购物车
const mergeCart = useCallback(async () => {
const localCart = localStorage.getItem('localCart');
if (!localCart) return;

try {
const localData = JSON.parse(localCart);
await request.post('/api/cart/merge', { cartList: localData });
localStorage.removeItem('localCart');
fetchCartFromServer();
} catch (err) {
console.error('❌ 合并购物车失败：', err);
}
}, []);

// 🔄 登录状态变化时合并
useEffect(() => {
if (isLogin) {
mergeCart();
}
}, [isLogin, mergeCart]);

// 💰 计算总价和总数量（核心业务逻辑）
useEffect(() => {
let price = 0;
let count = 0;

cartList.forEach(item => {
if (item.checked) {
// 🏷️ 业务规则：折扣商品按折扣价计算
const itemPrice = item.discountPrice || item.price;
price += itemPrice * item.quantity;
count += item.quantity;
}
});

setTotalPrice(Number(price.toFixed(2)));
setTotalCount(count);

// ☑️ 判断是否全选
const isAll = cartList.length > 0 && cartList.every(item => item.checked);
setIsAllChecked(isAll);
}, [cartList]);

// ☑️ 勾选/取消勾选单个商品
const handleCheckItem = async (id: string) => {
const newCartList = cartList.map(item =>
item.id === id ? { …item, checked: !item.checked } : item
);

setCartList(newCartList);
syncCartData(newCartList);
};

// ☑️ 全选/取消全选
const handleCheckAll = async () => {
const newCartList = cartList.map(item => ({
…item,
checked: !isAllChecked
}));

setCartList(newCartList);
syncCartData(newCartList);
};

// ➕➖ 增减商品数量
const handleChangeQuantity = async (id: string, type: 'add' | 'reduce') => {
const newCartList = cartList.map(item => {
if (item.id === id) {
let newQuantity = type === 'add'
? item.quantity + 1
: item.quantity – 1;

// 🛡️ 业务规则：数量最小为1，最大不超过库存
newQuantity = Math.max(1, Math.min(newQuantity, item.stock));

return { …item, quantity: newQuantity };
}
return item;
});

setCartList(newCartList);
syncCartData(newCartList);
};

// 🔄 同步购物车数据（本地/服务器）
const syncCartData = async (data: CartItem[]) => {
if (!isLogin) {
localStorage.setItem('localCart', JSON.stringify(data));
} else {
try {
await request.post('/api/cart/update', { cartList: data });
} catch (err) {
console.error('❌ 同步购物车失败：', err);
}
}
};

// 🗑️ 删除商品
const handleDelete = async (id: string) => {
const newCartList = cartList.filter(item => item.id !== id);
setCartList(newCartList);
syncCartData(newCartList);
};

if (loading) {
return (
<div style={{ textAlign: 'center', padding: '50px' }}>
<div style={{ fontSize: '24px' }}>🛒</div>
<p>加载购物车…</p>
</div>
);
}

return (
<div style={{ maxWidth: '1200px', margin: '0 auto', padding: '20px' }}>
<h2 style={{
display: 'flex',
alignItems: 'center',
gap: '10px',
borderBottom: '2px solid #e0e0e0',
paddingBottom: '15px'
}}>
<span>🛒</span> 我的购物车
<span style={{
fontSize: '14px',
color: '#666',
fontWeight: 'normal'
}}>
({cartList.length}件商品)
</span>
</h2>

{cartList.length === 0 ? (
<div style={{
textAlign: 'center',
padding: '80px 20px',
backgroundColor: '#f8f9fa',
borderRadius: '12px',
marginTop: '20px'
}}>
<div style={{ fontSize: '64px', marginBottom: '20px' }}>🛍️</div>
<h3 style={{ color: '#666', marginBottom: '10px' }}>
购物车空空如也
</h3>
<p style={{ color: '#999' }}>快去添加心仪的商品吧～</p>
</div>
) : (
<>
{/* 📝 表头 */}
<div style={{
display: 'grid',
gridTemplateColumns: '50px 2fr 1fr 1fr 1fr 100px',
gap: '15px',
padding: '15px',
backgroundColor: '#f8f9fa',
borderRadius: '8px',
marginBottom: '10px',
fontWeight: 'bold',
color: '#666'
}}>
<input
type="checkbox"
checked={isAllChecked}
onChange={handleCheckAll}
style={{ cursor: 'pointer' }}
/>
<span>☑️ 全选 / 商品信息</span>
<span style={{ textAlign: 'center' }}>💰 单价</span>
<span style={{ textAlign: 'center' }}>🔢 数量</span>
<span style={{ textAlign: 'center' }}>💵 小计</span>
<span style={{ textAlign: 'center' }}>🗑️ 操作</span>
</div>

{/* 📦 商品列表 */}
<div style={{ display: 'flex', flexDirection: 'column', gap: '10px' }}>
{cartList.map(item => (
<div key={item.id} style={{
display: 'grid',
gridTemplateColumns: '50px 2fr 1fr 1fr 1fr 100px',
gap: '15px',
padding: '20px',
backgroundColor: '#fff',
borderRadius: '12px',
boxShadow: '0 2px 8px rgba(0,0,0,0.08)',
alignItems: 'center'
}}>
<input
type="checkbox"
checked={item.checked}
onChange={() => handleCheckItem(item.id)}
style={{ cursor: 'pointer' }}
/>

{/* 🖼️ 商品信息 */}
<div style={{ display: 'flex', alignItems: 'center', gap: '15px' }}>
<img
src={item.image}
alt={item.name}
style={{
width: '80px',
height: '80px',
objectFit: 'cover',
borderRadius: '8px',
border: '1px solid #e0e0e0'
}}
/>
<div>
&l

深度学习入门（鱼书）第4章笔记——神经网络的学习

2026-06-03master阅读(18)

第04章：神经网络的学习

本笔记整理自《深度学习入门：基于 Python 的理论与实现》（鱼书），包含学习笔记与代码示例。

源码仓库

GitHub: https://github.com/2Anblo/deep-learning-from-scratch
Gitee: https://gitee.com/zb4r/deep-learning-from-scratch

本章开始进入神经网络最核心的内容之一——学习。

这里的“学习”，指的是：

利用训练数据
自动调整权重参数
让神经网络的预测越来越准确

在前面的章节中，我们一直是在“使用”已经设定好的权重进行前向传播，而这一章开始，我们要研究：

如何让神经网络自己找到这些权重

为了衡量神经网络预测得好不好，本章会引入：

损失函数（Loss Function）
梯度（Gradient）
梯度下降法（Gradient Descent）

神经网络学习的目标，本质上就是：

找到能让损失函数最小的参数

而梯度法，则是寻找这个最优参数的重要方法。

4.1 从数据中学习

神经网络最大的特点之一，就是：

参数可以通过数据自动学习

这和之前感知机中“手动设置权重”完全不同。

在第2章里：

AND
OR
NAND

这些逻辑门的参数，都是我们根据真值表人工设计的。

但现实中的神经网络：

参数数量可能有几十万
甚至上亿

例如：

W1.shape = (784, 100)
W2.shape = (100, 200)
W3.shape = (200, 10)

仅仅几个矩阵，就已经包含大量参数。

因此：

人工调参数是不现实的

所以必须让神经网络：

根据训练数据自动优化参数

这就是“学习”。

本章后面会使用：

MNIST 手写数字数据集

真正实现：

参数学习
损失计算
梯度更新

从而让神经网络逐渐学会识别数字。

补充：

第2章的感知机其实也可以“学习”。

根据：

感知机收敛定理

对于：

线性可分问题

感知机可以通过有限次学习找到正确参数。

但是：

非线性可分问题

例如 XOR：

单层感知机无法自动学习解决

而神经网络：

通过多层结构
非线性激活函数

能够学习更加复杂的问题。

4.1.1 数据驱动

机器学习最核心的东西其实就是：

数据

没有数据，机器学习几乎什么都做不了。

传统编程里，人通常会自己设计规则：

遇到什么情况怎么办
哪些特征重要
应该如何判断

本质上是：

人写规则 → 程序执行规则

但机器学习反过来了：

给机器大量数据 → 机器自己找规律

这就是“数据驱动”。

书里举了一个经典例子：

识别手写数字 5

看起来很简单，因为人一眼就能认出来。

但如果真让我们写程序：

到底怎样才算“5”？

其实非常难描述。

因为不同人的写法差异特别大：

有人写得圆
有人写得瘦
有人连笔
有人倾斜

图4-1里就能明显看出来：

在这里插入图片描述

同样都是 5，但长得五花八门

所以：

人能直觉识别
≠
人能准确总结规则

这也是传统人工规则方法的困难所在。

早期机器学习的一种典型思路是：

先人工提取“特征”
再让机器学习这些特征

例如图像处理中，人们会设计：

SIFT
SURF
HOG

这些“特征量”。

本质上是：

人先告诉机器：
“图像里什么信息重要”

然后再交给：

SVM
KNN

等算法分类。

也就是说：

机器负责学习
但“看什么”仍然由人决定

而神经网络（深度学习）最大的不同在于：

连特征也自己学习

它直接输入原始图像：

像素 → 神经网络 → 输出结果

中间不需要人工设计特征。

所以图4-2里：

在这里插入图片描述

灰色部分表示“机器自动完成”
神经网络那一行几乎全部是灰色

意味着：

人为干预更少

传统方法：

图像
→ 人工特征
→ 机器学习
→ 结果

深度学习：

图像
→ 神经网络自动学习
→ 结果

这也是：

端到端（End-to-End）

学习的含义。

所谓“端到端”：

从原始输入
直接得到最终输出

中间不需要人为拆步骤。

神经网络还有一个很大的优势：

同一套流程
可以解决很多不同问题

比如：

识别数字
识别猫狗
人脸识别
语音识别

传统方法往往都要：

重新设计特征

但神经网络通常只需要：

换数据继续训练

即可。

4.1.2 训练数据和测试数据

在机器学习中，数据通常不会直接全部拿来训练，而是会分成两部分：

训练数据（Training Data）
测试数据（Test Data）

其中：

训练数据用于让模型学习规律、调整参数
测试数据用于检验模型真正的效果

这样做的核心目的，是为了验证模型有没有“泛化能力”。

这里的“泛化能力”，可以理解成：

模型是否能处理从来没见过的新数据。

机器学习真正追求的，并不是“把训练集背下来”，而是能够举一反三。

比如手写数字识别：

训练时，模型可能看过很多人的数字“8”。

但实际应用时，系统面对的是：

没见过的人
没见过的字迹
不同风格的数字

如果模型依然能正确识别，就说明它具备较好的泛化能力。

否则，就可能只是死记硬背了训练数据里的写法。

因此，只使用同一批数据来：

训练模型
再评价模型

其实是不可靠的。

因为模型很可能只是“记住了答案”。

这种现象叫作：

过拟合（Overfitting）

也就是：

模型在训练数据上表现很好，但面对新数据时效果很差。

避免过拟合，是机器学习中的一个重要问题。

4.2 损失函数

在神经网络学习过程中，模型需要一个“标准”来判断自己当前表现得怎么样。

这个标准，就是：

损失函数（Loss Function）

可以把它理解成：

神经网络当前“犯错的程度”。

损失函数会用一个数值来表示模型预测结果和真实答案之间的差距。

差距越大 → 损失越大
差距越小 → 损失越小

而神经网络训练的目标，其实就是：

不断调整参数，让损失函数尽可能变小。

书里用了“幸福指数”来举例，其实很好理解。

正常人描述幸福时，可能只会说：

“还不错”
“一般般”
“挺开心”

但如果能给幸福程度打分，比如：

幸福指数 = 10.23

那就能更精确地比较不同状态。

神经网络也是类似的。

它不会简单地判断：

“预测得还行”
“预测得不好”

而是会通过损失函数，把当前错误程度转换成一个具体数值。

这样模型才能知道：

现在效果怎么样
参数调整后有没有变好
应该往哪个方向优化

这里有一个容易混淆的点：

损失函数衡量的是“坏的程度”。

也就是说：

损失越大 → 模型越差
损失越小 → 模型越好

因此，训练的目标通常写成：

最小化损失函数

本质上等价于：

最大化模型性能

只是数学上更习惯使用“最小化错误”这种表达方式。

实际中，损失函数可以自由设计。

但神经网络里最常见的有两种：

均方误差（Mean Squared Error）
交叉熵误差（Cross Entropy Error）

后面会重点介绍这两种损失函数。

4.2.1 均方误差

均方误差（Mean Squared Error，MSE）是最经典的损失函数之一。

它的作用很简单：

计算“预测结果”和“真实答案”之间到底差了多少。

公式如下：

E

=

1

2

∑

k

(

y

k

−

t

k

)

2

E=\\frac{1}{2}\\sum_{k}(y_k-t_k)^2

$E = \frac{1}{2} k \sum (y_{k} - t_{k})^{2}$ 其中：

y_k 表示神经网络的输出
t_k 表示真实标签（监督数据）
k 表示第 k 个元素

整个公式的流程其实就是：

预测值减去真实值

对误差平方

全部加起来

因为用了平方：

误差越大，惩罚越明显
正负误差不会互相抵消

前面的 1/2 主要是为了后面求导方便，对结果本质影响不大。

在手写数字识别中，输出层通常有 10 个神经元，对应数字：

0 ~ 9

例如：

y = [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]

这里表示模型认为：

是“0”的概率：0.1
是“1”的概率：0.05
是“2”的概率：0.6
…

其中概率最大的“2”，说明模型最倾向于认为答案是数字 2。

而监督数据 t：

t = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

这里正确答案是“2”。

因为只有索引为 2 的位置是 1。

这种表示方法叫：

One–Hot 表示

特点是：

正确标签位置为 1
其他位置全部为 0

均方误差的 Python 实现非常直接：

def mean_squared_error(y, t):
return 0.5 * np.sum((y – t) ** 2)

这里：

(y – t) ** 2

表示：

先计算误差
再逐元素平方

然后：

np.sum()

把所有误差加起来。

书里给了两个例子。

第一个例子：

y = [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]

模型认为“2”的概率最高。

而正确答案也正好是“2”。

因此损失较小：

0.0975

第二个例子：

y = [0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0]

这里模型最相信的是“7”。

但正确答案其实是“2”。

因此误差明显更大：

0.5975

也就是说：

均方误差越小，说明模型预测越接近真实答案。

神经网络训练的目标，本质上就是：

不断调整参数，让均方误差越来越小

4.2.2 交叉熵误差

除了均方误差之外，神经网络里还有一个非常常用的损失函数：

交叉熵误差（Cross Entropy Error）

它的公式如下：

E

=

−

∑

k

t

k

log

⁡

y

k

E=-\\sum_k t_k\\log y_k

$E = - k \sum t_{k} lo g y_{k}$ 其中：

y_k 表示模型输出的概率
t_k 表示正确标签（one-hot）
log 表示自然对数

交叉熵误差和均方误差最大的不同在于：

它只关心“正确答案对应的概率”有多大。

因为在 one-hot 表示中：

t = [0, 0, 1, 0, 0, ...]

只有正确标签的位置是 1。

其他位置全是 0。

所以：

t_k * log(y_k)

实际上只有正确答案那一项会被保留下来。

比如：

正确答案是数字 2。

如果模型输出：

y = [0.1, 0.05, 0.6, ...]

那么真正参与计算的，其实只有：

–log(0.6)

结果约等于：

0.51

如果模型对正确答案非常没信心：

y = [0.1, 0.05, 0.1, ..., 0.6, ...]

此时正确答案“2”的概率只有：

0.1

那么损失会变成：

–log(0.1) ≈ 2.30

误差一下子变得很大。

这里其实体现了交叉熵误差的核心思想：

正确答案概率越大 → 损失越小
正确答案概率越小 → 损失越大

当模型对正确答案的概率预测为：

1

时：

log(1) = 0

因此：

交叉熵误差 = 0

说明模型预测完全正确。

自然对数函数的图像大致如下：

当 x → 1 时 → log(x) → 0
当 x → 0 时 → log(x) 会快速减小

因此：

–log(x)

会在概率很小时迅速变大。

这意味着：

如果模型把正确答案概率预测得很低，交叉熵会给予非常大的惩罚。

这也是它在分类问题中特别好用的原因。

交叉熵误差的代码实现如下：

def cross_entropy_error(y, t):
delta = 1e-7
return –np.sum(t * np.log(y + delta))

这里：

delta = 1e-7

是一个非常小的值。

作用是防止：

np.log(0)

因为：

log(0) = –∞

会导致程序无法正常计算。

因此通常会人为加一个极小值做保护。

从结果上也能明显看出来：

正确答案概率高 → 交叉熵小
正确答案概率低 → 交叉熵大

因此，训练神经网络时：

让交叉熵误差不断减小

就等价于：

让模型越来越相信正确答案

4.2.3 mini-batch学习

前面介绍的均方误差和交叉熵误差，都是针对单个样本计算的。

但实际训练神经网络时，我们面对的是整个训练集，因此损失函数也应该反映所有训练数据的整体表现。

以交叉熵误差为例，当训练集包含 N 个样本时，损失函数可以写成：

E

=

−

1

N

∑

n

∑

k

t

n

k

log

⁡

y

n

k

E=-\\frac{1}{N}\\sum_n\\sum_k t_{nk}\\log y_{nk}

$E = - \frac{1}{N} n \sum k \sum t_{nk} lo g y_{nk}$ 这里：

N：训练样本总数
n：第 n 个样本
k：输出层第 k 个神经元
$y_{nk} ynk：模型对第 n 个样本的预测结果$
$t_{nk} tnk：第 n 个样本的真实标签$

其实这个公式并不复杂，本质上就是：

把每个样本的交叉熵误差全部加起来，再求平均值。

最后除以 N 的作用是进行平均化（正规化）。

这样无论训练集有：

100 条数据
1000 条数据
10000 条数据

最终得到的损失函数都处于同一个量级，便于比较和分析。

不过，实际训练时通常不会每次都使用全部训练数据。

原因很简单：

数据量太大
计算速度太慢
每更新一次参数都要遍历全部样本

例如：

MNIST 训练集有：

60000 个样本

如果每次计算损失函数都使用全部数据，训练效率会非常低。

而现实中的数据集往往有：

几百万条
几千万条
甚至更多

这种情况下，全量计算几乎是不现实的。

因此，深度学习采用了一种折中的方法：

每次只随机抽取一小部分数据参与训练。

这部分数据称为：

Mini-Batch（小批量）

例如：

训练集：60000条

随机抽取：100条

然后：

计算这100条数据的损失函数
计算梯度
更新参数

下一次再随机抽取另外100条数据继续训练。

这种训练方式就叫：

Mini–Batch Learning

以 MNIST 为例：

(x_train, t_train), (x_test, t_test) = \\
load_mnist(normalize=True, one_hot_label=True)

读取完成后：

x_train.shape
# (60000, 784)

t_train.shape
# (60000, 10)

这里：

60000 表示训练样本数量
784 表示输入层维度（28×28像素）
10 表示输出层维度（数字0~9）

因此：

x_train[i]

表示第 i 道题（输入图片）

而：

t_train[i]

表示对应的标准答案。

两者下标一一对应。

接下来随机抽取一个 Mini-Batch：

train_size = x_train.shape[0]
batch_size = 10

batch_mask = np.random.choice(train_size, batch_size)

x_batch = x_train[batch_mask]
t_batch = t_train[batch_mask]

这里：

np.random.choice(60000, 10)

会随机生成 10 个索引，例如：

array([
11035, 34071, 37349, 56787, 27918,
1853, 11821, 31543, 14277, 8427
])

然后：

x_train[batch_mask]

取出对应的 10 张图片。

t_train[batch_mask]

取出对应的 10 个答案。

于是就得到了一个：

Mini–Batch = 10组(图片 + 标签)

这里的 Mini-Batch 本质上就是随机抽出来的 10 组训练样本。

本节重点

损失函数最终关注的是整个训练集的平均误差。
全量数据计算代价太高，因此实际训练采用 Mini-Batch。
Mini-Batch 就是从训练集中随机抽取的一小部分样本。
x_train[i] 是第 i 个输入数据，t_train[i] 是对应答案。
batch_size=10 时，每次训练只使用随机选出的 10 组样本。
神经网络训练过程本质上是在不断抽取 Mini-Batch，并利用它们更新参数。

4.2.4 mini-batch版交叉熵误差的实现

前面实现的交叉熵误差只适用于单个样本。

但实际训练时，我们输入的往往是一个 Mini-Batch，因此需要让损失函数能够一次处理多条数据。

首先来看支持 Batch 的版本：

def cross_entropy_error(y, t):
if y.ndim == 1:
t = t.reshape(1, t.size)
y = y.reshape(1, y.size)

batch_size = y.shape[0]

return –np.sum(t * np.log(y + 1e-7)) / batch_size

这里增加了两个关键处理。

处理单个样本输入

如果：

y.ndim == 1

说明输入的是：

y = [0.1, 0.2, 0.7, 0, 0, 0, 0, 0, 0, 0]

这样的单条数据。

而后面的代码统一按照二维数组处理，因此需要先转换形状：

y.reshape(1, y.size)

例如：

[0.1, 0.2, 0.7, 0, 0, 0, 0, 0, 0, 0]

变成：

[[0.1, 0.2, 0.7, 0, 0, 0, 0, 0, 0, 0]]

形状从：

(10,)

变成：

(1, 10)

这样无论输入一个样本还是多个样本，都能使用同一套代码。

求平均损失

batch_size = y.shape[0]

表示当前 Batch 中有多少条数据。

例如：

y.shape
# (100, 10)

说明：

Batch 中有100个样本
每个样本有10个分类概率

因此：

batch_size = 100

最后：

/ batch_size

表示求平均损失。

这样得到的结果不会因为 Batch 大小不同而发生明显变化。

标签形式的交叉熵误差

前面的写法要求监督数据采用 One-Hot 表示：

t = [0,0,1,0,0,0,0,0,0,0]

但很多时候标签其实直接保存为：

t = 2

或者：

t = [2,7,0,9,4]

此时可以进一步优化：

def cross_entropy_error(y, t):
if y.ndim == 1:
t = t.reshape(1, t.size)
y = y.reshape(1, y.size)

batch_size = y.shape[0]

return –np.sum(
np.log(y[np.arange(batch_size), t] + 1e-7)
) / batch_size

为什么可以这样写？

先回忆 One-Hot 版本：

t * np.log(y)

例如：

t = [0,0,1,0]
y = [0.1,0.2,0.6,0.1]

计算后：

[0, 0, log(0.6), 0]

实际上只有正确答案的位置保留下来了。

其他位置全被乘成了0。

所以我们真正需要的其实只是：

log(0.6)

也就是：

正确标签对应位置的预测概率。

np.arange(batch_size) 的作用

假设：

batch_size = 5

那么：

np.arange(batch_size)

得到：

[0, 1, 2, 3, 4]

如果标签为：

t = [2, 7, 0, 9, 4]

表示：

第0个样本正确答案是2
第1个样本正确答案是7
第2个样本正确答案是0
第3个样本正确答案是9
第4个样本正确答案是4

此时：

y[np.arange(batch_size), t]

等价于：

[
y[0,2],
y[1,7],
y[2,0],
y[3,9],
y[4,4]
]

即：

一次性取出每个样本对应正确答案的预测概率。

例如：

[0.6, 0.8, 0.9, 0.7, 0.5]

然后再计算：

np.log(...)

即可得到交叉熵误差。

本节重点

Mini-Batch版交叉熵误差需要同时支持单个样本和批量样本。
reshape() 用于把一维数据统一转换成二维数据。
batch_size = y.shape[0] 表示 Batch 中样本数量。
最后除以 batch_size，得到平均损失。
标签形式比 One-Hot 更节省空间。
y[np.arange(batch_size), t] 可以一次性取出每个样本正确类别对应的预测概率。
交叉熵误差本质上只关心正确答案对应的概率有多大。

4.2.5 为何要设定损失函数

学习到这里，一个很自然的问题是：

我们最终想提高的是识别准确率，为什么还要额外设计一个损失函数呢？

例如在手写数字识别中：

最终目标是提高识别精度
训练时却在不断减小损失函数

看起来好像绕了一圈。

实际上，这是因为神经网络学习依赖于导数（梯度）。

神经网络训练时，会不断调整：

权重（Weight）
偏置（Bias）

而调整方向则由导数决定。

例如：

某个权重的导数 < 0

说明：

增大这个权重，损失函数会减小。

反之：

某个权重的导数 > 0

说明：

减小这个权重，损失函数会减小。

因此，训练过程实际上是在做：

计算梯度 → 更新参数 → 降低损失

如果导数为 0：

参数怎么改都不会让损失变化

此时学习就停止了。

那么为什么不用识别精度来求导呢？

原因在于：

识别精度是不连续的。

举个例子。

假设：

100 个样本

正确识别 32 个

那么：

Accuracy = 32%

此时即使把网络参数稍微调整一点点：

32% → 32%

识别精度通常不会发生变化。

因为预测结果还没有跨过分类边界。

例如：

原来模型输出：

数字2概率 = 0.51
数字7概率 = 0.49

预测结果：

2

调整参数后：

数字2概率 = 0.55
数字7概率 = 0.45

预测结果仍然是：

2

因此：

准确率完全没变

虽然模型实际上已经变好了。

识别精度的变化往往是这样的：

32%
32%
32%
32%
33%
33%
33%

它只能跳跃式变化。

而不会出现：

32.0001%
32.0002%
32.0003%

这样的连续变化。

因此：

准确率对于微小参数变化几乎没有反应。

对应的导数自然大部分时候都是：

0

这样梯度下降法就失去了作用。

而损失函数不同。

例如交叉熵误差：

0.92543

参数稍微变化一点：

0.92317

再变化一点：

0.92084

损失会连续变化。

这样就能计算导数。

也就能知道：

参数应该往哪个方向调整

这也是为什么神经网络训练时：

优化目标 = 损失函数

而不是：

优化目标 = 识别精度

实际上：

训练阶段优化损失函数
评估阶段观察识别精度

两者分工不同。

这个问题和第3章提到的激活函数其实非常类似。

阶跃函数：

x < 0 → 0

x ≥ 0 → 1

图像像开关一样。

除了跳变点以外：

导数 = 0

y

=

{

0

(

x

<

0

)

1

(

x

≥

0

)

y=\\begin{cases}0&(x<0)\\\\1&(x\\ge0)\\end{cases}

$y = {01 (x < 0) (x \geq 0)$

因此参数即使发生微小变化：

输出也不会变化

神经网络就无法学习。

而 Sigmoid 函数则不同：

y

=

1

+

e

−

x

y=\\frac{1}{1+e^{-x}}

$y = \frac{1}{1 + e ^{- x}}$ 在这里插入图片描述

Sigmoid 具有两个重要特点：

输出连续变化
导数也连续变化

因此：

参数变化一点
↓
输出变化一点
↓
损失变化一点
↓
梯度能够计算

神经网络才能顺利学习。

本节重点

神经网络依靠梯度（导数）更新参数。
识别精度是离散变化的，对微小参数变化几乎没有反应。
因此以识别精度作为优化目标时，大多数位置导数为 0。
损失函数是连续变化的，能够提供有效梯度。
神经网络训练时优化损失函数，而不是直接优化识别精度。
阶跃函数导数几乎处处为 0，因此不适合作为神经网络激活函数。
Sigmoid 函数输出连续、导数连续，能够支持梯度学习。

4.3 数值微分

梯度法使用梯度的信息决定前进的方向。本节将介绍梯度是什么、有什么性质等内容。在这之前，我们先来介绍一下导数。

4.3.1 导数

在神经网络学习中，导数是一个非常重要的概念。

简单来说：

导数表示某个位置上，函数变化得有多快。

书中用马拉松举了一个例子。

假设运动员：

10分钟跑了2千米

那么平均速度为：

2 ÷ 10 = 0.2 千米/分钟

不过这里得到的是：

一段时间内的平均变化率

而导数关注的是：

某一个瞬间的变化率

就像汽车仪表盘显示的时速一样，它反映的是当前这一刻的速度，而不是整个行程的平均速度。

数学上，导数定义为：

d

f

(

x

)

d

x

=

lim

⁡

h

→

0

f

(

x

+

h

)

−

f

(

x

)

h

\\frac{df(x)}{dx}=\\lim_{h\\to0}\\frac{f(x+h)-f(x)}{h}

$\frac{df ( x )}{d x} = h \to 0 lim \frac{f ( x + h ) - f ( x )}{h}$ 其中：

f(x) 表示函数
x 表示当前位置
h 表示一个极小的变化量

整个公式表达的含义是：

当 x 发生一个极小变化时，函数值会变化多少。

也可以理解为：

函数在该点切线的斜率。

数值微分

理论上导数由极限定义：

h → 0

但计算机无法真正表示“无限接近0”。

因此实际计算时，会使用一个很小的数来近似求导。

这种方法称为：

数值微分（Numerical Differentiation）

最直接的实现方式如下：

# 不好的实现示例
def numerical_diff(f, x):
h = 1e-50
return (f(x + h) – f(x)) / h

看起来完全符合导数定义，但实际上存在两个问题。

问题一：h太小会产生舍入误差

代码中使用：

h = 1e-50

希望尽可能接近0。

但计算机的浮点数精度有限。

例如：

np.float32(1e-50)

结果：

0.0

因为数字太小，已经超出了 float32 的表示能力。

这种由于精度不足导致的误差称为：

舍入误差（Rounding Error）

因此实际计算中通常采用：

h = 1e-4

即：

0.0001

这个值已经足够小，同时又不会产生严重精度问题。

问题二：前向差分本身存在误差

前面的公式实际上计算的是：

f(x+h) – f(x)

对应图中的这条斜线：

(x, f(x))
↓
(x+h, f(x+h))

求得的是两点连线的斜率。

而真正的导数应该是：

x 点处切线的斜率

因此两者并不完全相同。

图中所示：

深色直线：真正切线
浅色直线：近似切线

两者存在一定偏差。

中心差分

为了减小这种误差，通常采用：

x+h

和

x–h

两侧同时计算。

公式变为：

f

(

x

+

h

)

−

f

(

x

−

h

)

2

h

\\frac{f(x+h)-f(x-h)}{2h}

$\frac{f ( x + h ) - f ( x - h )}{2 h}$ 这种方法称为：

中心差分（Central Difference）

相比：

f(x+h)–f(x)

的前向差分，

中心差分以 x 为中心进行计算，因此更加接近真实切线。

最终实现如下：

def numerical_diff(f, x):
h = 1e-4
return (f(x+h) – f(x–h)) / (2*h)

这也是后续章节计算数值梯度时使用的方法。

数值微分 vs 解析求导

求导大致有两种方式。

1. 数值微分

利用差分近似：

(f(x+h)–f(x–h))/(2*h)

特点：

简单直观
容易实现
存在近似误差
计算速度较慢

2. 解析求导

直接利用数学公式推导。

例如：

y

=

x

2

y=x^2

$y = x^{2}$ 在这里插入图片描述解析求导得到：

d

y

d

x

=

2

x

\\frac{dy}{dx}=2x

$\frac{d y}{d x} = 2 x$ 当：

x = 2

时：

dy/dx = 4

这种方法得到的是理论上的真实导数。

特点：

没有数值误差
计算速度快
需要数学推导

本节重点

导数表示函数在某一点的瞬时变化率。
导数本质上对应函数切线的斜率。
计算机无法真正令 h→0，因此使用数值微分近似计算。
h 太小会产生舍入误差。
前向差分误差较大，因此采用中心差分：

(f(x+h)–f(x–h))/(2h)
利用差分近似求导称为数值微分。
利用数学公式直接推导称为解析求导。
神经网络后续计算梯度时，会大量使用数值微分的思想。

4.3.2 数值微分的例子

前面介绍了数值微分的实现方法，下面通过一个具体例子来看看它的效果。

这里使用的函数是：

y

=

0.01

x

2

+

0.1

x

y=0.01x^2+0.1x

$y = 0.01 x^{2} + 0.1 x$ 对应的 Python 实现：

def function_1(x):
return 0.01 * x**2 + 0.1 * x

观察函数图像

利用 matplotlib 绘图后，可以得到如图4-6所示的曲线。

在这里插入图片描述从图像可以发现：

函数整体单调递增
曲线越来越陡
说明随着 x 增大，函数变化速度也在增大

这也意味着：

函数的导数会随着 x 的增大而增大。

使用数值微分计算导数

利用上一节实现的 numerical_diff()：

numerical_diff(function_1, 5)

结果：

0.1999999999990898

计算：

numerical_diff(function_1, 10)

结果：

0.2999999999986347

因此：

x = 5 时，导数约为 0.2
x = 10 时，导数约为 0.3

这里的导数表示：

x 每增加 1 个单位时，函数值大约增加多少。

例如：

x = 5 时

导数 ≈ 0.2

表示附近区域内：

x 增加 1

f(x) 大约增加 0.2

与解析解比较

这个函数其实可以直接求导。

原函数：

y

=

0.01

x

2

+

0.1

x

y=0.01x^2+0.1x

$y = 0.01 x^{2} + 0.1 x$ 解析求导得到：

d

y

d

x

=

0.02

x

+

0.1

\\frac{dy}{dx}=0.02x+0.1

$\frac{d y}{d x} = 0.02 x + 0.1$ 代入：

x = 5

得到：

0.02 × 5 + 0.1 = 0.2

代入：

x = 10

得到：

0.02 × 10 + 0.1 = 0.3

与数值微分结果：

0.1999999999990898
0.2999999999986347

几乎完全一致。

误差仅来自浮点数计算。

切线的含义

书中接着利用求出的导数绘制了切线。

例如：

x = 5

处的切线斜率为：

0.2

而：

x = 10

处的切线斜率为：

0.3

从图4-7可以明显看出：

在这里插入图片描述

x=5 处切线较平缓
x=10 处切线更陡

这与我们刚刚计算出的导数大小完全一致：

0.3 > 0.2

说明：

导数越大，函数增长得越快，切线也越陡。

本节重点

数值微分可以近似计算函数在某一点的导数。
导数表示函数在该点的瞬时变化率。
对函数

y = 0.01x² + 0.1x

而言：
- x=5 时导数约为 0.2
- x=10 时导数约为 0.3
解析求导结果为：

d

y

d

x

=

0.02

x

+

0.1

\\frac{dy}{dx}=0.02x+0.1

$\frac{d y}{d x} = 0.02 x + 0.1$
数值微分结果与解析解几乎一致。
导数本质上对应函数在该点切线的斜率。
导数越大，函数增长越快，切线越陡。

4.3.3 偏导数

前面讨论的导数只有一个变量，例如：

y

=

x

2

y = x^2

$y = x^{2}$ 而在神经网络中，函数往往会包含多个参数。

因此，我们需要研究：

当函数有多个变量时，如何计算某个变量对结果的影响。

多变量函数

这里使用的例子是：

f

(

x

0

,

x

1

)

=

x

0

2

+

x

1

2

f(x_0, x_1)=x_0^2+x_1^2

$f (x_{0}, x_{1}) = x_{0}^{2} + x_{1}^{2}$ 对应的 Python 实现：

def function_2(x):
return x[0]**2 + x[1]**2

# 等价写法
def function_2(x):
return np.sum(x**2)

这里：

x[0] 对应 $x_0 x0$
x[1] 对应 $x_1 x1$

函数的作用很简单：

计算所有变量平方后的总和。

函数图像

与前面的单变量函数不同：

f

(

x

0

,

x

1

)

f(x_0,x_1)

$f (x_{0}, x_{1})$ 包含两个输入变量，因此图像不再是二维曲线，而是三维曲面。

从图4-8可以看到：

在这里插入图片描述

曲面像一个碗
最低点位于原点

即：

(

x

0

,

x

1

)

=

(

0

,

0

)

(x_0,x_1)=(0,0)

$(x_{0}, x_{1}) = (0, 0)$ 此时：

f

(

x

0

,

x

1

)

=

0

f(x_0,x_1)=0

$f (x_{0}, x_{1}) = 0$ 取得最小值。

什么是偏导数

对于多变量函数：

f

(

x

0

,

x

1

)

f(x_0,x_1)

$f (x_{0}, x_{1})$ 我们可以分别研究：

x₀ 变化时函数如何变化
x₁ 变化时函数如何变化

这种只针对某一个变量求导的方法称为：

偏导数（Partial Derivative）

记作：

∂

f

∂

x

0

\\frac{\\partial f}{\\partial x_0}

$\frac{\partial f}{\partial x _{0}}$ 和

∂

f

∂

x

1

\\frac{\\partial f}{\\partial x_1}

$\frac{\partial f}{\partial x _{1}}$ 这里的符号：

∂

\\partial

$\partial$ 表示偏导数。

求关于 $x_0 x0 的偏导数$

题目：

当 x₀=3，x₁=4 时，求关于 x₀ 的偏导数。

求偏导时：

固定 x₁
只让 x₀ 变化

因此把：

x

1

=

4

x_1=4

$x_{1} = 4$ 代入原函数：

f

(

x

0

)

=

x

0

2

+

4

2

f(x_0)=x_0^2+4^2

$f (x_{0}) = x_{0}^{2} + 4^{2}$ 对应代码：

def function_tmp1(x0):
return x0*x0 + 4.0**2

然后直接调用数值微分：

numerical_diff(function_tmp1, 3.0)

结果：

6.00000000000378

约等于：

6

$6$

求关于 $x_1 x1 的偏导数$

同理：

固定 x₀
只让 x₁ 变化

令：

x

0

=

3

x_0=3

$x_{0} = 3$ 得到：

f

(

x

1

)

=

3

2

+

x

1

2

f(x_1)=3^2+x_1^2

$f (x_{1}) = 3^{2} + x_{1}^{2}$ 对应代码：

def function_tmp2(x1):
return 3.0**2 + x1*x1

计算：

numerical_diff(function_tmp2, 4.0)

结果：

7.999999999999119

约等于：

8

$8$

为什么结果是 6 和 8？

原函数：

f

(

x

0

,

x

1

)

=

x

0

2

+

x

1

2

f(x_0,x_1)=x_0^2+x_1^2

$f (x_{0}, x_{1}) = x_{0}^{2} + x_{1}^{2}$ 解析求偏导：

对 x₀ 求导：

∂

f

∂

x

0

=

2

x

0

\\frac{\\partial f}{\\partial x_0}=2x_0

$\frac{\partial f}{\partial x _{0}} = 2 x_{0}$ 代入：

x

0

=

3

x_0=3

$x_{0} = 3$ 得到：

2

×

3

=

6

2\\times3=6

$2 \times 3 = 6$

对 x₁ 求导：

∂

f

∂

x

1

=

2

x

1

\\frac{\\partial f}{\\partial x_1}=2x_1

$\frac{\partial f}{\partial x _{1}} = 2 x_{1}$ 代入：

x

1

=

4

x_1=4

$x_{1} = 4$ 得到：

2

×

4

=

8

2\\times4=8

$2 \times 4 = 8$ 与数值微分的结果完全一致。

偏导数的本质

偏导数和普通导数本质上是一样的：

都是在求某一点的斜率。

区别在于：

普通导数：

只有一个变量

偏导数：

有多个变量

只研究其中一个变量

其余变量保持不变

因此可以简单记忆：

偏导数 = 固定其它变量后，对目标变量求导。

本节重点

多变量函数包含多个输入变量。
对多变量函数求导时得到的是偏导数。
偏导数表示：

固定其它变量时，目标变量变化对函数的影响。
对于函数：

f

(

x

0

,

x

1

)

=

x

0

2

+

x

1

2

f(x_0,x_1)=x_0^2+x_1^2

$f (x_{0}, x_{1}) = x_{0}^{2} + x_{1}^{2}$ 有：

∂

f

∂

x

0

=

2

x

0

\\frac{\\partial f}{\\partial x_0}=2x_0

$\frac{\partial f}{\partial x _{0}} = 2 x_{0}$

∂

f

∂

x

1

=

2

x

1

\\frac{\\partial f}{\\partial x_1}=2x_1

$\frac{\partial f}{\partial x _{1}} = 2 x_{1}$
当 (x₀,x₁)=(3,4) 时：

∂

f

∂

x

0

=

6

\\frac{\\partial f}{\\partial x_0}=6

$\frac{\partial f}{\partial x _{0}} = 6$

∂

f

∂

x

1

=

8

\\frac{\\partial f}{\\partial x_1}=8

$\frac{\partial f}{\partial x _{1}} = 8$
计算偏导数时，需要固定其它变量，仅让目标变量发生变化。

4.4 梯度

前面学习偏导数时，我们分别计算了：

∂

f

∂

x

0

\\frac{\\partial f}{\\partial x_0}

$\frac{\partial f}{\partial x _{0}}$ 和

∂

f

∂

x

1

\\frac{\\partial f}{\\partial x_1}

$\frac{\partial f}{\partial x _{1}}$ 但对于多变量函数来说，仅仅知道单个变量的变化情况还不够。

我们希望能够同时描述：

所有变量变化时，函数会朝哪个方向变化。

因此引入了梯度（Gradient）的概念。

什么是梯度

对于多变量函数：

f

(

x

0

,

x

1

)

f(x_0,x_1)

$f (x_{0}, x_{1})$ 把所有偏导数组合在一起：

(

∂

f

∂

x

0

,

∂

f

∂

x

1

)

\\left( \\frac{\\partial f}{\\partial x_0}, \\frac{\\partial f}{\\partial x_1} \\right)

$(\frac{\partial f}{\partial x _{0}}, \frac{\partial f}{\partial x _{1}})$ 得到的向量称为梯度。

例如：

f

(

x

0

,

x

1

)

=

x

0

2

+

x

1

2

f(x_0,x_1)=x_0^2+x_1^2

$f (x_{0}, x_{1}) = x_{0}^{2} + x_{1}^{2}$ 在点：

(

3

,

4

)

(3,4)

$(3, 4)$ 处：

∂

f

∂

x

0

=

6

\\frac{\\partial f}{\\partial x_0}=6

$\frac{\partial f}{\partial x _{0}} = 6$ 因此梯度为：

(

6

,

8

)

(6,8)

$(6, 8)$ 梯度可以理解为：

函数在各个变量方向上的变化率组成的向量。

numerical_gradient 的实现思路

def _numerical_gradient(f, x):
h = 1e-4 # 0.0001
grad = np.zeros_like(x)

for idx in range(x.size):
tmp_val = x[idx]
x[idx] = float(tmp_val) + h
fxh1 = f(x) # f(x+h)

x[idx] = tmp_val – h
fxh2 = f(x) # f(x-h)
grad[idx] = (fxh1 – fxh2) / (2*h)

x[idx] = tmp_val # 还原值

return grad

书中的 numerical_gradient() 本质上是在做：

固定其它变量

对当前变量做中心差分

计算偏导数

把所有偏导数存入数组

返回最终梯度向量

例如：

numerical_gradient(function_2, np.array([3.0, 4.0]))

结果：

array([6., 8.])

表示：在这里插入图片描述

同样：

numerical_gradient(function_2, np.array([0.0, 2.0]))

得到：

array([0., 4.])

说明：

在这里插入图片描述

梯度图的含义

对于函数：

f

(

x

0

,

x

1

)

=

x

0

2

+

x

1

2

f(x_0,x_1)=x_0^2+x_1^2

$f (x_{0}, x_{1}) = x_{0}^{2} + x_{1}^{2}$ 书中绘制了对应的梯度图。

图中的每个箭头都是一个梯度向量。

在这里插入图片描述

观察图像可以发现：

箭头都指向原点附近
离原点越远，箭头越长
越接近原点，箭头越短

这是因为：

(

0

,

0

)

(0,0)

$(0, 0)$ 是该函数的最小值点。

梯度表示什么方向

梯度最重要的性质是：

梯度指向函数值增加最快的方向。

例如：

在点：

(

3

,

4

)

(3,4)

$(3, 4)$ 处，

梯度为：

(

6

,

8

)

(6,8)

$(6, 8)$ 说明如果沿着：

(

6

,

8

)

(6,8)

$(6, 8)$ 这个方向移动，

函数值会增长得最快。

为什么图中箭头指向最低点

书中特别说明：

图4-9画的并不是梯度本身，而是：

−

∇

f

-\\nabla f

$- \nabla f$ 即负梯度。

因此图中的箭头全部朝向函数最低处。

对于：

f

(

x

0

,

x

1

)

=

x

0

2

+

x

1

2

f(x_0,x_1)=x_0^2+x_1^2

$f (x_{0}, x_{1}) = x_{0}^{2} + x_{1}^{2}$ 最低点位于：

(

0

,

0

)

(0,0)

$(0, 0)$ 所以所有箭头都指向原点。

梯度与神经网络学习

神经网络训练时，我们希望：

损失函数不断减小。

而梯度告诉我们：

哪个方向增长最快。

因此只需要朝着相反方向移动即可：

−

∇

f

-\\nabla f

$- \nabla f$ 这就是：

函数值下降最快的方向。

后面要学习的梯度下降法（Gradient Descent），正是利用这一性质不断更新参数，从而找到损失函数的最小值。

本节重点

梯度是所有偏导数组成的向量。
梯度描述了函数在各个变量方向上的变化率。
numerical_gradient() 通过分别计算偏导数来求梯度。
梯度指向函数值增加最快的方向。
负梯度指向函数值减小最快的方向。
图4-9绘制的是负梯度，因此箭头都指向最低点。
神经网络后续的参数优化，本质上就是沿着负梯度方向不断更新参数。

4.4.1 梯度法

机器学习和神经网络训练的目标，本质上都是寻找一组最优参数，使损失函数尽可能小。

但现实中的损失函数通常十分复杂：

参数很多
搜索空间很大
无法直接求出最小值

因此需要一种能够逐步逼近最优解的方法，这就是梯度法（Gradient Method）。

梯度法的基本思想

前面学习过：

梯度指向函数值增加最快的方向。

那么：

−

∇

f

-\\nabla f

$- \nabla f$ 自然就是函数值下降最快的方向。

因此，如果想让损失函数不断减小，只需要不断沿着负梯度方向移动即可。

梯度法的过程可以概括为：

当前位置
↓
计算梯度
↓
沿负梯度方向移动一步
↓
到达新位置
↓
重新计算梯度
↓
继续移动

不断重复这个过程，就有机会逐渐靠近函数的最小值。

梯度不一定指向最小值

这里有一个容易误解的地方。

很多人会认为：

梯度是不是直接指向最小值？

答案是否定的。

梯度只能保证：

在当前位置附近，沿这个方向函数下降最快。

但无法保证：

这个方向最终一定能到达全局最小值。

对于复杂函数来说，还可能遇到：

局部最小值（Local Minimum）
鞍点（Saddle Point）
学习高原（Plateau）

例如：

局部最小值：某个小区域内最小，但不是全局最小
鞍点：某个方向是极大值，另一个方向是极小值
学习高原：梯度非常小，参数更新几乎停止

因此梯度法并不是万能的，但它依然是深度学习中最常用的优化方法。

梯度下降更新公式

梯度法可以写成下面的更新公式：

x

0

=

x

0

−

η

∂

f

∂

x

0

x_0=x_0-\\eta \\frac{\\partial f}{\\partial x_0}

$x0=x0−<span class=\"base$

Java高级全套教程（十二）—— 分布式事务超详细实战全解（基础理论+双方案企业级实战）

2026-06-02master阅读(51)

Java高级全套教程（十二）—— 分布式事务超详细实战全解（基础理论+双方案企业级实战）

第一章数据库本地事务核心原理

1.1 事务核心定义

事务是数据库层面保障数据操作可靠性的核心机制，指一组关联性的SQL操作集合，集合内的所有数据库操作是一个不可分割的原子单元。事务执行遵循“全员成功、全员回滚”原则：若所有SQL执行无异常，整体提交生效；若任意一条SQL执行失败、程序报错、网络中断，所有已执行的操作全部撤销，数据恢复至操作前状态。

事务的核心作用是解决业务操作中数据一致性问题，避免多步数据库操作出现“部分成功、部分失败”的数据错乱场景。

业务场景举例：用户下单扣库存、生成订单、扣余额是一组关联业务，任意一步失败，所有操作都必须回滚，不能出现“库存扣除但订单创建失败”的脏数据。

1.2 本地事务概念

本地事务又称数据库事务，是依托关系型数据库（MySQL、Oracle等）原生事务机制实现的事务控制。其核心特征为：事务涉及的所有业务数据、数据库操作，均在同一个数据库、同一个服务节点内完成，无需跨服务、跨库、跨节点协作。

本地事务仅适用于单体架构系统，依托数据库ACID特性即可完美保障数据一致性；在微服务分布式架构中，多服务、多数据库拆分后，本地事务将完全失效，无法解决跨服务数据一致性问题。

1.3 事务四大核心特性（ACID）

关系型数据库事务具备四大刚性特性，是所有数据一致性保障的基础：

原子性（Atomicity）：事务是最小执行单元，不可拆分。所有操作要么全部执行成功提交，要么全部失败回滚，不存在中间状态。
一致性（Consistency）：事务执行前后，数据库整体数据完整性、业务约束始终保持一致。例如转账场景，总资金总额不会发生变化。
隔离性（Isolation）：多个并发执行的事务相互隔离、互不干扰，数据库通过不同隔离级别控制并发事务的干扰程度，避免脏数据产生。
持久性（Durability）：事务一旦提交成功，数据变更会永久写入磁盘，即使服务器宕机、重启，数据也不会丢失。

第二章并发事务引发的核心问题

数据库支持多事务并发执行，高并发场景下，多个事务同时操作同一批数据，若没有合理的隔离机制，会引发数据异常问题。核心分为三类读写冲突问题、一类写冲突问题，是定义事务隔离级别的核心依据。

2.1 脏写（写-写冲突）

定义：两个及以上事务同时操作同一行数据，后提交的事务覆盖先提交事务的修改结果，导致前序事务的数据修改丢失。

场景复现：事务A修改用户余额未提交，事务B同时修改同一用户余额并提交，事务A后续提交后，直接覆盖B的修改数据，造成数据丢失。

解决方案：强制事务串行执行，同一数据同一时间仅允许一个事务执行写操作，杜绝并行写冲突。

2.2 脏读（读-写冲突）

定义：一个事务读取到了另一个事务未提交的临时数据，后续若该事务回滚，当前读取的数据即为无效脏数据。

场景复现：事务A扣除商品库存（未提交），事务B读取到库存减少的数据并执行后续业务，事务A因异常回滚恢复库存，导致事务B基于脏数据执行业务，引发数据错乱。

解决方案：实现写优先机制，数据写操作未提交完成前，禁止其他事务读取数据。

2.3 不可重复读（读-写冲突）

定义：同一事务内，两次读取同一数据结果不一致。事务第一次读取数据后，其他事务修改并提交该数据，导致当前事务再次查询时数据发生变化。

核心区别：脏读是读取未提交数据，不可重复读是读取已提交的修改数据，聚焦数据更新场景。

解决方案：实现读优先机制，事务读取数据期间，禁止其他事务修改、更新数据。

2.4 幻读（读-写冲突）

定义：同一事务内，根据相同查询条件多次查询，查询结果的数据集数量发生变化。其他事务新增/删除符合条件的数据，导致当前事务出现“幻觉数据”。

核心区别：不可重复读针对单条数据修改，幻读针对数据集新增/删除。

解决方案：锁定查询范围，事务读取期间，禁止其他事务新增、删除对应条件的数据。

第三章 MySQL事务隔离级别详解

MySQL InnoDB引擎实现了SQL标准的4种事务隔离级别，隔离级别从低到高，并发性能逐步降低，数据一致性逐步提升，可根据业务场景灵活选型。

3.1 四大隔离级别特性对照表

隔离级别脏读不可重复读幻读适用场景

读未提交（Read Uncommitted）	存在	存在	存在	极少使用，仅用于数据实时监控场景
读已提交（Read Committed）	杜绝	存在	存在	Oracle、SQL Server默认级别，适用于大多数并发业务
可重复读（Repeatable Read）	杜绝	杜绝	存在（理论）	MySQL默认级别，适配绝大多数企业业务场景
串行化（Serializable）	杜绝	杜绝	杜绝	超高数据一致性场景，无并发需求，性能极低

3.2 各级别详细说明

3.2.1 读未提交

最低隔离级别，允许事务读取其他事务未提交的修改数据，无法杜绝任何并发问题，数据一致性极差，生产环境基本不使用。

3.2.2 读已提交

仅允许读取其他事务已提交的数据，彻底解决脏读问题。但同一事务内多次读取同一数据，可能读取到其他事务已提交的更新数据，存在不可重复读、幻读问题。

3.2.3 可重复读

MySQL默认事务隔离级别，保证同一事务多次读取同一数据结果完全一致，彻底解决脏读、不可重复读问题。InnoDB引擎通过MVCC机制极大缓解幻读问题，满足99%的企业业务需求。

3.2.4 串行化

最高隔离级别，强制所有事务串行顺序执行，完全规避所有并发问题。但会产生大量锁等待、锁竞争，并发性能极低，仅用于金融、支付等对数据一致性要求极致严苛的场景。

第四章分布式事务核心认知与解决方案选型

4.1 分布式事务产生背景

单体架构中，所有业务、数据集中在一个数据库，本地事务可完美保障一致性。微服务架构下，业务被拆分为多个独立微服务，每个服务对应独立数据库，跨服务业务操作（下单、扣库存、扣款）会涉及多库、多服务操作，本地事务失效，由此产生分布式事务问题。

分布式事务核心痛点：跨服务操作无法实现原子性，容易出现部分服务执行成功、部分失败，导致数据不一致。

4.2 柔性事务核心思想

分布式场景不适用数据库刚性ACID事务，企业主流采用柔性事务，核心思想：不追求实时强一致性，保障数据最终一致性，通过重试、日志、消息补偿机制，让延迟执行的业务最终完成，适配微服务高并发、高可用特性。

4.3 两大主流柔性事务方案对比

4.3.1 RocketMQ可靠消息最终一致性

核心逻辑：基于RocketMQ事务消息，保障事务发起方本地业务与消息发送原子一致，消息发送成功后，强制消费方执行业务，通过消息回查、日志幂等保证最终一致。

适用场景：业务时效性要求较高、必须保证消息可靠送达、上下游业务强关联的场景（下单扣库存、订单联动业务）。

4.3.2 最大努力通知型事务

核心逻辑：业务主动方完成本地事务后，尽可能多次通知被动方，同时提供主动查询校对机制，不保证消息100%实时送达，依靠重试+兜底查询实现最终一致。

适用场景：时效性低、被动方结果不影响主动方业务的场景（支付结果通知、充值结果同步）。

第五章 RocketMQ环境Docker企业级部署

5.1 环境依赖

服务器系统：CentOS 7+
运行环境：Docker 20.10+
中间件版本：RocketMQ 4.4.0
辅助工具：RocketMQ可视化控制台

5.2 前置环境配置

关闭SELinux与防火墙，规避端口访问、权限异常问题：

# 临时关闭SELinux
setenforce 0
# 永久关闭SELinux
sed -i 's/^enforcing/disabled/' /etc/selinux/config

# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

5.3 部署NameServer（注册中心）

NameServer是RocketMQ核心注册中心，负责Broker服务注册、发现、路由分发，无状态可集群部署。

# 创建数据挂载目录
mkdir -p /docker/rocketmq/namesrv/{logs,store}

# 启动NameServer容器
docker run -d \\
–restart=always \\
–name rmq-namesrv \\
-p 9876:9876 \\
-v /docker/rocketmq/namesrv/logs:/root/logs \\
-v /docker/rocketmq/namesrv/store:/root/store \\
-e "MAX_POSSIBLE_HEAP=100000000" \\
rocketmqinc/rocketmq sh mqnamesrv

5.4 部署Broker消息服务

Broker负责消息存储、投递、持久化，是消息核心处理节点，需自定义配置文件保证集群可用性。

5.4.1 编写Broker配置文件

# 创建配置目录
mkdir -p /docker/rocketmq/conf
# 编写核心配置
cat > /docker/rocketmq/conf/broker.conf << EOF
# 集群名称
brokerClusterName=DefaultCluster
# Broker节点名称
brokerName=broker-master
# 0代表Master节点
brokerId=0
# 消息删除时间（凌晨4点）
deleteWhen=04
# 消息磁盘保留时长48小时
fileReservedTime=48
# 异步主从同步模式
brokerRole=ASYNC_MASTER
# 异步刷盘策略（高性能）
flushDiskType=ASYNC_FLUSH
# 服务器内网IP（修改为当前服务器IP）
brokerIP1=192.168.66.100
# 磁盘最大使用比例
diskMaxUsedSpaceRatio=99
EOF

5.4.2 启动Broker容器

# 创建数据挂载目录
mkdir -p /docker/rocketmq/broker/{logs,store}

# 启动Broker容器
docker run -d \\
–restart=always \\
–name rmq-broker \\
–link rmq-namesrv:namesrv \\
-p 10911:10911 \\
-p 10909:10909 \\
–privileged=true \\
-v /docker/rocketmq/broker/logs:/root/logs \\
-v /docker/rocketmq/broker/store:/root/store \\
-v /docker/rocketmq/conf/broker.conf:/opt/rocketmq-4.4.0/conf/broker.conf \\
-e "NAMESRV_ADDR=namesrv:9876" \\
-e "MAX_POSSIBLE_HEAP=200000000" \\
rocketmqinc/rocketmq sh mqbroker -c /opt/rocketmq-4.4.0/conf/broker.conf

5.5 部署可视化控制台

docker run -d \\
–restart=always \\
–name rmq-console \\
-p 8080:8080 \\
-e "JAVA_OPTS=-Drocketmq.namesrv.addr=192.168.66.100:9876 -Dcom.rocketmq.sendMessageWithVIPChannel=false" \\
pangliang/rocketmq-console-ng

部署完成后，访问 http://192.168.66.100:8080 即可进入RocketMQ可视化管理界面，查看主题、消息、集群状态。

第六章可靠消息最终一致性分布式事务实战

6.1 业务场景说明

实现用户下单-扣库存跨微服务分布式事务：订单服务创建订单、库存服务扣除商品库存，保证两个服务操作要么全部成功、要么全部回滚，杜绝订单创建成功但库存未扣除、或库存扣除无订单的脏数据。

6.2 核心实现原理

订单服务发送半事务消息到RocketMQ，消息暂不允许消费；

执行订单服务本地事务（创建订单、记录事务日志）；

本地事务成功，通知MQ提交消息，库存服务消费消息扣库存；

本地事务失败，通知MQ回滚删除消息；

网络异常状态下，MQ定时回查本地事务状态，保证最终一致性；

通过事务日志实现幂等性，避免消息重复消费导致库存超扣。

6.3 数据库表设计

6.3.1 订单表 orders

CREATE TABLE `orders` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`order_no` varchar(64) NOT NULL COMMENT '订单唯一编号',
`product_id` bigint NOT NULL COMMENT '商品ID',
`pay_count` int NOT NULL COMMENT '购买数量',
`order_status` tinyint NOT NULL DEFAULT 1 COMMENT '订单状态 1-正常 0-失效',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_order_no` (`order_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';

6.3.2 库存表 stock

CREATE TABLE `stock` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`product_id` bigint NOT NULL COMMENT '商品ID',
`total_count` int NOT NULL DEFAULT 0 COMMENT '总库存数量',
`used_count` int NOT NULL DEFAULT 0 COMMENT '已售出数量',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_product_id` (`product_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品库存表';

6.3.3 事务日志表 tx_log（幂等核心）

CREATE TABLE `tx_log` (
`tx_no` varchar(64) NOT NULL COMMENT '全局事务编号',
`tx_status` tinyint NOT NULL DEFAULT 0 COMMENT '事务状态 0-处理中 1-已完成 2-已回滚',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '事务创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '事务更新时间',
PRIMARY KEY (`tx_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='分布式事务日志表';

6.4 工程搭建（父工程+双微服务）

6.4.1 父工程统一依赖管理

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.itbaizhan</groupId>
<artifactId>rocketmq-transaction-parent</artifactId>
<version>1.0.0</version>
<packaging>pom</packaging>
<modules>
<module>order-service</module>
<module>stock-service</module>
</modules>

<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<spring.boot.version>2.3.12.RELEASE</spring.boot.version>
<rocketmq.version>2.0.2</rocketmq.version>
<mybatis.plus.version>3.4.3.4</mybatis.plus.version>
</properties>

<dependencyManagement>
<dependencies>
<!– SpringBoot核心依赖 –>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring.boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>

<!– MybatisPlus –>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis.plus.version}</version>
</dependency>

<!– RocketMQ –>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-spring-boot-starter</artifactId>
<version>${rocketmq.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>

6.4.2 订单服务依赖（order-service）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.itbaizhan</groupId>
<artifactId>rocketmq-transaction-parent</artifactId>
<version>1.0.0</version>
</parent>

<modelVersion>4.0.0</modelVersion>
<artifactId>order-service</artifactId>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

6.5 核心通用实体类

6.5.1 分布式事务消息载体 TxMessage

package com.itbaizhan.common.tx;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;

/**
* 分布式事务消息通用载体
* 封装订单、库存服务交互的核心事务数据
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class TxMessage implements Serializable {

private static final long serialVersionUID = 89234792347923423L;

/**
* 全局唯一事务编号
*/
private String globalTxNo;

/**
* 商品ID
*/
private Long productId;

/**
* 购买数量
*/
private Integer buyCount;
}

6.5.2 事务日志实体 TxLog

package com.itbaizhan.order.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;

@Data
@TableName("tx_log")
public class TxLog {

@TableId(type = IdType.INPUT)
private String txNo;

private Integer txStatus;

private LocalDateTime createTime;

private LocalDateTime updateTime;
}

6.6 订单服务核心业务实现

6.6.1 订单服务配置文件 application.yml

server:
port: 9090

spring:
application:
name: order–transaction–service
datasource:
url: jdbc:mysql://192.168.66.100:3306/tx_order_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver

# RocketMQ配置
rocketmq:
name-server: 192.168.66.100:9876
producer:
group: order–transaction–group

# MybatisPlus配置
mybatis-plus:
mapper-locations: classpath:mapper/*.xml
global-config:
db-config:
id-type: auto
logic-delete-field: deleted

6.6.2 订单业务接口与实现

package com.itbaizhan.order.service;

import com.itbaizhan.order.entity.Order;
import com.itbaizhan.common.tx.TxMessage;

public interface OrderService {

/**
* 提交订单（入口方法）
* @param productId 商品ID
* @param buyCount 购买数量
*/
void submitOrder(Long productId, Integer buyCount);

/**
* 执行本地事务：创建订单+记录事务日志
* @param txMessage 全局事务消息
*/
void executeLocalOrderTx(TxMessage txMessage);
}

package com.itbaizhan.order.service.impl;

import com.alibaba.fastjson.JSON;
import com.itbaizhan.order.entity.Order;
import com.itbaizhan.order.entity.TxLog;
import com.itbaizhan.order.mapper.OrderMapper;
import com.itbaizhan.order.mapper.TxLogMapper;
import com.itbaizhan.order.service.OrderService;
import com.itbaizhan.common.tx.TxMessage;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.UUID;

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {

@Resource
private OrderMapper orderMapper;

@Resource
private TxLogMapper txLogMapper;

@Resource
private RocketMQTemplate rocketMQTemplate;

private static final String TRANSACTION_TOPIC = "order_stock_tx_topic";

@Override
public void submitOrder(Long productId, Integer buyCount) {
// 生成全局唯一事务编号
String globalTxNo = UUID.randomUUID().toString().replace("-", "");
// 封装事务消息
TxMessage txMessage = new TxMessage(globalTxNo, productId, buyCount);
Message<String> message = MessageBuilder.withPayload(JSON.toJSONString(txMessage)).build();
// 发送半事务消息，绑定本地事务
rocketMQTemplate.sendMessageInTransaction("order-transaction-group", TRANSACTION_TOPIC, message, txMessage);
log.info("订单事务消息发送成功，全局事务号：{}", globalTxNo);
}

@Override
@Transactional(rollbackFor = Exception.class)
public void executeLocalOrderTx(TxMessage txMessage) {
// 幂等判断：已执行过的事务直接返回
TxLog existTx = txLogMapper.selectById(txMessage.getGlobalTxNo());
if (existTx != null) {
log.info("订单事务已处理，无需重复执行，事务号：{}", txMessage.getGlobalTxNo());
return;
}

// 1. 创建订单数据
Order order = new Order();
order.setOrderNo(UUID.randomUUID().toString().replace("-", ""));
order.setProductId(txMessage.getProductId());
order.setPayCount(txMessage.getBuyCount());
order.setOrderStatus(1);
order.setCreateTime(LocalDateTime.now());
orderMapper.insert(order);

// 2. 记录事务日志，标记事务处理中
TxLog txLog = new TxLog();
txLog.setTxNo(txMessage.getGlobalTxNo());
txLog.setTxStatus(0);
txLog.setCreateTime(LocalDateTime.now());
txLogMapper.insert(txLog);
log.info("订单本地事务执行成功，事务号：{}", txMessage.getGlobalTxNo());
}
}

6.6.3 RocketMQ事务监听处理器（核心）

package com.itbaizhan.order.listener;

import com.alibaba.fastjson.JSON;
import com.itbaizhan.order.entity.TxLog;
import com.itbaizhan.order.mapper.TxLogMapper;
import com.itbaizhan.order.service.OrderService;
import com.itbaizhan.common.tx.TxMessage;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;

@Slf4j
@Component
@RocketMQTransactionListener(txProducerGroup = "order-transaction-group")
public class OrderTransactionListener implements RocketMQLocalTransactionListener {

@Autowired
private OrderService orderService;

@Resource
private TxLogMapper txLogMapper;

/**
* 执行本地事务
*/
@Override
@Transactional(rollbackFor = Exception.class)
public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
try {
TxMessage txMessage = (TxMessage) arg;
// 执行订单本地事务
orderService.executeLocalOrderTx(txMessage);
// 本地事务成功，提交消息，允许库存服务消费
return RocketMQLocalTransactionState.COMMIT;
} catch (Exception e) {
log.error("订单本地事务执行异常，事务回滚", e);
// 本地事务失败，回滚消息
return RocketMQLocalTransactionState.ROLLBACK;
}
}

/**
* 事务回查（网络异常兜底机制）
*/
@Override
public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
try {
String payload = new String((byte[]) msg.getPayload());
TxMessage txMessage = JSON.parseObject(payload, TxMessage.class);
// 查询事务日志，判断本地事务是否执行成功
TxLog txLog = txLogMapper.selectById(txMessage.getGlobalTxNo());
if (txLog != null) {
log.info("事务回查：本地事务已执行成功，事务号：{}", txMessage.getGlobalTxNo());
return RocketMQLocalTransactionState.COMMIT;
}
// 事务状态未知，继续回查
return RocketMQLocalTransactionState.UNKNOWN;
} catch (Exception e) {
log.error("事务回查异常", e);
return RocketMQLocalTransactionState.ROLLBACK;
}
}
}

6.6.4 订单控制层（测试入口）

package com.itbaizhan.order.controller;

import com.itbaizhan.order.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@Slf4j
@RestController
@RequestMapping("/order")
public class OrderController {

@Resource
private OrderService orderService;

@GetMapping("/create")
public String createOrder(@RequestParam Long productId, @RequestParam Integer buyCount) {
orderService.submitOrder(productId, buyCount);
return "订单提交成功，等待库存处理";
}
}

6.7 库存服务核心业务实现

6.7.1 库存服务配置文件 application.yml

server:
port: 9091

spring:
application:
name: stock–transaction–service
datasource:
url: jdbc:mysql://192.168.66.100:3306/tx_stock_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver

# RocketMQ配置
rocketmq:
name-server: 192.168.66.100:9876

# MybatisPlus配置
mybatis-plus:
mapper-locations: classpath:mapper/*.xml
global-config:
db-config:
id-type: auto

6.7.2 库存业务接口与实现

package com.itbaizhan.stock.service;

import com.itbaizhan.common.tx.TxMessage;

public interface StockService {

/**
* 扣减库存核心方法
* @param txMessage 事务消息
*/
void deductStock(TxMessage txMessage);
}

package com.itbaizhan.stock.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.itbaizhan.common.tx.TxMessage;
import com.itbaizhan.stock.entity.Stock;
import com.itbaizhan.stock.entity.TxLog;
import com.itbaizhan.stock.mapper.StockMapper;
import com.itbaizhan.stock.mapper.TxLogMapper;
import com.itbaizhan.stock.service.StockService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;

@Slf4j
@Service
public class StockServiceImpl implements StockService {

@Resource
private StockMapper stockMapper;

@Resource
private TxLogMapper txLogMapper;

@Override
@Transactional(rollbackFor = Exception.class)
public void deductStock(TxMessage txMessage) {
// 幂等校验：避免重复扣库存
TxLog existTx = txLogMapper.selectById(txMessage.getGlobalTxNo());
if (existTx != null) {
log.info("库存事务已处理，无需重复扣减，事务号：{}", txMessage.getGlobalTxNo());
return;
}

// 查询商品库存
LambdaQueryWrapper<Stock> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Stock::getProductId, txMessage.getProductId());
Stock stock = stockMapper.selectOne(queryWrapper);

// 校验库存是否充足
if (stock == null || stock.getTotalCount() < txMessage.getBuyCount()) {
throw new RuntimeException("商品库存不足，扣减失败");
}

// 扣减库存、更新已售数量
stock.setTotalCount(stock.getTotalCount() – txMessage.getBuyCount());
stock.setUsedCount(stock.getUsedCount() + txMessage.getBuyCount());
stockMapper.updateById(stock);

// 记录库存事务日志，实现幂等
TxLog txLog = new TxLog();
txLog.setTxNo(txMessage.getGlobalTxNo());
txLog.setTxStatus(1);
txLog.setCreateTime(LocalDateTime.now());
txLogMapper.insert(txLog);

log.info("库存扣减成功，商品ID：{}，扣减数量：{}，事务号：{}",
txMessage.getProductId(), txMessage.getBuyCount(), txMessage.getGlobalTxNo());
}
}

6.7.3 库存消息消费者

package com.itbaizhan.stock.consumer;

import com.alibaba.fastjson.JSON;
import com.itbaizhan.common.tx.TxMessage;
import com.itbaizhan.stock.service.StockService;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;

@Slf4j
@Component
@RocketMQMessageListener(consumerGroup = "stock-consumer-group", topic = "order_stock_tx_topic")
public class StockTransactionConsumer implements RocketMQListener<String> {

@Resource
private StockService stockService;

@Override
public void onMessage(String message) {
log.info("库存服务接收事务消息：{}", message);
// 解析事务消息
TxMessage txMessage = JSON.parseObject(message, TxMessage.class);
// 执行扣库存业务
stockService.deductStock(txMessage);
}
}

第七章最大努力通知型分布式事务实战

7.1 业务场景说明

实现充值结果异步通知业务：用户充值成功后，充值服务完成扣款，通过RocketMQ异步通知账户服务更新余额。采用最大努力通知机制，支持消息重试+主动查询兜底，适配低时效性、高可靠性的通知场景。

7.2 核心实现机制

充值服务完成本地充值事务，发送充值结果消息到MQ；

账户服务监听MQ消息，消费成功则更新账户余额；

消息消费失败时，MQ自动重试推送，实现多次通知；

长期通知失败，账户服务主动调用充值服务接口，查询充值结果兜底；

通过事务日志实现幂等，避免重复充值、余额重复累加。

7.3 数据库表设计

7.3.1 充值记录表 recharge

CREATE TABLE `recharge` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`recharge_no` varchar(64) NOT NULL COMMENT '充值订单号',
`user_id` bigint NOT NULL COMMENT '用户ID',
`recharge_amount` decimal(10,2) NOT NULL COMMENT '充值金额',
`recharge_status` tinyint NOT NULL DEFAULT 0 COMMENT '充值状态 0-待处理 1-充值成功 2-充值失败',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_recharge_no` (`recharge_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户充值记录表';

7.3.2 用户账户表 account

CREATE TABLE `account` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`user_id` bigint NOT NULL COMMENT '用户ID',
`balance` decimal(10,2) NOT NULL DEFAULT 0.00 COMMENT '账户余额',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户账户表';

7.3.3 通知事务日志表 notify_tx_log（幂等+兜底核心）

CREATE TABLE `notify_tx_log` (
`tx_no` varchar(64) NOT NULL COMMENT '全局事务编号',
`recharge_no` varchar(64) NOT NULL COMMENT '充值订单号',
`notify_status` tinyint NOT NULL DEFAULT 0 COMMENT '通知状态 0-待通知 1-通知成功 2-通知失败',
`notify_times` int NOT NULL DEFAULT 0 COMMENT '已通知次数',
`last_notify_time` datetime DEFAULT NULL COMMENT '最后通知时间',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`tx_no`),
UNIQUE KEY `uk_recharge_no` (`recharge_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='最大努力通知事务日志表';

7.4 整体工程结构说明

延续前文父工程，新增两个微服务：

recharge-service（充值服务）：处理用户充值、本地事务落库、发送充值通知消息、提供充值结果查询兜底接口
account-service（账户服务）：消费充值通知、更新用户余额、定时任务兜底查询未同步充值订单

7.5 通用消息实体（充值通知消息）

package com.itbaizhan.common.notify;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;

/**
* 充值通知消息实体
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class RechargeNotifyMessage implements Serializable {

private static final long serialVersionUID = 56781234567890L;

/**
* 全局事务号
*/
private String globalTxNo;

/**
* 充值订单号
*/
private String rechargeNo;

/**
* 用户ID
*/
private Long userId;

/**
* 充值金额
*/
private BigDecimal rechargeAmount;

/**
* 充值状态
*/
private Integer rechargeStatus;
}

7.6 充值服务（recharge-service）完整实现

7.6.1 服务依赖 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.itbaizhan</groupId>
<artifactId>rocketmq-transaction-parent</artifactId>
<version>1.0.0</version>
</parent>

<modelVersion>4.0.0</modelVersion>
<artifactId>recharge-service</artifactId>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-task</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

7.6.2 配置文件 application.yml

server:
port: 9092

spring:
application:
name: recharge–service
datasource:
url: jdbc:mysql://192.168.66.100:3306/tx_recharge_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver

# RocketMQ配置
rocketmq:
name-server: 192.168.66.100:9876
producer:
group: recharge–notify–producer–group

# MybatisPlus配置
mybatis-plus:
mapper-locations: classpath:mapper/*.xml
global-config:
db-config:
id-type: auto

7.6.3 充值业务核心接口与实现

package com.itbaizhan.recharge.service;

import com.itbaizhan.recharge.entity.Recharge;

/**
* 充值业务接口
*/
public interface RechargeService {

/**
* 用户充值业务
* @param userId 用户ID
* @param amount 充值金额
* @return 充值订单号
*/
String userRecharge(Long userId, java.math.BigDecimal amount);

/**
* 根据充值订单号查询充值结果（兜底查询接口）
* @param rechargeNo 充值订单号
* @return 充值订单信息
*/
Recharge getRechargeInfo(String rechargeNo);
}

package com.itbaizhan.recharge.service.impl;

import com.alibaba.fastjson.JSON;
import com.itbaizhan.common.notify.RechargeNotifyMessage;
import com.itbaizhan.recharge.entity.Recharge;
import com.itbaizhan.recharge.entity.NotifyTxLog;
import com.itbaizhan.recharge.mapper.RechargeMapper;
import com.itbaizhan.recharge.mapper.NotifyTxLogMapper;
import com.itbaizhan.recharge.service.RechargeService;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.UUID;

@Slf4j
@Service
public class RechargeServiceImpl implements RechargeService {

@Resource
private RechargeMapper rechargeMapper;

@Resource
private NotifyTxLogMapper notifyTxLogMapper;

@Resource
private RocketMQTemplate rocketMQTemplate;

private static final String RECHARGE_NOTIFY_TOPIC = "recharge_notify_topic";

@Override
@Transactional(rollbackFor = Exception.class)
public String userRecharge(Long userId, java.math.BigDecimal amount) {
// 1. 生成唯一订单号、事务号
String rechargeNo = UUID.randomUUID().replace("-", "");
String globalTxNo = UUID.randomUUID().replace("-", "");

// 2. 新增充值订单，标记充值成功
Recharge recharge = new Recharge();
recharge.setRechargeNo(rechargeNo);
recharge.setUserId(userId);
recharge.setRechargeAmount(amount);
recharge.setRechargeStatus(1);
recharge.setCreateTime(LocalDateTime.now());
rechargeMapper.insert(recharge);

// 3. 新增通知事务日志，初始待通知状态
NotifyTxLog txLog = new NotifyTxLog();
txLog.setTxNo(globalTxNo);
txLog.setRechargeNo(rechargeNo);
txLog.setNotifyStatus(0);
txLog.setNotifyTimes(0);
txLog.setCreateTime(LocalDateTime.now());
notifyTxLogMapper.insert(txLog);

// 4. 封装通知消息，发送MQ
RechargeNotifyMessage message = new RechargeNotifyMessage();
message.setGlobalTxNo(globalTxNo);
message.setRechargeNo(rechargeNo);
message.setUserId(userId);
message.setRechargeAmount(amount);
message.setRechargeStatus(1);

Message<String> mqMessage = MessageBuilder.withPayload(JSON.toJSONString(message)).build();
// 同步发送消息，失败会自动重试
rocketMQTemplate.syncSend(RECHARGE_NOTIFY_TOPIC, mqMessage);

// 5. 更新通知次数、最后通知时间
txLog.setNotifyTimes(1);
txLog.setLastNotifyTime(LocalDateTime.now());
notifyTxLogMapper.updateById(txLog);

log.info("用户充值成功，已发送通知，订单号：{}", rechargeNo);
return rechargeNo;
}

@Override
public Recharge getRechargeInfo(String rechargeNo) {
return rechargeMapper.selectOne(com.baomidou.mybatisplus.core.conditions.query.LambdaQueryChainWrapper
.lambdaQuery(rechargeMapper)
.eq(Recharge::getRechargeNo, rechargeNo)
.getWrapper());
}
}

7.6.4 充值兜底重试定时任务（最大努力核心）

package com.itbaizhan.recharge.task;

import com.alibaba.fastjson.JSON;
import com.itbaizhan.common.notify.RechargeNotifyMessage;
import com.itbaizhan.recharge.entity.NotifyTxLog;
import com.itbaizhan.recharge.entity.Recharge;
import com.itbaizhan.recharge.mapper.NotifyTxLogMapper;
import com.itbaizhan.recharge.service.RechargeService;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;

/**
* 定时重试通知任务：最大努力通知核心
* 定时扫描通知失败、未完成的订单，持续重试推送
*/
@Slf4j
@Component
public class NotifyRetryTask {

@Resource
private NotifyTxLogMapper notifyTxLogMapper;

@Resource
private RechargeService rechargeService;

@Resource
private RocketMQTemplate rocketMQTemplate;

private static final String RECHARGE_NOTIFY_TOPIC = "recharge_notify_topic";
// 最大重试次数
private static final int MAX_RETRY_TIMES = 5;

@Scheduled(cron = "0 */1 * * * ?")
public void retryNotify() {
// 查询待通知、通知失败且未超过最大重试次数的记录
List<NotifyTxLog> waitNotifyList = notifyTxLogMapper.selectList(
com.baomidou.mybatisplus.core.conditions.query.LambdaQueryChainWrapper
.lambdaQuery(notifyTxLogMapper)
.in(NotifyTxLog::getNotifyStatus, 0, 2)
.lt(NotifyTxLog::getNotifyTimes, MAX_RETRY_TIMES)
.getWrapper()
);

if (waitNotifyList == null || waitNotifyList.isEmpty()) {
return;
}

log.info("开始执行充值通知重试，待重试数量：{}", waitNotifyList.size());
for (NotifyTxLog txLog : waitNotifyList) {
try {
// 查询最新充值状态
Recharge recharge = rechargeService.getRechargeInfo(txLog.getRechargeNo());
if (recharge == null) {
continue;
}

// 封装消息重试推送
RechargeNotifyMessage message = new RechargeNotifyMessage();
message.setGlobalTxNo(txLog.getTxNo());
message.setRechargeNo(txLog.getRechargeNo());
message.setUserId(recharge.getUserId());
message.setRechargeAmount(recharge.getRechargeAmount());
message.setRechargeStatus(recharge.getRechargeStatus());

org.springframework.messaging.Message<String> mqMessage =
org.springframework.messaging.support.MessageBuilder.withPayload(JSON.toJSONString(message)).build();
rocketMQTemplate.syncSend(RECHARGE_NOTIFY_TOPIC, mqMessage);

// 更新重试次数与时间
txLog.setNotifyTimes(txLog.getNotifyTimes() + 1);
txLog.setLastNotifyTime(LocalDateTime.now());
notifyTxLogMapper.updateById(txLog);

log.info("充值通知重试成功，订单号：{}，当前重试次数：{}", txLog.getRechargeNo(), txLog.getNotifyTimes());
} catch (Exception e) {
log.error("充值通知重试失败，订单号：{}", txLog.getRechargeNo(), e);
// 标记为通知失败，等待下次重试
txLog.setNotifyStatus(2);
notifyTxLogMapper.updateById(txLog);
}
}
}
}

7.6.5 充值控制层（测试入口+兜底查询接口）

package com.itbaizhan.recharge.controller;

import com.itbaizhan.recharge.entity.Recharge;
import com.itbaizhan.recharge.service.RechargeService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.math.BigDecimal;

@Slf4j
@RestController
@RequestMapping("/recharge")
public class RechargeController {

@Resource
private RechargeService rechargeService;

/**
* 充值测试接口
*/
@GetMapping("/doRecharge")
public String doRecharge(@RequestParam Long userId, @RequestParam BigDecimal amount) {
String rechargeNo = rechargeService.userRecharge(userId, amount);
return "充值成功，充值订单号：" + rechargeNo;
}

/**
* 兜底查询接口，供账户服务主动调用
*/
@GetMapping("/getInfo/{rechargeNo}")
public Recharge getRechargeInfo(@PathVariable String rechargeNo) {
return rechargeService.getRechargeInfo(rechargeNo);
}
}

7.7 账户服务（account-service）完整实现

7.7.1 服务依赖 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.itbaizhan</groupId>
<artifactId>rocketmq-transaction-parent</artifactId>
<version>1.0.0</version>
</parent>

<modelVersion>4.0.0</modelVersion>
<artifactId>account-service</artifactId>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web<span class=\"token

一文搞懂hadoop的HDFS

2026-06-02master阅读(44)

Hadoop介绍

什么是Hadoop

Hadoop是由Apache基金会所开发的分布式系统基础架构，旨在解决海量数据存储和计算分析问题。狭义上来说，Hadoop是指Apache Hadoop开源框架，包含以下三种核心组件：

Hadoop HDFS(Hadoop Distributed File System):分布式文件存储系统，解决海量数据存储问题。
Hadoop Yarn:集群资源管理和任务调度框架，解决资源任务调度问题。
Hadoop MapReduce：分布式计算框架，解决海量数据计算问题。

广义上来说，Hadoop通常是指围绕Hadoop打造的大数据生态圈，部分技术栈如下图: 在这里插入图片描述

zookeeper:分布式协调组件。
HDFS:分布式文件系统。
MapReduce：分布式计算框架。
Hive：分布式数据仓库。
HBase:分布式数据库。
Flume:日志采集框架。
Sqoop：数据导入/导出工具。
pig:工作流引擎。
Mahout:机器学习算法库。
oozie:作业流调度工具。
Ambari:大数据集群管理平台。 Hadoop官网：https://hadoop.apache.org/

大数据技术生态体系

在这里插入图片描述

Hadoop发展历史

Hadoop最初是由Doug Cutting和Mike Cafarella于2002年左右创建的，最早起源于Nutch，其最初的目标是构建一个能够处理大规模数据集的分布式文件处理系统。后期，Doug Cutting以Google的GFS（Google File System）和MapReduce为基础，开发了Hadoop Distributed File System（HDFS）和Hadoop MapReduce。2006年，Hadoop成为Apache软件基金会的顶级项目，开始吸引了越来越多的开发者和用户。以下是Hadoop发展历史中的一些重要时间点，了解即可。

2002年10月，Doug Cutting和Mike Cafarella创建了开源网页爬虫项目Nutch。
2003年10月，Google发表Google File System论文。
2004年7月，Doug Cutting和Mike Cafarella在Nutch中实现了类似GFS的功能，即后来HDFS的前身。
2004年10月，Google发表了MapReduce论文。
2005年2月，Mike Cafarella在Nutch中实现了MapReduce的最初版本。
2005年12月，开源搜索项目Nutch移植到新框架，使用MapReduce和HDFS在20个节点稳定运行。
2006年1月，Doug Cutting加入雅虎，Yahoo!提供一个专门的团队和资源将Hadoop发展成一个可在网络上运行的系统。
2006年2月，Apache Hadoop项目正式启动以支持MapReduce和HDFS的独立发展。
2006年3月，Yahoo!建设了第一个Hadoop集群用于开发。
2006年4月，第一个Apache Hadoop发布。
2006年11月，Google发表了Bigtable论文，激起了Hbase的创建。
2007年10月，第一个Hadoop用户组会议召开，社区贡献开始急剧上升。
2007年，百度开始使用Hadoop做离线处理。
2007年，中国移动开始在“大云”研究中使用Hadoop技术。
2008年，淘宝开始投入研究基于Hadoop的系统——云梯，并将其用于处理电子商务相关数据。
2008年1月，Hadoop成为Apache顶级项目。
2008年2月，Yahoo!运行了世界上最大的Hadoop应用，宣布其搜索引擎产品部署在一个拥有1万个内核的Hadoop集群上。
2008年4月，在900个节点上运行1TB排序测试集仅需209秒，成为世界最快。
2008年8月，第一个Hadoop商业化公司Cloudera成立。
2009 年3月，Cloudera推出世界上首个Hadoop发行版——CDH（Cloudera’s Distribution including Apache Hadoop）平台，完全由开放源码软件组成。
2009年6月，Cloudera的工程师Tom White编写的《Hadoop权威指南》初版出版，后被誉为Hadoop圣经。
2009年7月，Hadoop Core项目更名为Hadoop Common;
2009年7月，MapReduce 和 Hadoop Distributed File System (HDFS) 成为Hadoop项目的独立子项目。
2009年8月，Hadoop创始人Doug Cutting加入Cloudera担任首席架构师。
2009年10月，首届Hadoop World大会在纽约召开。
2010年5月，IBM提供了基于Hadoop 的大数据分析软件——InfoSphere BigInsights，包括基础版和企业版。
2011年3月，Apache Hadoop获得Media Guardian Innovation Awards媒体卫报创新奖
2012年3月，企业必须的重要功能HDFS NameNode HA被加入Hadoop主版本。
2012年8月，另外一个重要的企业适用功能YARN成为Hadoop子项目。
2014年2月，Spark逐渐代替MapReduce成为Hadoop的缺省执行引擎，并成为Apache基金会顶级项目。
2017年12月，Hadoop 3.0.0版本发布，标志着Hadoop的持续发展和创新。

截止到2024年初，Hadoop最新版本为3.3.6版本，整个Hadoop发行版本中经历了Haoop1.x、2.x、3.x系列版本。目前，Hadoop1.x版本已经被淘汰，Hadoop2.x版本相较于1.x版本引入了Yarn平台，Hadoop3.x版本相较于2.x版本做了优化升级，目前企业中使用主流hadoop版本为hadoop3.x版本。此外，Hadoop目前发行版本分为开源社区版和商业版。社区版由Apache软件基金会进行维护，商业版Hadoop则是由第三方商业公司在社区版的基础上做了一些修改、整合，并经过各个服务组件的兼容性测试后发布的版本，其中一些著名的商业版包括Cloudera的CDH、Hortonworks的HDP，2018年，Cloudea收购Hortonworks公司。 ClouderaManager的CDH平台：在这里插入图片描述

Ambari的HDP平台： [图片]

Hadoop优势特点

Hadoop具备如下优势特点:

低成本 Hadoop可以由多台廉价普通机器组成，支持TB和PB级别数据存储，并不需要运行在昂贵且高可靠性的硬件上。
高可靠、容错性 HDFS中数据存储有多副本支持数据高可靠性，即使一些副本出现故障也能保障数据可使用。MapReduce计算过程中任务失败，可以自动进行任务重新分配进行任务重试。此外，HDFS和Yarn都支持高可用配置，当主节点挂掉时，可以自动选主切换，保证集群可靠性。
高扩展性 Hadoop集群可以扩展到上千个节点以支持数据存储和计算，节点多支持数据量大、支持更大并行度的并行计算。
高效性 Hadoop可以并行在节点之间动态移动数据，保证各个节点数据动态平衡；基于MapReduce进行数据处理计算时，可以并行处理数据，效率极高。总之，Hadoop具备高可靠、高容错、高扩展、高效性这些优势在互联网领域中已经得到广泛运用。

HDFS架构核心

HDFS简介

HDFS（Hadoop Distributed File System）是 Apache Hadoop 项目的一个子项目，设计目的是用于存储海量（例如：TB和PB）文件数据，支持高吞吐读写文件并且高度容错。HDFS将多台普通廉价机器组成分布式集群形成分布式文件系统，提供统一的访问接口，用户可以像访问普通文件系统一样来使用HDFS访问文件。

HDFS有如下特点：

HDFS适合处理大规模数据，如：TB和PB，可以处理百万规模以上的文件数量，使用场景是一次写入、多次读取场景。
HDFS将文件线性按字节切分成多个block块进行存储，每个block块默认128M。
每个block块默认有3个副本，提高容错性，如果一个副本丢失不可用，后续可以自动恢复。
HDFS适合大文件写入，不适合大量小文件写入，因为小文件多NameNode要使用更多内存来维护存储文件目录和block信息。此外，读取大量小文件时，文件寻址时间要大于文件读取时间，违反HDFS设计目标。
HDFS不支持并发写入数据，一个文件只能有一个写，不能多个线程同时写。
HDFS数据写入后不支持修改，只支持append追加。 HDFS架构 HDFS是一个主从（Master/Slaves）架构，由一个NameNode和一些DataNode组成，下图是HDFS架构：

以上架构中包含NameNode、SecondaryNameNode、DataNode 、HDFS Client各角色，下面对各个角色作用进行介绍。

NameNode

NameNode就是主从架构中的Master，是HDFS中的管理者。HDFS中数据文件分布式存储在各个DataNode节点上，NameNode维护和管理文件系统元数据（空间目录树结构、文件、Block信息、访问权限），随着存储文件的增多，NameNode上存储的信息越来越多，NameNode主要通过两个组件实现元数据管理：fsimage（命名空间镜像文件）和editslog（编辑日志）。

fsimage：HDFS文件系统元数据的镜像文件，其中包含了HDFS文件系统的所有目录和文件相关信息元数据。
edits：用户操作HDFS的编辑日志文件，存放HDFS文件系统的所有操作事件，文件的所有写操作会被记录到Edits文件中。 fsimage中存储了当前HDFS中文件属性（文件名称、路径、权限关系、副本数、修改、访问时间等），当HDFS启动后，首先会将磁盘中的fsimage加载到内存中，这样可以保证用户HDFS的高效和低延迟。需要注意，fsimage中不记录每个block所在的DataNode信息，这些信息在每次HDFS启动时从DataNode重建，之后DataNode会周期性的通过心跳向NameNode报告block信息。在NameNode运行期间，客户端对HDFS的操作(文件或目录的创建、重命名、删除)日志都会保存在edits文件中，edits文件保存在磁盘中。当NameNode重启时，会将fsimage内容映射到内存中，然后再一条条执行edits文件中的操作就可以恢复到NameNode重启前的状态，做到不丢失数据。总结，NameNode作用如下：

完全基于内存存储文件元数据、目录结构、文件block的映射信息。

提供文件元数据持久化/管理方案。

提供副本放置策略。

处理客户端读写请求。

SecondaryNameNode

随着操作HDFS的数据变多，久而久之就会造成edits文件变的很大，如果namenode重启后再一条条执行edits日志恢复状态就需要很长时间，导致重启速度慢，所以在NameNode运行的时候就需要将editslog和fsimage定期合并。这个合并操作就由SecondaryNameNode负责。所以SecondaryNameNode作用就是辅助NameNode定期合并fsimage和editslog，并将合并后的fsimage推送给NameNode。

DataNode

DataNode是主从架构中的Slave,DataNode存储文件block块，Block在DataNode上以文件形式存储在磁盘上，包括2个文件，一个是数据文件本身，一个是元数据（包括block长度、block校验和、时间戳）。当DataNode启动后会向NameNode进行注册，并汇报block列表信息，后续会周期性（参数dfs.blockreport.intervalMsec决定，默认6小时）向NameNode上报所有的块信息。同时，DataNode会每隔3秒与NameNode保持心跳，如果超过10分钟NameNode没有收到某个DataNode的心跳，则认为该节点不可用。总结，DataNode作用如下：

基于本地磁盘存储block数据块。

保存block的校验和数据保证block的可靠性。

与NameNode保持心跳并汇报block列表信息。

Client

Client是操作HDFS的客户端，作用如下：

与NameNode交互，获取文件block位置信息。

与DataNode交互，读写文件block数据。

文件上传时，负责文件切分成block并上传。

可以通过client访问HDFS进行文件操作或管理HDFS。

fsimage和editslog合并

HDFS 中NameNode管理通过fsimage和editslog来管理集群元数据，SecondaryNameNode会负责定期合并fsimage和editslog，以保证HDFS集群重启后快速恢复到之前状态。

合并流程

[图片]

当HDFS集群首次启动会在NameNode上创建空的fsimage，对HDFS的操作会记录到edits文件中。

当开始进行editslog和fsimage合并时，SecondaryNameNode请求namenode生成新的editslog文件并向其中写日志。

SecondaryNameNode通过HTTP GET的方式从NameNode下载fsimage和edits文件到本地。

SecondaryNameNode将fsimage加载到自己的内存，并根据editslog更新内存中的fsimage信息，然后将更新完毕之后的fsimage写到磁盘上。

SecondaryNameNode通过HTTP PUT将新的fsimage文件发送到NameNode，NameNode将该文件保存为.ckpt的临时文件备用。

NameNode重命名该临时文件并准备使用，此时NameNode拥有一个新的fsimage文件和一个新的很小的editslog文件（可能不是空的，因为在SecondaryNameNode合并期间可能对元数据进行了读写操作）。

后续SecondaryNameNode会按照以上步骤周期性进行editslog和fsimage的合并。

合并时机

默认情况下，SecondaryNameNode每隔1小时执行edits和fsimage合并，通过参数“dfs.namenode.checkpoint.period”进行控制，默认该参数为3600s，即：1小时。 HDFS还会每分钟进行NameNode操作事务数量检查，如果editslog存储的事务(即操作数)到了1000000个也会进行editslog和fsimage的合并。每分钟检查操作事务参数通过dfs.namenode.checkpoint.check.period设置，默认60s，editslog操作数控制参数为dfs.namenode.checkpoint.txns，默认1000000。

安全模式

安全模式工作流程

HDFS启动后的大致工作流程：

启动NameNode，NameNode加载fsimage到内存，对内存数据执行edits log日志中的事务操作。

文件系统元数据内存镜像加载完毕，进行fsimage和edits log日志的合并，并创建新的fsimage文件和一个空的edits log日志文件。

NameNode等待DataNode上传block列表信息，直到副本数满足最小副本条件,这个过程NameNode处于安全模式，最小副本条件指整个文件系统中有99.9%的block达到了最小副本数（默认值是1，可设置）。

当满足了最小副本条件，再过30秒，NameNode就会退出安全模式。

在NameNode安全模式（safemode）下，操作HDFS有如下特点：

对文件系统元数据进行只读操作。

当文件的所有block信息具备的情况下，对文件进行只读操作。不允许进行文件修改（写，删除或重命名文件）。

注意事项

NameNode不会持久化block位置信息，DataNode保有各自存储的block列表信息。正常操作时，NameNode在内存中有一个blocks位置的映射信息（所有文件的所有文件块的位置映射信息）。 NameNode在安全模式，DataNode需要上传block列表信息到NameNode。在安全模式NameNode不会要求DataNode复制或删除block。新格式化的HDFS不进入安全模式，因为DataNode压根就没有block。

配置信息

属性名称类型默认值描述

dfs.namenode.replication.min	int	1	写入文件成功的最小副本数
dfs.namenode.replication.min	float	0.999	系统中block达到了最小副本数的比例，之后NameNode会退出安全模式。
dfs.namenode.safemode.extension	int	30000ms	系统满足了最小副本条件后再过多久退出安全模式

命令操作

通过以下命令查看namenode是否处于安全模式：

hdfs dfsadmin -safemode get

HDFS的前端webUI页面也可以查看NameNode是否处于安全模式，有时候我们希望等待安全模式退出，之后进行文件的读写操作，尤其是在脚本中，此时可以执行命令：

hdfs dfsadmin -safemode wait

当然，以上这个命令不会经常使用，更多的是集群正常启动后会自动退出安全模式。管理员有权在任何时间让namenode进入或退出安全模式，进入安全模式命令如下：

hdfs dfsadmin -safemode enter

以上命令可以让namenode一直处于安全模式，离开安全模式命令如下：

hdfs dfsadmin -safemode leave

Block及副本存放策略

Block块

HDFS存储文件数据时会将文件切分成block，block大小由参数dfs.blocksize决定，在Hadoop1.x中block大小默认为64M ，在Hadoop2.x/3.x中每个block默认大小为128M。 HDFS中块大小不能设置太大，也不能设置太小。如果块设置太大会导致读取block时从磁盘传输数据的时间明显大于寻址时间，导致程序处理数据时变的非常慢；如果块设置过小，大量的块会占用NameNode大量内存来存储元数据，而NameNode内存有限，另一方面，文件块过小会导致寻址时间增大，导致程序一直在找block的开始位置。在HDFS中平均查找block的寻址时间为10ms，经过测试，block文件寻址时间为block传输时间的1%时机器性能最佳，即block传输时间为1s（10ms/0.01=1000ms=1s）时机器性能最佳，目前磁盘的传输速率普遍为100MB/s，计算出最佳block大小为100M（100MB/s*1s=100MB），由于在计算机领域，计算机使用的是二进制系统，而2的幂次方在二进制系统中具有简单而高效的表示方式，使用这些大小的数据更为方便，如：2的7次方是128，2的8次方是256，以此类推。所以block没有设置为100M，而是设置为了128M。所以HDFS中块大小的设置主要取决于磁盘的传输速率，在实际生产中，如果磁盘传输速率为200MB/s时，一般设置block的大小为256M，如果磁盘传输速率为400MB/s时，一般设置block大小为512M。此外，需要注意如果一个文件本身是1KB，上传到HDFS中就对应1个Block，该Block大小实际占用1KB，即：Block大小默认128M表示存储一份数据的分片上限大小，一个文件大于128M会切分成多个block进行存储。

Block副本放置策略

HDFS中每个block块有3副本，由参数dfs.replication决定。三个副本会按照副本放置策略进行存储，如下图所示就是一个block有3副本存储情况。 [图片]

第一个副本：放置在上传文件的DataNode，也就是Client所在节点上；如果是集群外提交，则随机挑选一台磁盘不太满，CPU不太忙的节点。第二个副本：放置在与第一个副本不同的机架的节点上。第三个副本：与第二个副本相同机架的随机节点。更多副本：随机节点存放。

读写流程

HDFS写文件流程

[图片]

客户端会创建DistributedFileSystem对象，DistributedFileSystem会发起对namenode的一个RPC连接，请求创建一个文件，不包含关于block块的请求。namenode会执行各种各样的检查，确保要创建的文件不存在，并且客户端有创建文件的权限。如果检查通过，namenode会创建一个文件（在edits中，同时更新内存状态），否则创建失败，客户端抛异常IOException。

NN在文件创建后，返回给HDFS Client可以开始上传文件块。

DistributedFileSystem返回一个FSDataOutputStream对象给客户端用于写数据。FSDataOutputStream封装了一个DFSOutputStream对象负责客户端跟datanode以及namenode的通信。

客户端中的FSDataOutputStream对象将数据切分为小的packet数据包（64kb，core-default.xml：file.client-write-packet-size默认值65536），并写入到一个内部队列（“数据队列”）。DataStreamer会读取其中内容，并请求namenode返回一个datanode列表来存储当前block副本。列表中的datanode会形成管线，DataStreamer将数据包发送给管线中的第一个datanode，第一个datanode将接收到的数据发送给第二个datanode，第二个发送给第三个，依次类推。

FSDataOutputStream维护着一个数据包的队列，这的数据包是需要写入到datanode中的，该队列称为确认队列。当一个数据包在管线中所有datanode中写入完成，就从ack队列中移除该数据包。如果在数据写入期间datanode发生故障，则执行以下操作

当block传输完成，DN会向NN汇报block信息，同时Client继续传输下一个block，如果有多个block，则会反复从步骤4开始执行。

当客户端完成了数据的传输，调用数据流的close方法。该方法将数据队列中的剩余数据包写到datanode的管线并等待管线的确认。

客户端收到管线中所有正常datanode的确认消息后，通知namenode文件写入成功。

HDFS读文件流程

[图片]

客户端通过FileSystem对象的open方法打开希望读取的文件，DistributedFileSystem对象通过RPC调用namenode，以确保文件起始位置。对于每个block，namenode返回存有该副本的datanode地址。这些datanode根据它们与客户端的距离来排序。如果客户端本身就是一个datanode，并保存有相应block一个副本，会从本地读取这个block数据。

DistributedFileSystem返回一个FSDataInputStream对象给客户端读取数据。该对象管理着datanode和namenode的I/O，用于给客户端使用。客户端对这个输入调用read方法，存储着文件起始几个block的datanode地址的DFSInputStream连接距离最近的datanode。通过对数据流反复调用read方法，可以将数据从datnaode传输到客户端。到达block的末端时，DFSInputSream关闭与该datanode的连接，然后寻找下一个block的最佳datanode。客户端只需要读取连续的流，并且对于客户端都是透明的。

客户端从流中读取数据时，block是按照打开DFSInputStream与datanode新建连接的顺序读取的。它也会根据需要询问namenode来检索下一批数据块的datanode的位置。一旦客户端完成读取，就close掉FSDataInputStream的输入流。

在读取数据的时候如果DFSInputStream在与datanode通信时遇到错误，会尝试从这个块的一个最近邻datanode读取数据。同时也记住故障datanode，保证以后不会反复读取该节点上后续的block。DFSInputStream也会通过校验和确认从datanode发来的数据是否完整。如果发现有损坏的块，DFSInputStream会尝试从其他datanode读取其副本并通知namenode。

Client下载完block后会验证DN中的MD5，保证块数据的完整性。

HDFS集群搭建与操作

节点基础环境准备

搭建真正分布式HDFS集群至少需要3台Linux节点，这里准备5台Linux节点（这里我们使用的是VMWare虚拟机安装的centos7，也可以直接使用云服务器），节点名称和ip信息如下:

节点IP节点名称

192.168.179.4	node1
192.168.179.5	node2
192.168.179.6	node3
192.168.179.7	node4
192.168.179.8	node5

这里默认已经创建好以上各个节点，并且每个节点分配资源为4核2G内存，建议每台节点至少给到2核2G，否则可能一些组件不能正常运行问题。下面对这5个节点进行基础配置。

配置各个节点的ip

启动每台节点，在对应的节点路径“/etc/sysconfig/network-scripts”下配置ifg-ens33文件配置IP（注意，不同机器可能此文件名称不同，一般以ifcfg-xxx命名），以配置ip 192.168.179.4为例，ifcfg-ens33配置内容如下：

TYPE=Ethernet
BOOTPROTO=static #使用static配置
DEFROUTE=yes
PEERDNS=yes
PEERROUTES=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_PEERDNS=yes
IPV6_PEERROUTES=yes
IPV6_FAILURE_FATAL=no
ONBOOT=yes #开机启用本配置
IPADDR=192.168.179.4 #静态IP
GATEWAY=192.168.179.2 #默认网关
NETMASK=255.255.255.0 #子网掩码
DNS1=192.168.179.2 #DNS配置可以与默认网关相同

以上其他节点配置只需要修改对应的ip即可，配置完成后，在每个节点上执行如下命令重启网络服务：

systemctl restart network.service

配置主机名

在每台节点上修改/etc/hostname,配置对应的主机名称，参照节点IP与节点名称对照表分别为：node1、node2、node3、node4、node5。配置完成后需要重启各个节点，才能正常显示各个主机名。关于Centos hostname配置有如下几点建议：

hostname只允许包含ascii字符里的数字0-9，字母a-zA-Z，连字符-和.，其他都不允许。例如，不允许出现其他标点符号，不允许空格，不允许下划线，不允许中文字符。
hostanme开头和结尾字符不允许是连字符。
hostanme强烈建议不要用数字开头，尽管这一条不是强制的。
hostanme建议用小写字母而不用大写字母。

关闭防火墙

执行如下命令确定各个节点上的防火墙开启情况，需要将各个节点上的防火墙关闭：

#检查防火墙状态
firewall-cmd –state

#临时关闭防火墙（重新开机后又会自动启动）
systemctl stop firewalld 或者systemctl stop firewalld.service

#设置开机不启动防火墙
systemctl disable firewalld

关闭SELinux

SELinux就是Security-Enhanced Linux的简称，安全加强的linux。传统的linux权限是对文件和目录的owner, group和other的rwx进行控制，而SELinux采用的是委任式访问控制，也就是控制一个进程对具体文件系统上面的文件和目录的访问，SELinux规定了很多的规则，来决定哪个进程可以访问哪些文件和目录。虽然SELinux很好用，但是在多数情况我们还是将其关闭，因为在不了解其机制的情况下使用SELinux会导致软件安装或者应用部署失败。在每台节点/etc/selinux/config中将SELINUX=enforcing改成SELINUX=disabled即可。

配置阿里云yum源

后续为了方便在Linux节点上安装各个软件，我们将yum源改成国内阿里云yum源，这样下载软件速度快一些，每个节点具体操作按照以下步骤进行：

#安装wget，wget是linux最常用的下载命令(有些系统默认安装，可忽略)
yum -y install wget

#备份当前的yum源
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

#下载阿里云的yum源配置
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo

#清除原来文件缓存，构建新加入的repo结尾文件的缓存
yum clean all
yum makecache

配置完成后，可以在每台节点上安装“vim”命令，方便后续操作：

#在各个节点上安装 vim命令
yum -y install vim

设置Linux 系统显示中文/英文

#查看当前系统语言
echo $LANG
#显示结果如下，说明默认支持显示英文
en_US.UTF-8

#临时修改系统语言为中文，重启节点后恢复英文
LANG="zh_CN.UTF-8"

#如果想要永久修改系统默认语言为中文，需要创建/修改/etc/locale.conf文件,写入以下内容，设置完成后需要重启各节点。
LANG="zh_CN.UTF-8"

设置自动更新时间

后续基于Linux各个节点搭建HDFS时，需要各节点的时间同步，可以通过设置各个节点自动更新时间来保证各个节点时间一致，具体按照以下操作来执行：

修改本地时区及ntp服务

yum -y install ntp
rm -rf /etc/localtime
ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
/usr/sbin/ntpdate -u pool.ntp.org

自动同步时间设置定时任务，每10分钟同步一次，配置/etc/crontab文件，实现自动执行任务。建议直接crontab -e 来写入定时任务。使用crontab -l 查看当前用户定时任务。

#各个节点执行 crontab -e 写入以下内容
*/10 * * * * /usr/sbin/ntpdate -u pool.ntp.org >/dev/null 2>&1

#重启定时任务
service crond restart

#查看日期
date

设置各个节点之间的ip映射

每个节点都有自己的IP和主机名，各个节点默认进行文件传递或通信时需要使用对应的ip进行通信，后续为了方便各个节点之间的通信和文件传递，可以配置各个节点名称与ip之间的映射，节点之间通信时可以直接写对应的主机名称，不必写复杂的ip。每台节点具体操作按照以下操作进行。进入每台节点的/etc/hosts下，修改hosts文件，vim /etc/hosts:

#在文件后面追加以下内容
192.168.179.4 node1
192.168.179.5 node2
192.168.179.6 node3
192.168.179.7 node4
192.168.179.8 node5

各个节点配置完成后，可以使用ping命令互相测试使用节点名称是否可以正常通信。

[root@node5 ~]# ping node1
PING node1 (192.168.179.4) 56(84) bytes of data.
64 bytes from node1 (192.168.179.4): icmp_seq=1 ttl=64 time=0.892 ms
64 bytes from node1 (192.168.179.4): icmp_seq=2 ttl=64 time=0.415 ms
... ...

配置节点之间免密访问

后续搭建HDFS集群时需要Linux各个节点之间免密，节点两两免秘钥的根本原理如下：假设A节点需要免秘钥登录B节点，只要B节点上有A节点的公钥，那么A节点就可以免密登录当前B节点。具体操作步骤如下:

安装ssh客户端需要在每台节点上安装ssh客户端，否则，不能使用ssh命令（最小化安装Liunx，默认没有安装ssh客户端），这里在Centos7系统中默认已经安装，此步骤可以省略：

yum -y install openssh-clients

创建.ssh目录在每台节点执行如下命令，在每台节点的“~”目录下，创建.ssh目录，注意，不要手动创建这个目录，因为有权限问题。

cd ~
ssh localhost
#这里会需要输入节点密码#
exit

配置各节点向一台节点通信免密在每台节点上执行如下命令，给当前节点创建公钥和私钥：

ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa

将node1、node2、node3、node4、node5的公钥copy到node1上，这样这五台节点都可以免密登录到node1。命令如下：

#在node1上执行如下命令，需要输入密码ssh-copy-id node1 #会在当前~/.ssh目录下生成authorized_keys文件，文件中存放当前node1的公钥#

#在node2上执行如下命令，需要输入密码ssh-copy-id node1 #会将node2的公钥追加到node1节点的authorized_keys文件中

#在node3上执行如下命令，需要输入密码ssh-copy-id node1 #会将node3的公钥追加到node1节点的authorized_keys文件中

#在node4上执行如下命令，需要输入密码ssh-copy-id node1 #会将node4的公钥追加到node1节点的authorized_keys文件中

#在node5上执行如下命令，需要输入密码ssh-copy-id node1 #会将node5的公钥追加到node1节点的authorized_keys文件中

各节点免密将node1节点上_{/.ssh/authorized_keys拷贝到node2、node3、node4、node5各节点的}/.ssh/目录下，执行如下命令：

scp ~/.ssh/authorized_keys node2:`pwd`
scp ~/.ssh/authorized_keys node3:`pwd`
scp ~/.ssh/authorized_keys node4:`pwd`
scp ~/.ssh/authorized_keys node5:`pwd

以上node1向各个节点发送文件时需要输入密码，经过以上步骤，节点两两免密完成。

Hadoop集群运行模式

可以参考Hadoop官网进行Hadoop集群搭建，目前Hadoop集群搭建有三种模式：

本地模式：单机运行，只能单机测试MapReduce运行任务，生产和测试都不会使用。
伪分布式模式：单机运行，一台节点部署所有Hadoop角色，模拟分布式集群环境，具备Hadoop集群所有功能，生产和测试一般不会使用。
完全分布式模式：多台服务器部署Hadoop集群，各个角色分布到不同节点上执行，生产和测试环境中经常使用。

HDFS伪分布式集群搭建

安装JDK

按照以下步骤在node1节点上安装JDK8。

在node1节点创建/software目录，上传并安装jdk8 rpm包

rpm -ivh /software/jdk-8u181-linux-x64.rpm

以上命令执行完成后，会在每台节点的/user/java下安装jdk8。 2. 配置jdk环境变量在node1节点上配置jdk的环境变量：

export JAVA_HOME=/usr/java/jdk1.8.0_181-amd64
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

以上配置完成后，最后执行“source /etc/profile”使配置生效。

HDFS伪分布式集群搭建

这里我们在 node1节点上进行HDFS伪分布式集群搭建，按照如下步骤进行搭建即可。

下载安装包并解压我们安装Hadoop3.3.6版本，搭建HDFS集群前，首先需要在官网下载安装包，地址如下：https://hadoop.apache.org/releases.html。下载完成安装包后，上传到node1节点的/software目录下并解压到opt目录下。

#将下载好的hadoop安装包上传到node1节点上
[root@node1 ~]# ls /software/
hadoop-3.3.6.tar.gz

#将安装包解压到/opt目录下
[root@node1 ~]# cd /software/
[root@node1 software]# tar -zxvf ./hadoop-3.3.6.tar.gz -C /opt

解压之后可以看到Hadoop安装包内容如下：

[root@node1 hadoop-3.3.6]# ll
bin
etc
include
lib
libexec
LICENSE-binary
licenses-binary
LICENSE.txt
logs
NOTICE-binary
NOTICE.txt
README.txt
sbin
share

以上Hadoop解压文件重要目录解释如下:

bin目录：Hadoop最基本的管理脚本和使用脚本的目录，用户可以直接使用这些脚本管理和使用Hadoop。
etc目录：Hadoop配置文件所在的目录，包括core-site,xml、hdfs-site.xml、mapred-site.xml、yarn-site.xml、works等。
include：对外提供的编程库头文件，这些头文件均是用C++定义的，通常用于C++程序访问HDFS或者编写MapReduce程序。
lib目录：lib目录包含了Hadoop对外提供的编程动态库和静态库，与include目录中的头文件结合使用。
sbin目录：Hadoop管理脚本所在的目录，主要包含HDFS和YARN中各类服务的启动/关闭脚本。
share目录：存放Hadoop的依赖jar包、文档、和官方案例，对HDFS 操作依赖的jar包都在这里。

在node1节点上配置Hadoop的环境变量

[root@node1 software]# vim /etc/profile
export HADOOP_HOME=/software/hadoop-3.3.6/
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:

#使配置生效
source /etc/profile

配置hadoop-env.sh 启动伪分布式HDFS集群时会判断$HADOOP_HOME/etc/hadoop/hadoop-env.sh文件中是否配置JAVA_HOME，所以需要在hadoop-env.sh文件加入以下配置（大概在54行有默认注释配置的JAVA_HOME）:

#vim /software/hadoop-3.3.6/etc/hadoop/hadoop-env.sh
export JAVA_HOME=/usr/java/jdk1.8.0_181-amd64/

配置core-site.xml 进入 $HADOOP_HOME/etc/hadoop路径下，修改core-site.xml文件，指定HDFS集群数据访问地址及集群数据存放路径。

#vim /software/hadoop-3.3.6/etc/hadoop/core-site.xml
<configuration><!– 指定NameNode的地址 –><property><name>fs.defaultFS</name><value>hdfs://node1:8020</value></property><!– 指定 Hadoop 数据存放的路径 –><property><name>hadoop.tmp.dir</name><value>/opt/data/local_hadoop</value></property></configuration>

配置hdfs-site.xml 进入 $HADOOP_HOME/etc/hadoop路径下，修改hdfs-site.xml文件，指定NameNode和SecondaryNameNode节点和端口。

#vim /software/hadoop-3.3.6/etc/hadoop/hdfs-site.xml
<configuration><!– 指定block副本数–><property><name>dfs.replication</name><value>1</value></property><!– NameNode WebUI访问地址–><property><name>dfs.namenode.http-address</name><value>node1:9870</value></property><!– SecondaryNameNode WebUI访问地址–><property><name>dfs.namenode.secondary.http-address</name><value>node1:9868</value></property></configuration>

配置workers指定DataNode节点进入 $HADOOP_HOME/etc/hadoop路径下，修改workers配置文件，加入以下内容：

#vim /software/hadoop-3.3.6/etc/hadoop/workers
node1

配置start-dfs.sh&stop-dfs.sh 进入 $HADOOP_HOME/sbin路径下，在start-dfs.sh和stop-dfs.sh文件顶部添加操作HDFS的用户为root，防止启动错误。

#分别在start-dfs.sh 和stop-dfs.sh文件顶部添加如下内容HDFS_NAMENODE_USER=root
HDFS_DATANODE_USER=root
HDFS_SECONDARYNAMENODE_USER=root

格式化并启动HDFS集群

HDFS完全分布式集群搭建完成后，首次使用需要进行格式化，在NameNode节点（node1）上执行如下命令：

#在node1节点上格式化集群
[root@node1 ~]# hdfs namenode -format```
格式化集群完成后就可以在node1节点上执行如下命令启动集群：
```Plain Text
#在node1节点上启动集群
[root@node1 ~]# start-dfs.sh

至此，Hadoop完全分布式搭建完成，可以浏览器访问HDFS WebUI界面，通过此界面方便查看和操作HDFS集群。WebUI访问地址如下，在Hadoop2.x版本中，访问的WEBUI端口为50070,Hadoop3.x 访问WebUi端口是9870。 NameNode WebUI访问地址为：http://node1:9870，需要在window中配置hosts。

在这里插入图片描述

SecondaryNameNode WebUI访问地址为:http://node1:9868

在这里插入图片描述

停止集群时只需要在NameNode节点上执行stop-dfs.sh命令即可。后续再次启动HDFS集群只需要在NameNode节点执行start-dfs.sh命令，不需要再次格式化集群。

查看集群目录

查看NameNode数据目录可以在hdfs-site.xml中配置“dfs.namenode.name.dir”属性来指定NameNode存储数据的目录，默认NameNode数据存储在${hadoop.tmp.dir}/dfs/name目录，进入“/opt/data/local_hadoop/dfs/name/current”查看相应NameNode存储数据信息：

[root@node1 ~]# ll /opt/data/local_hadoop/dfs/name/current
edits_0000000000000000001-0000000000000000002
edits_inprogress_0000000000000000003
fsimage_0000000000000000000
fsimage_0000000000000000000.md5
seen_txid
VERSION

一个运行的NameNode如下的目录结构，该目录结构在第一次格式化的时候创建。

[图片]

in_use.lock文件用于NameNode锁定存储目录。这样就防止其他同时运行的NameNode实例使用相同的存储目录。
edits表示edits log日志文件。
fsimage表示文件系统元数据镜像文件。
seen_txid记录edits操作编号，NameNode在checkpoint之前首先要切换新的edits log文件，在切换时更新seen_txid的值。上次合并fsimage和editslog之后的第一个操作编号。
VERSION文件是一个Java的属性文件。

[图片]

layoutVersion是一个负数，定义了HDFS持久化数据结构的版本。这个版本数字跟hadoop发行的版本无关。当layout改变的时候，该数字减1（比如从-57到-58）。当对HDFDS进行了升级，就会发生layoutVersion的改变。
namespaceID是该文件系统的唯一标志符，当NameNode第一次格式化的时候生成。
clusterID是HDFS集群使用的一个唯一标志符，在HDFS联邦的情况下，就看出它的作用了，因为联邦情况下，集群有多个命名空间，不同的命名空间由不同的NameNode管理。
blockpoolID是block池的唯一标志符，一个NameNode管理一个命名空间，该命名空间中的所有文件存储的block都在block池中。
cTime标记着当前NameNode创建的时间。对于刚格式化的存储，该值永远是0，但是当文件系统更新的时候，这个值就会更新为一个时间戳。
storageType表示当前目录存储NameNode内容的数据结构。

查看SecondaryNameNode数据目录可以在hdfs-site.xml中配置“dfs.namenode.checkpoint.dir”属性来指定SecondaryNameNode存储数据的目录，默认SecondaryNameNode数据存储在${hadoop.tmp.dir}/dfs/namesecondary目录，进入“/opt/data/local_hadoop/dfs/namesecondary/current”查看相应SecondaryNameNode存储数据信息：

[root@node1 ~]# ll /opt/data/local_hadoop/dfs/namesecondary/current
edits_0000000000000000001-0000000000000000002
fsimage_0000000000000000000
fsimage_0000000000000000000.md5
fsimage_0000000000000000002
fsimage_0000000000000000002.md5
VERSION

SecondaryNameNode数据目录主要是定期对NameNode中edits和fsimage进行合并，然后将合并数据推送给NameNode。 3. 查看DataNode数据目录可以在hdfs-site.xml中配置“dfs.datanode.data.dir”属性来指定DataNode存储数据的目录，默认NameNode数据存储在${hadoop.tmp.dir}/dfs/data目录，进入“/opt/data/local_hadoop/dfs/data/current”查看相应DataNode存储Block数据信息：

[root@node1 ~]# ll /opt/data/local_hadoop/dfs/data/current
BP-1620277224-192.168.179.4-1705932038786
VERSION

DataNode关键文件和目录结构如下： [图片]

HDFS块数据存储于blk_前缀的文件中，包含了被存储文件原始字节数据的一部分。
每个block文件都有一个.meta后缀的元数据文件关联。该文件包含了一个版本和类型信息的头部，后接该block中每个部分的校验和。
每个block属于一个block池，每个block池有自己的存储目录，该目录名称就是该池子的ID（跟NameNode的VERSION文件中记录的block池ID一样）。
当一个目录中的block达到64个的时候，DataNode会创建一个新的子目录来存放新的block和它们的元数据。这样即使当系统中有大量的block的时候，目录树也不会太深。同时也保证了在每个目录中文件的数量是可管理的，避免了多数操作系统都会碰到的单个目录中的文件个数限制（几十几百上千个）。
如果dfs.datanode.data.dir指定了位于在不同的硬盘驱动器上的多个不同的目录，则会通过轮询的方式向目录中写block数据。需要注意的是block的副本不会在同一个DataNode上复制，而是在不同的DataNode节点之间复制。

HDFS完全分布式集群搭建

节点规划

在前面课程中，我们知道Hadoop集群中有Namenode，SecondaryNameNode，DataNode各个角色，这里我们需要搭建HDFS完全分布式集群，在我们现有Linux集群中节点对应角色划分如下：在这里插入图片描述

安装JDK

同上，需要各个节点都按照jdk

HDFS完全分布式集群搭建

下载安装包并解压我们安装Hadoop3.3.6版本，此版本目前是比较新的版本，搭建HDFS集群前，首先需要在官网下载安装包，地址如下：https://hadoop.apache.org/releases.html。下载完成安装包后，上传到node1节点的/software目录下并解压，没有此目录，可以先创建此目录。

#将下载好的hadoop安装包上传到node1节点上
[root@node1 ~]# ls /software/
hadoop-3.3.6.tar.gz

[root@node1 ~]# cd /software/
[root@node1 software]# tar -zxvf ./hadoop-3.3.6.tar.gz

在node1节点上配置Hadoop的环境变量

[root@node1 software]# vim /etc/profile
export HADOOP_HOME=/software/hadoop-3.3.6/
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:
#使配置生效
source /etc/profile

配置hadoop-env.sh

由于通过SSH远程启动进程的时候默认不会加载/etc/profile设置，JAVA_HOME变量就加载不到，而Hadoop启动需要读取到JAVA_HOME信息，所有这里需要手动指定。在对应的$HADOOP_HOME/etc/hadoop路径中，找到hadoop-env.sh文件加入以下配置（大概在54行有默认注释配置的JAVA_HOME）:

#vim /software/hadoop-3.3.6/etc/hadoop/hadoop-env.sh
export JAVA_HOME=/usr/java/jdk1.8.0_181-amd64/

配置core-site.xml

进入 $HADOOP_HOME/etc/hadoop路径下，修改core-site.xml文件，指定HDFS集群数据访问地址及集群数据存放路径。

#vim /software/hadoop-3.3.6/etc/hadoop/core-site.xml
<configuration>
<!– 指定HDFS文件系统访问URI –>
<property>
<name>fs.defaultFS</name>
<value>viewfs://ClusterX</value>
</property>

<!– 将 /data 目录挂载到 viewfs 中，并通过NN1集群进行管理–>
<property>
<name>fs.viewfs.mounttable.ClusterX.link./data</name>
<value>hdfs://node1:8020/data</value>
</property>

<!– 将 /project 目录挂载到 viewfs 中，并通过NN1集群进行管理–>
<property>
<name>fs.viewfs.mounttable.ClusterX.link./project</name>
<value>hdfs://node1:8020/project</value>
</property>

<!– 将 /user 目录挂载到 viewfs 中，并通过NN2集群进行管理–>
<property>
<name>fs.viewfs.mounttable.ClusterX.link./user</name>
<value>hdfs://node2:8020/user</value>
</property>

<!– 将 /tmp 目录挂载到 viewfs 中，并通过NN2集群进行管理–>
<property>
<name>fs.viewfs.mounttable.ClusterX.link./tmp</name>
<value>hdfs://node2:8020/tmp</value>
</property>

<!– 对于没有配置的路径存放在 /home目录并挂载到 viewfs 中，并通过NN2集群进行管理–>
<property>
<name>fs.viewfs.mounttable.ClusterX.linkFallback</name>
<value>hdfs://node2:8020/home</value>
</property>

<!– 指定 Hadoop 数据存放的路径 –>
<property>
<name>hadoop.tmp.dir</name>
<value>/opt/data/hadoop/federation</value>
</property>
</configuration>

以上配置就是配置将不同数据目录交由不同的HDFS集群进行管理以减少元数据所占NN空间，并将各个目录挂载到viewfs中方便统一访问。

配置hdfs-site.xml

进入 $HADOOP_HOME/etc/hadoop路径下，修改hdfs-site.xml文件，指定NameNode和SecondaryNameNode节点和端口。在Hadoop Federation联邦中需要指定多个NN及相应SNN地址。

#vim /software/hadoop-3.3.6/etc/hadoop/hdfs-site.xml
<configuration>
<!– block副本数 –>
<property>
<name>dfs.replication</name>
<value>3</value>
</property>

<!– 指定两个NS –>
<property>
<name>dfs.nameservices</name>
<value>ns1,ns2</value>
</property>

<!– NS1 NameNode 地址和端口号–>
<property>
<name>dfs.namenode.rpc-address.ns1</name>
<value>node1:8020</value>
</property>

<!– NS1 NameNode WebUI访问地址–>
<property>
<name>dfs.namenode.http-address.ns1</name>
<value>node1:9870</value>
</property>

<!– NS1 SecondaryNameNode WebUI访问地址–>
<property>
<name>dfs.namenode.secondary.http-address.ns1</name>
<value>node3:9868</value>
</property>

<!– NS2 NameNode 地址和端口号–>
<property>
<name>dfs.namenode.rpc-address.ns2</name>
<value>node2:8020</value>
</property>

<!– NS2 NameNode WebUI访问地址–>
<property>
<name>dfs.namenode.http-address.ns2</name>
<value>node2:9870</value>
</property>

<!– NS2 SecondaryNameNode WebUI访问地址–>
<property>
<name>dfs.namenode.secondary.http-address.ns2</name>
<value>node4:9868</value>
</property>
</configuration>

配置workers指定DataNode节点

进入 $HADOOP_HOME/etc/hadoop路径下，修改workers配置文件，加入以下内容：

#vim /software/hadoop-3.3.6/etc/hadoop/workers
node3
node4
node5

配置start-dfs.sh&stop-dfs.sh

进入 $HADOOP_HOME/sbin路径下，在start-dfs.sh和stop-dfs.sh文件顶部添加操作HDFS的用户为root，防止启动错误。

#分别在start-dfs.sh 和stop-dfs.sh文件顶部添加如下内容

HDFS_NAMENODE_USER=root HDFS_DATANODE_USER=root HDFS_SECONDARYNAMENODE_USER=root

分发安装包

将node1节点上配置好的hadoop安装包发送到node2~node5节点上。这里由于Hadoop安装包比较大，也可以先将原有hadoop安装包上传到其他节点解压，然后在node1节点上只分发hfds-site.xml 、core-site.xml文件即可。

#在node1节点上执行如下分发命令

[root@node1 ~]# cd /software/
[root@node1 software]# scp -r ./hadoop-3.3.6/ node2:/software/
[root@node1 software]# scp -r ./hadoop-3.3.6/ node3:/software/
[root@node1 software]# scp -r ./hadoop-3.3.6/ node4:/software/
[root@node1 software]# scp -r ./hadoop-3.3.6/ node5:/software/

在node2、node3、node4、node5节点上配置HADOOP_HOME

#分别在node2、node3、node4、node5节点上配置HADOOP_HOME
vim /etc/profile
export HADOOP_HOME=/software/hadoop-3.3.6/
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:

#最后记得Source
source /etc/profile

格式化并启动HDFS集群

HDFS完全分布式集群搭建完成后，首次使用需要进行格式化，在NameNode节点（node1）上执行如下命令：

#在node1节点上格式化集群
[root@node1 ~]# hdfs namenode -format

格式化集群完成后就可以在node1节点上执行如下命令启动集群：

#在node1节点上启动集群
[root@node1 ~]# start-dfs.sh

至此，Hadoop完全分布式搭建完成，可以浏览器访问HDFS WebUI界面，通过此界面方便查看和操作HDFS集群。WebUI访问地址如下，在Hadoop2.x版本中，访问的WEBUI端口为50070,Hadoop3.x 访问WebUi端口是9870。

NameNode WebUI访问地址为：http://node1:9870，需要在window中配置hosts。停止集群时只需要在NameNode节点上执行stop-dfs.sh命令即可。后续再次启动HDFS集群只需要在NameNode节点执行start-dfs.sh命令，不需要再次格式化集群。

HDFS集群搭建注意点

在搭建和使用HDFS集群中需要注意如下点：

HDFS伪分布式集群只是测试，HDFS完全分布式是重点，需要掌握HDFS完全分布式搭建。
如果在集群搭建过程中出现错误需要重新格式化集群时，那么需要删除相关配置文件中指定的目录后，再次格式化，不删除先前集群数据目录会导致新的集群格式化不成功或者使用时有问题。
无论是伪分布式还是完全分布式集群搭建，格式化集群只需要在集群搭建完成后第一次启动时执行，后续使用HDFS集群不需要格式化，只需要执行start-dfs.sh/stop-dfs.sh 启停集群即可。
window访问HDFS集群时，如果使用别名而非IP访问，需要在windows “C:\\Windows\\System32\\drivers\\etc\\hosts”文件中配置ip和别名映射。

HDFS shell操作

基于xshell来操作HDFS时，可以使用HADOOP_HOME/bin/hadoopfs具体命令或者使用HADOOP_HOME/bin/hdfs dfs 具体命令，其中fs也可以使用dfs命令代替，dfs是fs的实现类。 hadoop fs 命令执行后，可以查看操作HDFS用法： [图片]

hadoop fs 命令等价于hdfs dfs ，都可以操作HDFS。 [图片]

下面介绍HDFS中常用的一些操作命令。 help help主要是查看命令的帮助。

[root@node1 ~]# hdfs dfs -help
Usage: hadoop fs [generic options]
[-appendToFile [-n] <localsrc> … <dst>]
[-cat [-ignoreCrc] <src> …]
[-checksum [-v] <src> …]
[-chgrp [-R] GROUP PATH…]
[-chmod [-R] <MODE[,MODE]… | OCTALMODE> PATH…]
[-chown [-R] [OWNER][:[GROUP]] PATH…]
[-concat <target path> <src path> <src path> …]
… …

-ls -ls：主要显示目录信息，查看HDFS中某个目录下的文件信息。

[root@node1 ~\\]# hdfs dfs -ls

-mkdir -mkdir 在HDFS中创建目录，还可跟上-p来创建多级目录。

[root@node1 ~]# hdfs dfs -mkdir /hello
[root@node1 ~]# hdfs dfs -mkdir /hello/a/b/cmkdir: `/hello/a/b/c': No such file or directory
[root@node1 ~]# hdfs dfs -mkdir -p /hello/a/b/c

-moveFromLocal -moveFromLocal:将文件从本地剪切到HDFS目录中。

[root@node1 ~]# vim data.txt
hello zhangsan
hello lisi
hello wangwu
[root@node1 ~]# hdfs dfs -moveFromLocal ./data.txt /hello/
[root@node1 ~]# hdfs dfs -ls /hello

-cat -cat ：显示HDFS文件内容命令。

[root@node1 ~]# hdfs dfs -cat /hello/data.txt
hello zhangsan
hello lisi
hello wangwu

-appendToFile -appendToFile ：追加一个文件到已经存在的文件末尾。

[root@node1 ~]# vim data2.txt
aaa
bbb
ccc

#将data2.txt文件内容追加到data.txt文件中
[root@node1 ~]# hdfs dfs -appendToFile ./data2.txt /hello/data.txt
[root@node1 ~]# hdfs dfs -cat /hello/data.txt
hello zhangsan
hello lisi
hello wangwu
aaa
bbb
ccc

-chmod -chmod 给文件赋值权限，文件系统中的用法一样。

[root@node1 ~]# hdfs dfs -ls /hello/data.txt
-rw-r–r– 3 root supergroup /hello/data.txt
[root@node1 ~]# hdfs dfs -chmod 777 /hello/data.txt
[root@node1 ~]# hdfs dfs -ls /hello/data.txt
-rwxrwxrwx 3 root supergroup /hello/data.txt

-copyFromLocal： -copyFromLocal: 从本地文件系统中拷贝文件到HDFS路径去。

[root@node1 ~]# vim data3.txt
hello zhangsan
hello lisi
hello wangwu

#将data3.txt拷贝到HDFS中
[root@node1 ~]# hdfs dfs -copyFromLocal ./data3.txt /hello/

[root@node1 ~]# ll
data3.txt

-copyToLocal -copyToLocal:从HDFS拷贝文件或者目录到本地。

[root@node1 ~]# hdfs dfs -copyToLocal /hello/ ./
[root@node1 ~]# ll
hello

-cp -cp : 从HDFS的一个路径拷贝到HDFS的另一个路径。

[root@node1 ~]# hdfs dfs -mkdir -p /hello2
[root@node1 ~]# hdfs dfs -cp /hello/data.txt /hello2/
[root@node1 ~]# hdfs dfs -ls /hello2
/hello2/data.txt

-mv -mv:在HDFS目录中移动文件，将文件移动到某个HDFS目录中。

[root@node1 ~]# hdfs dfs -mkdir -p /hello3
[root@node1 ~]# hdfs dfs -mv /hello2/data.txt /hello3/
[root@node1 ~]# hdfs dfs -ls /hello3//hello3/data.txt```
-get
-get：等同于copyToLocal，将文件从HDFS中下载文件到本地。
```Plain Text
[root@node1 ~]# hdfs dfs -get /hello3 ./
[root@node1 ~]# ll
hello3

-put -put：等同于copyFromLocal，将本地文件复制上传到HDFS中。

[root@node1 ~]# hdfs dfs -put ./hello3.txt /

-getmerge -getmerge：合并下载多个文件，比如HDFS的目录 /hello4下有多个文件:a.txt,b.txt,c.txt…,可以通过此命令，将数据合并下载到本地某个目录。

#创建hello4目录，并将对应的a.txt,b.txt,c.txt上传到此目录下
[root@node1 ~]# hdfs dfs -mkdir /hello4
[root@node1 ~]# hdfs dfs -put ./a.txt /hello4
[root@node1 ~]# hdfs dfs -put ./b.txt /hello4
[root@node1 ~]# hdfs dfs -put ./c.txt /hello4
[root@node1 ~]# hdfs dfs -ls /hello4
-rw-r–r– 3 root supergroup /hello4/a.txt
-rw-r–r– 3 root supergroup /hello4/b.txt
-rw-r–r– 3 root supergroup /hello4/c.txt

[root@node1 ~]# hdfs dfs -getmerge /hello4/* ./merge.txt
[root@node1 ~]# ll
-rw-r–r–. 1 root root merge.tx

-tail -tail：显示一个文件最后1kb数据到控制台。

[root@node1 ~]# hdfs dfs -tail /hello4/merge.txt
aaa
bbb
ccc

-rm -rm：删除文件或文件夹。可以加上 -r来递归删除目录下的所有数据。

[root@node1 ~]# hdfs dfs -rm /hello4/merge.txt
Deleted /hello4/merge.txt
[root@node1 ~]# hdfs dfs -rm -r /hello/
Deleted /hello

-rmdir -rmdir：删除空目录，目录必须是空目录才可以。

[root@node1 ~]# hdfs dfs -rmdir /hello2
注意：目录必须是空目录

-du -du:统计文件夹的大小信息。第一列标示该目录下总文件大小。第二列标示该目录下所有文件在集群上的总存储大小和你的副本数相关，副本数默认是3 ，所以第二列的是第一列的三倍（第二列内容=文件大小*副本数），第三列表示查询的目录。

[root@node1 ~]# hdfs dfs -du /hello4
4 12 /hello4/a.txt
4 12 /hello4/b.txt
4 12 /hello4/c.txt

-setrep -setrep:设置HDFS中文件的副本数量。

[root@node1 ~]# hdfs dfs -setrep 10 /hello3/data.txt
Replication 10 set: /hello3/data.txt

注意：这里设置的副本数只是记录在NameNode的元数据中，是否真的会有这么多副本，还得看DataNode的数量。因为目前只有3台DataNode，最多也就3个副本，只有节点数的增加到10台时，副本数才能达到10

HDFS Api操作 Window环境准备在window中通过IDEA编写操作HDFS的代码需要Window中配置Hadoop环境变量。首先将Hadoop3.x安装包下载到一个不包括中文、空格的路径中并解压，这里将Hadoop安装包解压下，如下：在这里插入图片描述

然后在Window中配置Hadoop环境变量:

配置完Hadoop环境变量后，还需要将的winutils.exe和hadoop.dll文件放在环境变量bin目录下。此外，hadoop.dll还要复制到“C:\\Windows\\System32”目录下。相关资料下载地址：https://github.com/cdarlint/winutils

API操作HDFS

在IDEA中创建项目，项目pom.xml导入依赖如下：

<properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<hadoop.version>3.3.6</hadoop.version>
<slf4j.version>1.7.36</slf4j.version>
<log4j.version>2.17.2</log4j.version>
<junit.version>4.11</junit.version>
</properties><dependencies><!– 操作 HDFS 所需依赖 –><dependency><groupId>org.apache.hadoop</groupId><artifactId>hadoop-client</artifactId><version>${hadoop.version}</version></dependency><!– slf4j&log4j 日志相关包 –><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>${slf4j.version}</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-to-slf4j</artifactId><version>${log4j.version}</version></dependency></dependencies>

编写代码如下：

public class TestHDFS {
public static FileSystem fs = null;

public static void main(String[] args) throws IOException, InterruptedException {
Configuration conf = new Configuration(true);
//创建FileSystem对象
fs = FileSystem.get(URI.create("hdfs://node1:8020/"),conf,"root");

//查看HDFS路径文件
listHDFSPathDir("/");
System.out.println("=====================================");

//创建目录
mkdirOnHDFS("/laowu/testdir");
System.out.println("=====================================");

//向HDFS 中上传数据
writeFileToHDFS("./data/test.txt","/laowu/testdir/test.txt");
System.out.println("=====================================");

//重命名HDFS文件
renameHDFSFile("/laowu/testdir/test.txt","/laowu/testdir/new_test.txt");
System.out.println("=====================================");

//查看文件详细信息
getHDFSFileInfos("/laowu/testdir/new_test.txt");
System.out.println("=====================================");

//读取HDFS中的数据
readFileFromHDFS("/laowu/testdir/new_test.txt");
System.out.println("=====================================");

//删除HDFS中的目录或者文件
deleteFileOrDirFromHDFS("/laowu/testdir");
System.out.println("=====================================");

//关闭fs对象
fs.close();
}

private static void listHDFSPathDir(String hdfsPath) throws IOException {
FileStatus[] fileStatuses = fs.listStatus(new Path(hdfsPath));
for (FileStatus fileStatus : fileStatuses) {
System.out.println(fileStatus.getPath());
}
}

private static void mkdirOnHDFS(String dirpath) throws IOException {
Path path = new Path(dirpath);

//判断目录是否存在if(fs.exists(path)) {
System.out.println("目录" + dirpath + "已经存在");
return;
}

//创建HDFS目录
boolean result = fs.mkdirs(path);
if(result) {
System.out.println("创建目录" + dirpath + "成功");
} else {
System.out.println("创建目录" + dirpath + "失败");
}
}

private static void writeFileToHDFS(String localFilePath, String hdfsFilePath) throws IOException {
//判断HDFS文件是否存在，存在则删除
Path hdfsPath = new Path(hdfsFilePath);
if(fs.exists(hdfsPath)) {
fs.delete(hdfsPath, true);
}

//创建HDFS文件路径
Path path = new Path(hdfsFilePath);
FSDataOutputStream out = fs.create(path);

//读取本地文件写入HDFS路径中
FileReader fr = new FileReader(localFilePath);
BufferedReader br = new BufferedReader(fr);
String newLine = "";
while ((newLine = br.readLine()) != null) {
out.write(newLine.getBytes());
out.write("\\n".getBytes());
}

//关闭流对象
out.close();
br.close();
fr.close();

//以上代码也可以调用copyFromLocalFile方法完成//参数解释如下：上传完成是否删除原数据；是否覆盖写入；本地文件路径；写入HDFS文件路径
fs.copyFromLocalFile(false,true,new Path(localFilePath),new Path(hdfsFilePath));
System.out.println("本地文件 ./data/test.txt 写入了HDFS中的"+hdfsFilePath+"文件中");

}

private static void renameHDFSFile(String hdfsOldFilePath,String hdfsNewFilePath) throws IOException {
fs.rename(new Path(hdfsOldFilePath),new Path(hdfsNewFilePath));
System.out.println("成功将"+hdfsOldFilePath+"命名为："+hdfsNewFilePath);
}

private static void getHDFSFileInfos(String hdfsFilePath) throws IOException {
Path file = new Path(hdfsFilePath);
RemoteIterator<LocatedFileStatus> listFilesIterator = fs.listFiles(file, true);//是否递归while(listFilesIterator.hasNext()){
LocatedFileStatus fileStatus = listFilesIterator.next();
System.out.println("文件详细信息如下:");
System.out.println("权限：" + fileStatus.getPermission());
System.out.println("所有者：" + fileStatus.getOwner());
System.out.println("组：" + fileStatus.getGroup());
System.out.println("大小：" + fileStatus.getLen());
System.out.println("修改时间：" + fileStatus.getModificationTime());
System.out.println("副本数：" + fileStatus.getReplication());
System.out.println("块大小：" + fileStatus.getBlockSize());
System.out.println("文件名：" + fileStatus.getPath().getName());

//获取当前文件block所在节点信息
BlockLocation[] blks = fileStatus.getBlockLocations();
for (BlockLocation nd : blks) {
System.out.println("block信息："+nd);
}
}
}

private static void readFileFromHDFS(String hdfsFilePath) throws IOException {
//读取HDFS文件
Path path= new Path(hdfsFilePath);
FSDataInputStream in = fs.open(path);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String newLine = "";
while((newLine = br.readLine()) != null) {
System.out.println(newLine);
}

//关闭流对象
br.close();
in.close();
}

private static void deleteFileOrDirFromHDFS(String hdfsFileOrDirPath) throws IOException {
//判断HDFS目录或者文件是否存在
Path path = new Path(hdfsFileOrDirPath);
if(!fs.exists(path)) {
System.out.println("HDFS目录或者文件不存在");
return;
}

//第二个参数表示是否递归删除
boolean result = fs.delete(path, true);
if(result){
System.out.println("HDFS目录或者文件 "+path+" 删除成功");
} else {
System.out.println("HDFS目录或者文件 "+path+" 删除成功");
}

}

Hadoop Federation 联邦

Federation背景介绍

[图片]

从上图中,我们可以很明显地看出现有的HDFS数据管理，数据存储2层分层的结构。也就是说,所有关于存储数据的信息和管理是放在NameNode这边,而真实数据的存储则是在各个DataNode下。而这些隶属于同一个NameNode，所管理的数据都是在同一个命名空间下的“NS”,以上结构是一个NameNode管理集群中所有元数据信息。举个例子，一般1GB内存放1，000，000 block元数据。200个节点的集群中每个节点有24TB存储空间，block大小为128MB，能存储大概4千万个block（200241024*1024M/128 约为4千万或更多）。100万需要1G内存存储元数据，4千万大概需要40G内存存储元数据，假设节点数如果更多、存储数据更多的情况下，需要的内存也就越多。通过以上例子可以看出，单NameNode的架构使得 HDFS 在集群扩展性和性能上都有潜在的问题，当集群大到一定程度后，NameNode进程使用的内存可能会达到上百G，NameNode 成为了性能的瓶颈。这时该怎么办？元数据空间依然还是在不断增大,一味调高NameNode的JVM大小绝对不是一个持久的办法，这时候就诞生了 HDFS Federation 的机制。 HDFS Federation是解决namenode内存瓶颈问题的水平横向扩展方案。Federation中文意思为联邦、联盟，HDFS Federation是NameNode的Federation,也就是会有多个NameNode。这些 namenode之间是联合的，他们之间相互独立且不需要互相协调，各自分工，管理自己的区域。分布式的datanode被用作通用的数据块存储存储设备。每个datanode要向集群中所有的namenode注册，且周期性地向所有 namenode 发送心跳和块报告，并执行来自所有 namenode的命令。 [图片]

NameNode节点之间是相互独立的联邦的关系，即它们之间不需要协调服务。

DataNode向集群中所有的NameNode注册，发送心跳和block块列表报告，处理来自NameNode的指令。

用户可以使用ViewFs创建个性化的命名空间视图，ViewFs类似于在Unix/Linux系统中的客户端挂载表。

Federation搭建

Hadoop Federation机制可以看成将多个HDFS集群进行了统一管理，即：多个HDFS集群中，每个集群都有一个或者多个NameNode，每个NameNode只能属于一个集群且都有自己的NameSpace，集群间的NameSpace相互独立。通过Hadoop Federation机制可以将指定数据存储在不同的集群由不同的NS管理，且可以通过ViewFS进行统一访问。

在node1~node5节点中进行Hadoop Federation集群搭建节点规划如下：在这里插入图片描述在搭建Hadoop Federation之前，首先将node1~node5节点上之前搭建的Hadoop集群数据目录和安装文件删除，重新进行搭建，搭建步骤如下。

下载安装包并解压

我们安装Hadoop3.3.6版本，此版本目前是比较新的版本，搭建HDFS集群前，首先需要在官网下载安装包，地址如下：https://hadoop.apache.org/releases.html。下载完成安装包后，上传到node1节点的/software目录下并解压，没有此目录，可以先创建此目录。 #将下载好的hadoop安装包上传到node1节点上

[root@node1 ~]# ls /software/
hadoop-3.3.6.tar.gz