java设计模式详解——23种设计模式（一文搞定，全网最详细）

💡 符号说明

◁—：空心三角箭头 + 实线◇—：空心菱形 + 实线◆—：实心菱形 + 实线箭头方向：始终指向被依赖/被关联方

2.1 继承

classDiagram

Vehicle <|-- Car : 继承

class Vehicle {

+move(): void

}

class Car {

+accelerate(): void

}

2.2 实现

classDiagram

Engine <|.. ElectricEngine : 实现

class Engine {

<>

+start(): void

}

class ElectricEngine {

+start(): void

}

2.3 关联

classDiagram

Car "1" --> "1" Driver : 关联

class Car {

-driver: Driver

}

class Driver {

-name: String

}

2.4 聚合

classDiagram

University "1" o-- "*" Student : 聚合

class University {

-students: List~Student~

}

class Student {

-name: String

}

2.5 组合

classDiagram

House "1" *-- "*" Room : 组合

class House {

-rooms: List~Room~

}

class Room {

-area: int

}

2.6 依赖

classDiagram

Car ..> Fuel : 依赖

class Car {

+refuel(f: Fuel): void

}

class Fuel {

-type: String

}

2.7 完整示例

三、软件设计原则

直接点击软件设计原则即可跳转，上一篇文章已经详细介绍过。

四、创建者模式

1. 单例模式

📌 定义：单例模式确保一个类只有一个实例，并提供全局访问点，常用于管理共享资源（如数据库连接、线程池等）等。

核心特性

唯一性：一个类只能有一个实例。全局访问：通过静态方法或属性获取该实例。延迟访问（可选）：可以选择在第一次请求时初始化实例。

实现方式

1. 懒汉式（线程不安全）

