设计模式 3 工程高频常用模式#

结合业务开发与面试考点，筛选9个最高频模式，基于之前的设计原则落地，附带极简代码、核心用途、适用场景，拒绝冗余概念。

1. 单例模式#

核心：保证一个类在全局仅有一个实例，提供统一访问点。
场景：连接池、配置管理器、日志工具、缓存管理器

1
// 饿汉单例（简单线程安全）
2
public class Singleton {
3
    private static final Singleton INSTANCE = new Singleton();
4
    private Singleton() {} // 私有构造，禁止new
5
    public static Singleton getInstance() {
6
        return INSTANCE;
7
    }
8
}

要点：私有化构造器；区分饿汉、懒汉、双重检查锁实现。

2. 工厂方法 & 抽象工厂#

工厂方法：一个工厂只生产一类产品，扩展产品只需新增工厂类。
抽象工厂：生产一组相关产品，适合产品族场景。
场景：SDK实例创建、多数据库驱动实例化。

1
interface Product {}
2
class ProductA implements Product {}
3

4
// 工厂方法
5
interface Factory {
6
    Product create();
7
}
8
class AFactory implements Factory {
9
    @Override
10
    public Product create() {
11
        return new ProductA();
12
    }
13
}

3. 策略模式#

核心：把多变算法独立封装，运行时动态切换算法，消除大量if-else。
场景：支付方式、折扣算法、文件解析器

1
interface Strategy {
2
    void handle();
3
}
4
class StrategyA implements Strategy {
5
    @Override public void handle() {}
6
}
7
// 上下文
8
class Context {
9
    private Strategy strategy;
10
    public void setStrategy(Strategy strategy) {
11
        this.strategy = strategy;
12
    }
13
    public void execute() {
14
        strategy.execute();
15
    }
16
}

4. 观察者模式#

核心：发布-订阅模型，主体状态变更自动通知所有订阅者。
场景：事件监听、消息通知、GUI回调、Spring事件驱动

1
// 观察者
2
interface Observer {
3
    void update();
4
}
5
// 被观察者
6
class Subject {
7
    private List<Observer> observers = new ArrayList<>();
8
    public void addObserver(Observer o) {observers.add(o);}
9
    public void notifyAllObserver() {
10
        observers.forEach(Observer::update);
11
    }
12
}

5. 装饰器模式#

核心：动态给对象叠加功能，相比继承更加灵活。
场景：IO流包装、权限叠加、请求参数增强

1
// 基础接口
2
interface Coffee {
3
    double cost();
4
    String desc();
5
}
6

7
// 基础咖啡
8
class SimpleCoffee implements Coffee {
9
    public double cost() {return 10;}
10
    public String desc() {return "纯咖啡";}
11
}
12

13
// 装饰器基类
14
abstract class CoffeeDecorator implements Coffee {
15
    protected Coffee coffee;
16
    public CoffeeDecorator(Coffee coffee) {this.coffee = coffee;}
17
}
18

19
// 加奶装饰
20
class MilkDecorator extends CoffeeDecorator {
21
    public MilkDecorator(Coffee coffee) {super(coffee);}
22
    public double cost() {return coffee.cost() + 2;}
23
    public String desc() {return coffee.desc() + "+牛奶";}
24
}

区分：装饰器包装自身实现同一接口；适配器用于转换接口。

6. 代理模式#

核心：通过代理对象控制对真实对象的访问，增加前后置逻辑。
场景：远程代理、AOP切面、权限校验、缓存、延迟加载
分类：静态代理、动态代理（JDK/Cglib，面试重点）

1
// 静态代理示例：统一接口
2
interface UserService {
3
    void addUser();
4
}
5

6
// 真实实现
7
class UserServiceImpl implements UserService {
8
    public void addUser() { /* 真实添加逻辑 */ }
9
}
10

11
// 代理类
12
class UserServiceProxy implements UserService {
13
    private UserService target = new UserServiceImpl();
14

15
    public void addUser() {
16
        // 前置：权限校验
17
        checkPermission();
18
        target.addUser();
19
        // 后置：日志记录
20
        log();
21
    }
22

23
    private void checkPermission() {}
24
    private void log() {}
25
}

7. 模板方法模式#

核心：父类定义固定执行流程，子类实现可变步骤。
场景：框架固定流程、文件解析、任务调度骨架

1
abstract class Template {
2
    // 固定流程
3
    public final void run() {
4
        step1();
5
        step2();
6
    }
7
    protected abstract void step2();
8
    private void step1() {}
9
}

8. 外观模式（门面）#

核心：为复杂子系统提供统一简易入口，降低调用方复杂度。
场景：复杂第三方SDK封装、微服务聚合接口

1
class SubA{}
2
class SubB{}
3
// 门面
4
class Facade {
5
    private SubA a = new SubA();
6
    private SubB b = new SubB();
7
    public void doService() {
8
        // 封装多个子系统调用
9
    }
10
}

9. 适配器模式#

核心：做接口转换器，兼容两套不兼容接口。
场景：新旧系统对接、第三方接口适配、兼容不同数据格式

1
// 目标接口
2
interface Target {void request();}
3
// 适配对象
4
class Adaptee {public void specificRequest(){}}
5
// 适配器
6
class Adapter implements Target{
7
    private Adaptee adaptee = new Adaptee();
8
    @Override
9
    public void request() {
10
        adaptee.specificRequest();
11
    }
12
}