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 等方法把事件传给下一个,也可中断传播。这种链式处理让编解码、日志、业务逻辑各成一层,灵活可插拔。