当前位置：首页 > news >正文

常见设计模式讲解

news 2025/9/27 10:27:52

一、总体分类（来自 GOF）

创建型（Creational）：负责对象创建，隐藏创建细节，常见：Singleton、Factory Method、Abstract Factory、Builder、Prototype。
结构型（Structural）：描述类或对象如何组合，常见：Adapter、Bridge、Composite、Decorator、Facade、Flyweight、Proxy。
行为型（Behavioral）：对象或类间的通信与职责分配，常见：Observer、Strategy、Command、Iterator、Template Method、State、Visitor、Chain of Responsibility、Mediator。

创建型模式 (Creational)

Singleton — 单例模式

目的：保证类只有一个实例，并提供全局访问点。
解决的问题：需要唯一共享实例（配置、连接池、日志中心等），并避免频繁创建对象开销。
参与者：Singleton 类本身负责实例管理。
实现要点：
- 饿汉式（类加载时初始化）或懒汉式（延迟实例化）。
- 线程安全：双重检查+volatile、静态内部类（推荐）、枚举单例（防反序列化/反射）。
优点：简单、能节省资源。缺点：全局状态带来测试困难、隐藏依赖、破坏可替换性。
工程建议：优先使用容器（Spring 单例 Bean）替代手写单例；若必需，使用静态内部类或枚举实现。
陷阱：对单例做过多职责会导致“上帝对象”；序列化/反射需防护。

示例：

// 文件名：SingletonExamples.java
public class SingletonExamples {// 静态内部类方式（懒加载，线程安全）public static class LazyHolderSingleton {private LazyHolderSingleton() {}private static class Holder { static final LazyHolderSingleton INSTANCE = new LazyHolderSingleton(); }public static LazyHolderSingleton getInstance() { return Holder.INSTANCE; }public void hello() { System.out.println("Hello from LazyHolderSingleton"); }}// 枚举单例（推荐，防止反序列化创建新实例）public enum EnumSingleton {INSTANCE;public void hello() { System.out.println("Hello from EnumSingleton"); }}public static void main(String[] args) {LazyHolderSingleton.getInstance().hello();EnumSingleton.INSTANCE.hello();}
}

Factory Method — 工厂方法

中文：工厂方法模式
目的：定义用于创建对象的接口，由子类决定实例化哪一个类，客户端调用接口而不直接 new。
解决的问题：客户端不依赖具体实现，便于扩展新的产品类型。
参与者：抽象工厂（Creator）声明 factoryMethod；具体工厂返回具体产品。
实现要点：把 new 操作封装在工厂方法中，子类/配置决定具体实现。
优点：符合开闭原则，便于新增产品。缺点：增加类数量，可能有许多小工厂类。
适用场景：需要延迟决定具体类或运行时通过配置/子类选择实现（例如不同 DB 驱动、不同策略类实例化）。

// 文件名：FactoryMethodExample.java
public class FactoryMethodExample {interface Product { void use(); }static class ConcreteProductA implements Product {public void use() { System.out.println("Using Product A"); }}static class ConcreteProductB implements Product {public void use() { System.out.println("Using Product B"); }}// Creator 抽象工厂static abstract class Creator {public abstract Product factoryMethod();public void doSomething() {Product p = factoryMethod();p.use();}}static class CreatorA extends Creator {public Product factoryMethod() { return new ConcreteProductA(); }}static class CreatorB extends Creator {public Product factoryMethod() { return new ConcreteProductB(); }}public static void main(String[] args) {Creator c1 = new CreatorA();Creator c2 = new CreatorB();c1.doSomething(); // 使用 Product Ac2.doSomething(); // 使用 Product B}
}

Abstract Factory — 抽象工厂

中文：抽象工厂模式
目的：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。
解决的问题：多个产品族需要一起使用且相互兼容时，便于在不同产品族之间切换。
参与者：抽象工厂、具体工厂、抽象产品、具体产品。
实现要点：一个工厂接口包含多种 createX 方法（createButton/createText 等），具体工厂实现整套产品族。
优点：易于交换整套产品族。缺点：新增产品（增加一种产品种类）需要修改抽象工厂接口与所有具体工厂。
场景：UI 皮肤切换、跨平台组件库等。

