← 返回学习路线

SYSTEM

设计模式 知识文档(面试高频)

八股
src/content/notes/system/07-设计模式.md

面向 Java 后端秋招面试 配套思维导图:mindmaps/07-设计模式.html

一、创建型

1.1 单例模式

单例保证一个类只有一个实例,并提供全局访问点。常见实现有四种,重点对比线程安全、延迟加载与防反射。

饿汉式在类加载时初始化,天然线程安全,但无法延迟加载;懒汉式延迟加载但需处理并发;静态内部类利用类加载机制实现延迟 + 线程安全;枚举单例天然防反射与反序列化,是 Effective Java 推荐的最优解。

DCL 懒汉单例(双重检查 + volatile):

public class Singleton {
    // volatile 防止指令重排序:new 对象分三步,重排会让别的线程拿到未初始化对象
    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;
    }
}

静态内部类与枚举方式:

// 静态内部类:利用类加载的线程安全性实现懒加载
public class Singleton {
    private Singleton() {
    }

    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

// 枚举单例:天然防反射、防反序列化,最优解
public enum SingletonEnum {
    INSTANCE;

    public void doSomething() {
    }
}

面试题:“单例模式有几种实现?哪种最好?”

饿汉式线程安全但无延迟加载;懒汉 DCL 用 volatile + 双重检查实现延迟加载与线程安全;静态内部类借类加载机制实现懒加载且无需加锁;枚举单例天然防反射、防反序列化,是 Effective Java 推荐的最优实现。实际项目中,无延迟需求用枚举,需要懒加载用静态内部类。

1.2 工厂方法 vs 抽象工厂

工厂方法让一个工厂类负责创建一种产品,子类决定实例化哪个具体产品,符合开闭原则——加新产品只需加新工厂子类,不改老代码。

抽象工厂更进一步,提供一个工厂接口,能创建一族相关产品(如同一主题的按钮 + 文本框)。它应对”产品族”场景,加产品族容易(新增工厂实现),但加新种类产品困难(要改所有工厂接口)。

工厂方法:

interface Product {
    void use();
}

class ProductA implements Product {
    public void use() { System.out.println("A"); }
}

class ProductB implements Product {
    public void use() { System.out.println("B"); }
}

abstract class Factory {
    public abstract Product create();
}

class FactoryA extends Factory {
    public Product create() { return new ProductA(); }
}

class FactoryB extends Factory {
    public Product create() { return new ProductB(); }
}

抽象工厂:

// 产品族:同一主题的一组组件
interface Button { void render(); }
interface TextField { void render(); }

class LightButton implements Button { public void render() { System.out.println("Light Button"); } }
class LightTextField implements TextField { public void render() { System.out.println("Light TextField"); } }

class DarkButton implements Button { public void render() { System.out.println("Dark Button"); } }
class DarkTextField implements TextField { public void render() { System.out.println("Dark TextField"); } }

interface UIFactory { // 抽象工厂:创建一族相关产品
    Button createButton();
    TextField createTextField();
}

class LightUIFactory implements UIFactory {
    public Button createButton() { return new LightButton(); }
    public TextField createTextField() { return new LightTextField(); }
}

class DarkUIFactory implements UIFactory {
    public Button createButton() { return new DarkButton(); }
    public TextField createTextField() { return new DarkTextField(); }
}

面试题:“工厂方法和抽象工厂的区别?”

工厂方法针对单一产品:每个具体工厂只造一种产品,加新产品只需加新工厂子类。抽象工厂针对产品族:一个工厂接口造一族相关产品(如整套主题组件),换主题容易,但加新种类产品要改所有工厂接口。

1.3 Builder 模式

Builder 把复杂对象的构造与表示分离,用链式调用一步步拼装,常用于多参数不可变对象,避免构造器参数爆炸和”set 一堆字段”的中间状态。

public class User {
    private final String name;
    private final int age;
    private final String email;

    private User(Builder b) {
        this.name = b.name;
        this.age = b.age;
        this.email = b.email;
    }

    public static class Builder {
        private String name;
        private int age;
        private String email;

        public Builder name(String name) { this.name = name; return this; }
        public Builder age(int age) { this.age = age; return this; }
        public Builder email(String email) { this.email = email; return this; }