public class Singleton {

private static Singleton instance;

private Singleton() {} // 私有构造方法

public static Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

❗️ 这种创建方式在多线程下是不安全的，也就是说在同一个线程中这个对象是单例的，只有一个实例，但是在多个线程中就会存在多个实例，拿Tomcat为例，如果一次请求为一个线程，那并发量高的话，你这个对象就会存在多份，服务器压力会很大。

2. 饿汉式（线程安全）

public class Singleton {

private static final Singleton instance = new Singleton();

private Singleton() {}

public static Singleton getInstance() {

return instance;

}

}

优点： 实现简单，通过final修饰，确保只存在一份实例，且线程安全。

缺点： 在类初始化时就会实例化，可能浪费资源。

💡 其实在正常开发中，我们大多数使用的是这种饿汉式，因为简单粗暴，而且在大多数情况下，类初始化时实例化这点开销可以忽略不计。

3. 双重检查锁（DCL线程安全）

public class Singleton {

private static volatile Singleton instance;

private Singleton() {}

public static Singleton getInstance() {

if (instance == null) { // 第一次检查

synchronized (Singleton.class) { // 加锁

if (instance == null) { // 第二次检查

instance = new Singleton();

}

}

}

return instance;

}

}

优点：延迟初始化 + 线程安全 + 高性能。 关键点：volatile 防止指令重排序。

注意 ❗️ ❗️ ❗️

这里是一个难点，底层原理涉及比较深，但是挺有意思的。

volatile关键字详解（扩展）

💡 作用：保证变量的可见性和禁止指令重排序，但不保证其原子性，它在多线程编程中用于解决内存可见性问题，但不适用于需要原子操作的场景（如 i++）

变量可见性（Visibility）

问题背景

在 Java 内存模型（JMM）中，每个线程有自己的工作内存（缓存），线程操作变量时可能直接从缓存读取，而不是主内存。这可能导致一个线程修改了变量，但其他线程看不到最新值

class Example {

boolean flag = false; // 不使用 volatile

void writer() { flag = true; }

void reader() { while (!flag); } // 可能死循环，读不到 flag 的变化

}

解决方案

被 volatile 修饰的变量，所有读写直接操作主内存，保证修改后立即对其他线程可见。

volatile boolean flag = false; // 使用 volatile

禁止指令重排序（Ordering）

问题背景：

JVM 和 CPU 为了提高性能，可能会对指令进行重排序（如单例模式的 Double-Checked Locking 问题）。

class Singleton {

private static Singleton instance;

static Singleton getInstance() {

if (instance == null) {

synchronized (Singleton.class) {

if (instance == null) {

instance = new Singleton(); // 可能发生指令重排序

}

}

}

return instance;

}

}

new Singleton() 的步骤：

分配内存空间

初始化对象

将引用指向内存地址

如果发生重排序（1→3→2），其他线程可能拿到未初始化的对象。

解决方案：

使用 volatile 修饰变量，禁止 JVM 进行指令重排序。

private static volatile Singleton instance; // 解决 DCL 问题

💡 到底什么是重排序？重排序的执行者是谁？重排序的执行时机是什么？

💡 重排序就是一种优化机制，核心就是调换两行代码的执行顺序（前提是两行代码之间没有必要的关联，比如int a = 1；int b = 2；这种），可以适当提高效率，但是这种情况下在多线程就会存在问题，类似上面说到的问题。

💡 重排序的三种类型

类型执行者触发场景示例编译器重排序Java/JIT 编译器编译源代码时，对没有数据依赖的语句进行优化交换int a=1;和int b=2;的执行顺序指令级重排序CPU处理器运行时指令流水线采用乱序执行(Out-of-Order Execution)优化先执行b=1再执行a=data.getValue()以隐藏内存访问延迟内存系统重排序缓存一致性协议多核CPU的缓存同步延迟导致写操作可见顺序与程序顺序不一致线程A写变量x后，线程B可能先看到y的更新后看到x的更新

关键特征对比：

编译器重排序：

发生在代码编译阶段通过调整语句顺序优化寄存器使用示例：int x=1; int y=x;不会被重排序（存在数据依赖） CPU指令重排序：

发生在运行时指令执行阶段现代CPU普遍支持乱序执行示例：Store-Load可能被重排序（写后读操作） 内存系统重排序：

由缓存一致性协议(MESI等)引起本质是内存可见性问题示例：单例DCL问题中，可能先看到对象引用后看到初始化内容

如何避免重排序导致的问题？

方法作用机制适用场景代码示例volatile 变量禁止指令重排序 + 保证可见性状态标志位、DCL单例模式private volatile boolean ready;synchronized 块内存屏障 + 原子性保障复合操作/临界区保护synchronized(lock){ counter++; }final 字段构造函数初始化安全不可变对象创建final Map config = initConfig();原子类CAS操作 + volatile语义计数器等简单原子操作AtomicInteger count = new AtomicInteger(0);

各方案对比说明：

volatile方案：

✅ 轻量级，仅针对变量操作❌ 不保证复合操作的原子性典型应用：// 双重检查锁定(DCL)

private volatile static Singleton instance;

synchronized方案：

✅ 全能解决方案（原子性+可见性）❌ 有性能开销典型应用：public synchronized void safeIncrement(){

counter++;

}

final方案：

✅ 初始化安全性（JLS 17.5保证）❌ 仅适用于不可变对象典型应用：class SafeConfig {

final Map config;

SafeConfig() {

config = loadConfig(); // 构造函数内安全发布

}

}

原子类方案：

✅ 无锁高性能❌ 仅适用于简单操作典型应用：AtomicReference state = new AtomicReference<>(INIT);

4. 静态内部类（线程安全）

public class Singleton {

private Singleton() {}

private static class Holder {

static final Singleton INSTANCE = new Singleton();

}

public static Singleton getInstance() {

return Holder.INSTANCE;

}

}

优点：懒加载 + 无锁线程安全（利用类加载机制）。

💡 首先我们要明白，我们使用的是Holder.INSTANCE变量，而这是通过内部类实现的，只有你调用getInstance方法才会执行，重点是jvm的类加载机制是天然线程安全的，它只会保证你这个内部类加载一次，所以非常的方便好用（不懂的去了解一下static变量和类加载机制，这里不做赘述）

5. 枚举（线程安全）

public enum Singleton {

INSTANCE;

public void doSomething() {

System.out.println("Singleton action");

}

}

使用方式

Singleton singleton = Singleton.INSTANCE;

singleton.doSomething();

优点：

绝对防止反射和序列化破坏单例，反序列化也是直接返回当前实例（java规定）。

代码简洁，JVM 保证唯一性，因为底层就是用final + static修饰的。

为什么枚举单例是最佳实践？

绝对线程安全 由 JVM 类加载机制 保证，无需任何同步代码（如 synchronized 或 volatile）。

天然防反射攻击 枚举的构造方法 无法通过反射调用（Constructor.newInstance() 直接报错）。

天然防反序列化攻击 枚举的反序列化 不会创建新对象，而是直接返回已存在的实例。

代码最简洁 只需一行 INSTANCE 定义，无需额外处理同步、反射、序列化等问题。

扩展：反序列化攻击

这一块大多数初级程序员可能都懵懵懂懂，什么是反序列化？什么又是反序列化攻击？

简单说一下，反序列化就是我们发送请求到服务器之后，这其实是一串序列化之后的编码，也就是将一些字符串和数据编码后的格式，服务器通过规则解析成java或者其它语言可以识别的格式，而反序列化攻击就是在发送的数据上做手脚，然后通过你反序列化的漏洞将危险代码植入到你的服务器，比如。

// 攻击者构造的恶意代码

Transformer[] transformers = new Transformer[]{

new ConstantTransformer(Runtime.class),

new InvokerTransformer("getMethod",

new Class[]{String.class, Class[].class},

new Object[]{"getRuntime", new Class[0]}),

new InvokerTransformer("invoke",

new Class[]{Object.class, Object[].class},

new Object[]{null, new Object[].class}),

new InvokerTransformer("exec",

new Class[]{String.class},

new Object[]{"calc.exe"}) // 弹出计算器

};

Transformer chain = new ChainedTransformer(transformers);

Map payload = new HashMap();

payload.put(chain, "dummy");

// 序列化成字节流

ByteArrayOutputStream bos = new ByteArrayOutputStream();

new ObjectOutputStream(bos).writeObject(payload);

byte[] maliciousData = bos.toByteArray();

// 通过HTTPS发送给你的服务

sendHttpsRequest(maliciousData);

当你的服务反序列化这个数据时：

重建HashMap对象

自动调用HashMap的readObject()

触发Transformer链式调用

最终执行Runtime.getRuntime().exec(“calc.exe”)

这是一个简单的例子，是commons-collections的一个漏洞，现已经修复。我想表达的是，或许我们用不到这个知识，但你得知道，在将来的某一天，你成为了开发组长或者经理，你不能不知道这些攻击的原理，不能不知道该怎么办。

应用场景

配置管理（全局配置，例如AppConfig）日志记录（单例日志记录器）数据库连接池（避免重复链接）缓存系统（Redis）

破坏单例的方式

反射（在构造方法中增加判断 if (instance != null)）序列化（使用readResolve可避免）

2. 原型模式

📌 定义：它允许通过复制现有对象（原型）来创建新对象，而不是通过 new 实例化，适用场景：

对象创建成本高（数据库查询、计算等）需要动态运行时创建对象避免构造函数的约束（创建对象和构造函数没有关系了）

实现方式

2.1 浅拷贝

class Person implements Cloneable {

private String name;

private int age;

private List hobbies; // 引用类型（浅拷贝会共享）

public Person(String name, int age, List hobbies) {

this.name = name;

this.age = age;

this.hobbies = hobbies;

}

@Override

public Person clone() {

try {

return (Person) super.clone(); // 调用Object的clone()

} catch (CloneNotSupportedException e) {

throw new AssertionError();

}

}

// Getters & Setters...

}

适用于没有嵌套对象，结构简单的对象。仅仅复制对象的内存地址和简单的属性。如果原始对象修改，复制的所有对象都会被修改。

2.2 深拷贝

完全复制对象及其引用的所有对象，适用于嵌套对象的场景

方式1：手动复制

@Override

public Person clone() {

try {

Person cloned = (Person) super.clone();

// 将嵌套的对象都在这手动赋值

cloned.hobbies = new ArrayList<>(this.hobbies); // 创建新List

return cloned;

} catch (CloneNotSupportedException e) {

throw new AssertionError();

}

}

方式2：序列化拷贝（推荐，但是要注意实现方式）

💡 优点：通用性强，适合复杂对象。

import java.io.*;

class Person implements Serializable {

// ...（同上）

public Person deepClone() {

try {

ByteArrayOutputStream bos = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(bos);

oos.writeObject(this);

ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());

ObjectInputStream ois = new ObjectInputStream(bis);

return (Person) ois.readObject();

} catch (IOException | ClassNotFoundException e) {

throw new RuntimeException("Deep clone failed", e);

}

}

}