// 文件名：AbstractFactoryExample.java
public class AbstractFactoryExample {// 抽象产品interface Button { void paint(); }interface TextField { void paint(); }// 具体产品 - Windowsstatic class WindowsButton implements Button { public void paint() { System.out.println("Windows Button"); } }static class WindowsTextField implements TextField { public void paint() { System.out.println("Windows TextField"); } }// 具体产品 - Macstatic class MacButton implements Button { public void paint() { System.out.println("Mac Button"); } }static class MacTextField implements TextField { public void paint() { System.out.println("Mac TextField"); } }// 抽象工厂interface GUIFactory {Button createButton();TextField createTextField();}static class WindowsFactory implements GUIFactory {public Button createButton() { return new WindowsButton(); }public TextField createTextField() { return new WindowsTextField(); }}static class MacFactory implements GUIFactory {public Button createButton() { return new MacButton(); }public TextField createTextField() { return new MacTextField(); }}// 客户端代码：通过工厂获得一族产品，无需知道具体实现public static void main(String[] args) {GUIFactory factory = detectOSFactory();Button b = factory.createButton();TextField tf = factory.createTextField();b.paint(); tf.paint();}private static GUIFactory detectOSFactory() {String os = System.getProperty("os.name", "Windows").toLowerCase();if (os.contains("mac")) return new MacFactory();else return new WindowsFactory();}
}

Builder — 建造者

中文：建造者模式
目的：将一个复杂对象的构建与表示分离，使得相同的构建过程可以创建不同的表示。
解决的问题：避免构造函数参数过多（telescoping constructor），便于构造可变/复杂对象（多可选参数）。
参与者：Builder 接口、ConcreteBuilder、Director（可选）、Product。
实现要点：链式 API（.withX().withY().build()）或静态内部类 builder；支持校验与默认值。
优点：可读性高，便于扩展，不可变对象友好。缺点：实现稍繁琐。
场景：复杂 DTO、配置对象、需要渐进式构造的场景。

Prototype — 原型模式

中文：原型模式
目的：通过复制已有实例来创建新对象（浅/深拷贝）。
解决的问题：对象构造成本高或配置复杂时复制原型更高效。
参与者：Prototype 接口（clone 方法）与具体原型。
实现要点：实现 clone() 或序列化复制，注意深拷贝 vs 浅拷贝、共享可变字段问题。
优点：创建速度快。缺点：深拷贝实现复杂，维护成本高。
场景：大量类似对象、对象创建耗时（例如复杂初始化或 expensive builder）。

// 文件名：BuilderExample.java
public class BuilderExample {public static class Person {private final String name;private final int age;private final String address;private final String phone;private Person(Builder b) {this.name = b.name; this.age = b.age; this.address = b.address; this.phone = b.phone;}public static Builder builder() { return new Builder(); }public static class Builder {private String name;private int age;private String address;private String phone;public Builder name(String name) { this.name = name; return this; }public Builder age(int age) { this.age = age; return this; }public Builder address(String address) { this.address = address; return this; }public Builder phone(String phone) { this.phone = phone; return this; }public Person build() {// 可加校验逻辑if (name == null || name.isEmpty()) throw new IllegalStateException("name required");return new Person(this);}}@Overridepublic String toString() {return "Person{name='" + name + "', age=" + age + ", address='" + address + "', phone='" + phone + "'}";}}public static void main(String[] args) {Person p = Person.builder().name("Alice").age(30).address("Beijing").build();System.out.println(p);}
}

结构型模式 (Structural)
6. Adapter — 适配器

中文：适配器模式
目的：将一个类的接口转换成客户端所期望的另一个接口，使接口不兼容的类能协同工作。
解决的问题：集成第三方库、旧接口适配新接口。
参与者：Target、Adapter、Adaptee。
实现要点：对象适配器（通过组合 Adaptee）或类适配器（通过继承）。优先用对象适配器。
优点：解耦、复用第三方代码。缺点：增加额外包装类。
场景：第三方系统适配、重构渐进迁移。

Bridge — 桥接

中文：桥接模式
目的：把抽象部分与实现部分分离，使二者可以独立变化（抽象与实现解耦）。
解决的问题：当抽象与实现都可能扩展时，避免类爆炸。
参与者：Abstraction（持有 Implementor）、RefinedAbstraction、Implementor、ConcreteImplementor。
实现要点：Abstraction 持有一个 Implementor 接口实例，调用实现完成具体操作；扩展各自维度时只需添加子类或实现。
优点：解耦、灵活扩展。缺点：设计复杂度高。
场景：图形渲染框架（抽象图形和渲染实现分离）、多平台支持。