        public User build() { return new User(this); }
    }
}

// 使用
User u = new User.Builder().name("Tom").age(18).email("a@b.com").build();

二、结构型

2.1 适配器模式

适配器把一个类的接口转换成客户端期望的另一个接口,使原本接口不兼容的类能协作。分对象适配器(持有被适配对象)和类适配器(继承被适配类,Java 单继承较少用)。

典型场景:旧系统接口升级、对接第三方 SDK、统一多个不同接口的实现。

// 目标接口:客户端期望 5V 输入
interface Target {
    int output5V();
}

// 被适配者:旧电源输出 220V
class Adaptee {
    public int output220V() { return 220; }
}

// 对象适配器:把 220V 转成 5V
class Adapter implements Target {
    private final Adaptee adaptee;

    public Adapter(Adaptee adaptee) { this.adaptee = adaptee; }

    public int output5V() {
        int v = adaptee.output220V();
        return v / 44; // 简单的降压
    }
}

面试题:“适配器模式应用场景?”

当现有类的接口与客户端期望不匹配时用适配器转换,常见于旧系统改造、对接第三方 SDK、让不兼容接口协作。对象适配器持有被适配对象更灵活,类适配器靠继承但受单继承限制。

2.2 代理模式

代理为目标对象提供一个替身,控制对它的访问。静态代理在编译期确定代理类,动态代理在运行时生成。

JDK 动态代理基于接口,通过 Proxy.newProxyInstance 生成代理类,InvocationHandler 处理方法调用;CGLIB 基于继承,通过生成目标类的子类并重写方法实现代理,无需目标实现接口。

Spring AOP 底层正是动态代理:有接口走 JDK 动态代理,无接口走 CGLIB。

interface Service {
    void work();
}

class ServiceImpl implements Service {
    public void work() { System.out.println("real work"); }
}

// JDK 动态代理:InvocationHandler 统一处理方法调用
class LoggingHandler implements InvocationHandler {
    private final Object target;

    public LoggingHandler(Object target) { this.target = target; }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before: " + method.getName());
        Object ret = method.invoke(target, args); // 委托真实对象
        System.out.println("after: " + method.getName());
        return ret;
    }
}

// 使用
Service proxy = (Service) Proxy.newProxyInstance(
        Service.class.getClassLoader(),
        new Class[]{Service.class},
        new LoggingHandler(new ServiceImpl()));
proxy.work();

CGLIB 动态代理示例:

// CGLIB:通过继承生成子类,无需目标实现接口
class ServiceNoInterface {
    public void work() { System.out.println("real work"); }
}

class CglibProxy implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before");
        Object ret = proxy.invokeSuper(obj, args); // 调用父类(真实逻辑)
        System.out.println("after");
        return ret;
    }

    public static <T> T create(Class<T> clazz) {
        Enhancer e = new Enhancer();
        e.setSuperclass(clazz);
        e.setCallback(new CglibProxy());
        return (T) e.create();
    }
}

面试题:“JDK 动态代理和 CGLIB 的区别?”

JDK 动态代理基于接口,用 Proxy + InvocationHandler 在运行时生成实现目标接口的代理类,要求目标实现接口;CGLIB 基于继承,生成目标类的子类并重写方法,不要求接口,但不能代理 final 类与方法。Spring AOP 默认有接口用 JDK 代理,无接口用 CGLIB。

2.3 装饰器模式

装饰器在不改变原对象的前提下,通过包装(与被装饰者实现同一接口)动态扩展功能,可层层叠加。Java IO 流是经典:BufferedInputStream 包装 FileInputStream,再被 DataInputStream 包装。

装饰器与代理结构很像,区别在意图:装饰器为”增强功能”,代理为”控制访问”。

interface Reader {
    String read();
}

class SimpleReader implements Reader {
    public String read() { return "data"; }
}

// 装饰器:包装同接口对象,叠加功能
class UpperCaseReader implements Reader {
    private final Reader reader;

    public UpperCaseReader(Reader reader) { this.reader = reader; }

    public String read() { return reader.read().toUpperCase(); }
}

// 使用:层层包装增强
Reader r = new UpperCaseReader(new SimpleReader());

面试题:“装饰器和代理模式的区别?”

结构相似,都持有目标引用并实现同一接口。区别在意图:装饰器为给对象叠加增强功能,可多层包装,调用方关注增强结果;代理为控制对目标对象的访问(权限、远程、延迟加载),调用方往往无感代理存在。装饰器典型场景是 IO 流包装,代理典型场景是 AOP 与远程调用。