上面的例子是自己写的序列化拷贝，但是在正式开发中不推荐，使用第三方库更安全，比如Jackson。上面的方式一般是不会存在反序列化攻击的，如果你的拷贝对象完全来自于jvm那就不存在这种危险，如果你的对象是来自于网络则需要注意，所以使用第三方库更加安全。

原型模式的应用场景

场景说明对象创建开销大当直接通过 new 创建对象成本较高时（如复杂计算、数据库查询），通过复制已有对象提升性能。动态配置对象运行时根据需求修改原型对象的属性，快速生成不同配置的新对象。撤销/恢复功能保存对象的历史状态（如文档编辑器中的“撤销”操作），通过克隆实现状态回滚。游戏开发快速生成大量相似实体（如敌人、子弹、道具），避免重复初始化资源。多线程环境需要线程安全的对象实例时，可预先克隆备用的独立对象。保护性拷贝防止外部代码修改原始对象（如返回防御性副本）。

原型模式的优缺点

优点缺点1. 性能高：比直接 new 对象更高效（尤其适用于复杂对象）。1. 深拷贝实现复杂：需递归处理所有嵌套对象，代码量增加。2. 动态性：运行时灵活克隆对象，无需依赖子类。2. 需实现 Cloneable：违反迪米特法则（侵入性设计）。3. 绕过构造函数限制：可复制包含私有构造方法的对象。3. 浅拷贝风险：默认 clone() 是浅拷贝，共享引用对象可能导致错误。4. 减少重复初始化：复用原型对象的初始化状态。4. 循环引用问题：深拷贝时需处理对象间的循环依赖。