三、行为型

3.1 策略模式

策略模式把一族算法各自封装成独立类,使它们可互换,从而消除大量 if-else 分支。上下文持有策略引用,运行时注入不同策略执行不同行为。

典型场景:支付方式(微信/支付宝/银行卡)、促销折扣、排序规则选择。

interface PayStrategy {
    void pay(int amount);
}

class WeChatPay implements PayStrategy {
    public void pay(int amount) { System.out.println("微信支付 " + amount); }
}

class AliPay implements PayStrategy {
    public void pay(int amount) { System.out.println("支付宝支付 " + amount); }
}

class PayContext { // 上下文持有策略,消除 if-else
    private final PayStrategy strategy;

    public PayContext(PayStrategy strategy) { this.strategy = strategy; }

    public void checkout(int amount) { strategy.pay(amount); }
}

// 使用
new PayContext(new WeChatPay()).checkout(100);

面试题:“策略模式如何消除 if-else?”

把每个分支的实现抽成独立策略类,实现同一接口;上下文持有策略引用,运行时按需注入具体策略。配合策略工厂(用 Map 维护策略 bean)后,新增方式只需加新策略类并注册,不再改原有判断逻辑,符合开闭原则。

3.2 观察者模式

观察者定义对象间一对多依赖:主题(Subject)状态变化时自动通知所有观察者,使它们能同步更新。Java 的 EventListener、事件总线、MQ 发布订阅都是其应用。

interface Observer {
    void update(String event);
}

class Subject {
    private final List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer o) { observers.add(o); }
    public void removeObserver(Observer o) { observers.remove(o); }

    public void notifyObservers(String event) {
        observers.forEach(o -> o.update(event));
    }
}

// 使用
Subject s = new Subject();
s.addObserver(e -> System.out.println("收到: " + e));
s.notifyObservers("下单");

3.3 状态模式

状态模式把每个状态封装成独立类,对象在状态变化时切换当前状态对象,从而把”根据状态走不同分支”的 if-else 消除掉。Context 把行为委托给当前 State 对象,状态切换由具体 State 触发。

典型场景:订单状态流转(待支付 → 已支付 → 已发货 → 已完成)、房间预订状态机。

interface OrderState {
    void next(Order order);
}

class Order { // Context
    private OrderState state;

    public Order(OrderState state) { this.state = state; }
    public void setState(OrderState state) { this.state = state; }
    public void next() { state.next(this); }
}

class Unpaid implements OrderState {
    public void next(Order order) {
        System.out.println("支付完成 -> 已支付");
        order.setState(new Paid());
    }
}

class Paid implements OrderState {
    public void next(Order order) {
        System.out.println("发货 -> 已发货");
        order.setState(new Shipped());
    }
}

class Shipped implements OrderState {
    public void next(Order order) {
        System.out.println("收货 -> 已完成");
    }
}

// 使用
Order order = new Order(new Unpaid());
order.next(); // 已支付
order.next(); // 已发货
order.next(); // 已完成

3.4 责任链模式

责任链把多个处理者串成链,请求沿链传递,每个处理者决定自己处理还是交给下一个。它解耦了请求发送者与接收者。

Netty 的 ChannelPipeline 是典型:入站/出站事件沿 ChannelHandler 链依次处理;Servlet 的 FilterChain、Spring 的 HandlerInterceptor 也是责任链。

abstract class Handler {
    protected Handler next;

    public Handler setNext(Handler next) { this.next = next; return next; }

    public abstract void handle(String request);
}

class AuthHandler extends Handler {
    public void handle(String request) {
        if (!request.contains("token")) {
            System.out.println("认证失败");
            return;
        }
        System.out.println("认证通过");
        if (next != null) next.handle(request);
    }
}

class LogHandler extends Handler {
    public void handle(String request) {
        System.out.println("记录日志: " + request);
        if (next != null) next.handle(request);
    }
}

// 使用:组装链
Handler chain = new AuthHandler();
chain.setNext(new LogHandler());
chain.handle("request with token");

面试题:“责任链模式在 Netty 中如何应用?”

Netty 用 ChannelPipeline 把 ChannelHandler 串成双向链表,入站事件从 head 向 tail 传递、出站从 tail 向 head。每个 Handler 处理后调用 fireChannelRead 等方法把事件传给下一个,也可中断传播。这种链式处理让编解码、日志、业务逻辑各成一层,灵活可插拔。