迪米特法则的核心思想

迪米特法则强调“最少知识原则”：一个对象应该只与其直接朋友（成员变量、方法参数、返回值等）交互，而不应了解其他对象的内部结构或依赖关系。目的是降低耦合。

💡 上面说的违反迪米特法则其实正常来说允许适当出现，因为这个法则是尽量避免我们操作对象中的子对象，因为你不知道子对象是否实现了序列化接口，是否实现了克隆接口，或者说子对象中还有没有内部对象，比较容易造成循环依赖的问题。

💡 在Spring的BeanUtils中有一个方法是copyProperties，这个方法就是用来复制对象的，可能会出现循环依赖现象，如果出现，可以通过@JsonIgnore注解忽略互相引用的字段，或者在复制时指定忽略的字段BeanUtils.copyProperties(source, target, "b"); // 忽略字段 "b"。

💡 当然，因为上面的方法底层原理还是反射，如果你的业务要求高（比如在游戏中，一个人物有一个技能是分身），这时候使用反射效率就很低了，可以采用封装DTO的形式或者说使用MapStruct 和 Orika等第三方库避免（了解即可，如果用到自行百度），这两个会在编译时形成一个字节码库，相当于手写的DTO，很快。

3. 工厂模式

直接点击 工厂模式 即可跳转，上一篇文章已经详细介绍过。

关于 简单工厂 也可以了解一下，Spring中常用的一种模式。

4. 抽象工厂模式

点击 抽象工厂 即可跳转，介绍比较详细且易懂。

5. 建造者模式

📌 定义： 将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

📌 和工厂模式的区别

工厂模式倾向于结果，客户端提供需求，工厂直接提供结果。建造者模式倾向于过程，将一个复杂对象分步骤创建，返回给客户端。

包含的角色

Product（产品）：表示被创建的复杂对象。Builder（抽象构造者）：定义创建产品各个部件的抽象构造方法。ConcreteBuilder（具体构造者）：Builder的实现类，用于创建具体的部件。Director（指挥官）：调度员，构建一个使用Builder接口的对象。

优缺点

💡 优点

封装性好：建造过程与产品分离。扩展性好：新增具体建造者不用修改原有的代码。便于控制细节：可以更好的控制不同部件的创建细节。解耦：将客户端与包含多个部件的复杂对象创建过程分离。

❌ 缺点

产品必须有共同点增加了系统的复杂度：创建多个Builder类适用范围有限：适合复杂对象

代码示例

// 产品类 - 电脑

class Computer {

private String cpu;

private String ram;

private String storage;

private String gpu;

// 省略getter和setter方法

@Override

public String toString() {

return "Computer{" +

"cpu='" + cpu + '\'' +

", ram='" + ram + '\'' +

", storage='" + storage + '\'' +

", gpu='" + gpu + '\'' +

'}';

}

}

// 抽象建造者

interface ComputerBuilder {

void buildCPU();

void buildRAM();

void buildStorage();

void buildGPU();

Computer getResult();

}

// 具体建造者 - 游戏电脑

class GamingComputerBuilder implements ComputerBuilder {

private Computer computer = new Computer();

@Override

public void buildCPU() {

computer.setCpu("Intel i9");

}

@Override

public void buildRAM() {

computer.setRam("32GB DDR5");

}

@Override

public void buildStorage() {

computer.setStorage("1TB NVMe SSD");

}

@Override

public void buildGPU() {

computer.setGpu("NVIDIA RTX 4090");

}

@Override

public Computer getResult() {

return computer;

}

}

// 具体建造者 - 办公电脑

class OfficeComputerBuilder implements ComputerBuilder {

private Computer computer = new Computer();

@Override

public void buildCPU() {

computer.setCpu("Intel i5");

}

@Override

public void buildRAM() {

computer.setRam("16GB DDR4");

}

@Override

public void buildStorage() {

computer.setStorage("512GB SSD");

}

@Override

public void buildGPU() {

computer.setGpu("Integrated Graphics");

}

@Override

public Computer getResult() {

return computer;

}

}

// 指挥者

class ComputerDirector {

public Computer construct(ComputerBuilder builder) {

builder.buildCPU();

builder.buildRAM();

builder.buildStorage();

builder.buildGPU();

return builder.getResult();

}

}

// 客户端代码

public class BuilderPatternDemo {

public static void main(String[] args) {

ComputerDirector director = new ComputerDirector();

// 构建游戏电脑

ComputerBuilder gamingBuilder = new GamingComputerBuilder();

Computer gamingComputer = director.construct(gamingBuilder);

System.out.println("Gaming Computer: " + gamingComputer);

// 构建办公电脑

ComputerBuilder officeBuilder = new OfficeComputerBuilder();

Computer officeComputer = director.construct(officeBuilder);

System.out.println("Office Computer: " + officeComputer);

}

}

适用场景

当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时

当构造过程必须允许被构造的对象有不同的表示时（同一个产品，实现细节不同，表示不同）

当需要生成的产品对象有复杂的内部结构时

当需要生成的产品对象的属性相互依赖，需要指定其生成顺序时

扩展

当过程固定或者流程较少，可以省略Director。链式调用：Builder的方法可以返回this，实现链式调用

public class ComputerBuilder {

private Computer computer = new Computer();

public ComputerBuilder withCPU(String cpu) {

computer.setCpu(cpu);

return this;

}

public ComputerBuilder withRAM(String ram) {

computer.setRam(ram);

return this;

}

public Computer build() {

return computer;

}

}

实际应用案例

Java中的StringBuilder：append()链式调用的经典案例。

Android中的AlertDialog.Builder

Lombok的@Builder注解

MyBatis中的SqlSessionFactoryBuilder

计算公式应用案例

📌 现在要实现业务上的计算功能，你是最终计算的出口，需要汇总多个子业务的结果并给出计算结果和分析结果，我们就可以给出一个计算抽象建造者例如CalcBuilder。

interface CalcBuilder {

List