Java面试中的设计模式

深度解析23种设计模式在Java开发中的核心应用,结合Spring、MyBatis等主流框架源码实现,覆盖阿里、腾讯、字节等大厂高频考点,助你系统掌握设计模式底层逻辑与实战技巧。

查看设计模式体系

设计模式在Java面试中的战略地位

在中高级Java开发岗位面试中,设计模式早已超越“了解即可”的范畴,成为考察系统设计能力、抽象思维与工程素养的核心标尺。据2024年春招数据统计,87.3%的BATJ级企业将设计模式列为技术面必考项,其中阿里P7+岗位平均涉及3.2个设计模式深度追问。

为什么设计模式如此重要?设计模式本质是面向对象设计原则的实践结晶,它将复杂系统抽象为可复用的结构单元,体现“高内聚、低耦合”的工程哲学。面试官通过设计模式考察点通常集中在:

  • 对SOLID原则的理解深度(单一职责、开闭原则等)
  • 代码可扩展性与可维护性的权衡能力
  • 框架源码中模式应用的实战洞察力
  • 新场景下模式组合使用的创造性思维

尤其值得注意的是,Spring框架中单例模式、工厂模式、代理模式、模板方法的组合应用,已成为Java开发者的“设计模式入门必修课”。本文将从面试官视角出发,构建系统性认知框架,助你实现从“背答案”到“建思维”的跃迁。

设计模式的三大认知误区

许多候选人陷入“死记硬背模式定义”的误区,导致在实际问答中暴露思维短板。以下三大认知偏差需重点规避:

  • 【定义陷阱】:将“单例模式=私有构造器+静态方法”等同,忽略其对并发安全、序列化恢复等生产环境问题的考量
  • 【场景错配】:在简单CRUD场景强行套用装饰器模式,违背“需求驱动设计”原则
  • 【技术割裂】:割裂看待设计模式与框架源码、性能优化的关系,无法建立知识网络

正确路径应是:以业务场景为锚点,以SOLID原则为标尺,动态选择最优模式组合。例如Spring事务管理中,代理模式+模板方法+责任链模式的协同应用,才是高阶面试的得分关键。

设计模式全景图谱与面试权重分布

根据2023年Java岗位面试真题大数据分析,我们将23种设计模式按考察频率与深度分为三级体系:

模式层级 代表模式 考察频率 考察深度 典型考题
一级必考 单例、工厂、代理、观察者 98.6% 源码分析+手写实现+场景优化 Spring单例注册表如何解决循环依赖?
二级高频 策略、装饰器、模板方法、责任链 82.4% 框架集成+扩展实现+性能对比 MyBatis插件机制如何体现责任链?
三级拓展 建造者、原型、适配器等 45.7% 概念辨析+典型场景 Lombok @Builder与原型模式区别?

特别提醒:单例模式在分布式环境下的变体(如Redis分布式单例、本地缓存+注册中心)已成为P6+岗位的隐藏考点,需重点关注。

单例模式:从基础实现到高阶工程实践

四种经典实现方式对比

基础单例需解决三大核心问题:实例唯一性、线程安全性、序列化安全。以下是四种主流实现的工程化考量:

// 1. 饿汉式:类加载即创建(线程安全但可能浪费资源)
public class HungrySingleton {
    private static final HungrySingleton INSTANCE = new HungrySingleton();
    private HungrySingleton() {}
    public static HungrySingleton getInstance() { return INSTANCE; }
}
// 2. 懒汉式:首次使用创建(需解决线程安全问题)
public class LazySingleton {
    private static LazySingleton instance;
    public static synchronized LazySingleton getInstance() {
        if (instance == null) instance = new LazySingleton();
        return instance;
    }
}
// 3. 双重检查锁:兼顾性能与安全(JDK5+)
public class DCLSingleton {
    private volatile static DCLSingleton instance;
    private DCLSingleton() {}
    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}
// 4. 静态内部类:JVM层面保证单例(推荐)
public class InnerClassSingleton {
    private InnerClassSingleton() {}
    private static class Holder {
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
    public static InnerClassSingleton getInstance() { return Holder.INSTANCE; }
}

【关键细节】:volatile关键字在双重检查锁中的作用是禁止指令重排,防止其他线程获取到未初始化完成的对象引用。

并发场景下的陷阱与对策

单例在分布式环境、反序列化、反射攻击下易失效,需综合防护:

  • 序列化破坏:实现readResolve()方法,返回唯一实例
  • 反射攻击:在构造器中检查实例是否存在,存在则抛异常
  • 反编译克隆:实现Cloneable时重写clone()返回自身
  • 容器破坏:Spring容器管理单例需配置@Scope("singleton")

【企业级实践】:阿里中间件Seata的GlobalSession管理器采用ConcurrentHashMap + 读写锁实现分布式单例,兼顾高并发与一致性。

Spring中的单例实现机制

Spring的单例管理远超基础单例,其核心特性包括:

  • 三级缓存解决循环依赖: singletonObjects(一级缓存)、earlySingletonObjects(二级缓存)、singletonFactories(三级缓存)
  • 工厂模式集成:通过ObjectFactory封装实例创建逻辑
  • 生命周期管理:支持InitializingBean、@PostConstruct等回调

【典型考题】:Spring如何解决AOP代理对象的循环依赖?
答:通过三级缓存中的singletonFactories提前暴露ObjectFactory,在依赖注入时动态生成代理对象,避免循环引用导致的死锁。

工厂模式:解耦对象创建的艺术

三种工厂模式的适用场景

工厂类型 核心特征 适用场景 反模式警示
简单工厂 静态方法+条件分支 对象创建逻辑简单(如日志级别) 违反开闭原则(增新产品需修改工厂)
工厂方法 抽象工厂+多实现类 产品族稳定(如数据库驱动) 每新增产品需新建工厂类(类爆炸)
抽象工厂 产品族+多产品线 多系列产品组合(如UI组件库) 增加产品线需修改所有工厂接口

【核心思想】:工厂模式本质是将对象创建与使用解耦,通过“高内聚的创建逻辑”降低业务代码复杂度。

Spring中的工厂模式应用

Spring的BeanFactory与ApplicationContext是工厂模式的集大成者:

// 核心接口定义
public interface BeanFactory {
    Object getBean(String name) throws BeansException;
     T getBean(String name, Class requiredType) throws BeansException;
}
// 典型实现类
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
    implements ConfigurableListableBeanFactory, BeanDefinitionRegistry { ... }

【关键机制】:Spring通过FactoryBean接口支持自定义工厂逻辑,例如MyBatis的SqlSessionFactoryBean:

// FactoryBean实现示例
public class SqlSessionFactoryBean implements FactoryBean {
    private Configuration configuration;
    @Override
    public SqlSessionFactory getObject() {
        return new SqlSessionFactoryBuilder().build(configuration);
    }
    @Override
    public Class getObjectType() {
        return SqlSessionFactory.class;
    }
}

自定义工厂的工程实践

在支付系统中,可设计策略模式+工厂模式组合方案:

// 支付策略接口
public interface PaymentStrategy {
    void pay(PaymentRequest request);
}
// 具体策略实现
public class WechatPayStrategy implements PaymentStrategy { ... }
public class AlipayStrategy implements PaymentStrategy { ... }
// 工厂类
public class PaymentStrategyFactory {
    private static final Map strategies = new ConcurrentHashMap<>();
    static {
        strategies.put("WECHAT", new WechatPayStrategy());
        strategies.put("ALIPAY", new AlipayStrategy());
    }
    public static PaymentStrategy getStrategy(String type) {
        return Optional.ofNullable(strategies.get(type.toUpperCase()))
            .orElseThrow(() -> new IllegalArgumentException("Unsupported payment type"));
    }
}

【进阶优化】:通过Spring的@Conditional注解实现动态注册策略,避免硬编码。

代理模式:控制对象访问的枢纽

静态代理与动态代理的本质差异

代理模式的核心是为真实对象提供代理以控制访问,分为两类实现路径:

  • 静态代理:编译期生成代理类(如Lombok的@With注解生成的代理)
  • 动态代理:运行时生成代理(JDK动态代理/CGLIB)

【典型应用】:Spring AOP的底层实现,通过代理对象在目标方法执行前后插入横切逻辑。

JDK动态代理的实现机制

JDK动态代理基于接口实现,核心类为Proxy与InvocationHandler:

// 代理创建示例
public class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;
    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("【前置日志】调用方法:" + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("【后置日志】返回值:" + result);
        return result;
    }
}
// 创建代理对象
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    new LoggingInvocationHandler(new UserServiceImpl())
);

【关键限制】:只能代理实现了接口的类,且代理对象与目标对象需实现相同接口。

CGLIB代理的深度解析

CGLIB通过继承目标类生成子类实现代理,适用于无接口场景:

// CGLIB代理实现
public class TransactionInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("【事务开始】");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("【事务提交】");
        return result;
    }
}
// 创建代理
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);
enhancer.setCallback(new TransactionInterceptor());
UserService proxy = (UserService) enhancer.create();

【Spring默认策略】:Spring AOP在以下情况自动切换代理方式:

  • 目标类实现接口 → JDK动态代理
  • 目标类无接口 → CGLIB代理
  • 强制CGLIB代理:配置@EnableAspectJAutoProxy(proxyTargetClass = true)

观察者模式:事件驱动架构的基石

经典观察者模式的两种形态

观察者模式定义对象间的一对多依赖关系,当主题对象状态改变时,所有依赖者自动更新:

// 抽象主题
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}
// 抽象观察者
public interface Observer {
    void update(String message);
}
// 具体实现
public class NewsAgency implements Subject {
    private List observers = new ArrayList<>();
    private String news;
    @Override
    public void registerObserver(Observer o) { observers.add(o); }
    @Override
    public void removeObserver(Observer o) { observers.remove(o); }
    @Override
    public void notifyObservers() {
        observers.forEach(o -> o.update(news));
    }
    public void setNews(String news) {
        this.news = news;
        notifyObservers(); // 状态改变时触发通知
    }
}

【设计要点】:需考虑通知顺序、异常隔离、异步通知等生产环境问题。

Spring事件监听机制

Spring的ApplicationEvent与ApplicationListener是观察者模式的典型应用:

// 自定义事件
public class UserRegisteredEvent extends ApplicationEvent {
    private final User user;
    public UserRegisteredEvent(Object source, User user) {
        super(source);
        this.user = user;
    }
    public User getUser() { return user; }
}
// 监听器实现
@Component
public class WelcomeEmailSender implements ApplicationListener {
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        emailService.sendWelcomeEmail(event.getUser().getEmail());
    }
}
// 发布事件
applicationContext.publishEvent(new UserRegisteredEvent(this, user));

【关键特性】:Spring 4.2+支持注解驱动的监听器:@EventListener,支持异步执行@Async。

响应式编程中的观察者模式

RxJava将观察者模式与迭代器模式结合,形成强大的数据流处理能力:

// 订阅者
Observer observer = new Observer() {
    @Override
    public void onNext(String s) { System.out.println("收到:" + s); }
    @Override
    public void onError(Throwable e) { e.printStackTrace(); }
    @Override
    public void onComplete() { System.out.println("完成"); }
};
// 被观察者
Observable.just("Hello", "World")
    .map(String::toUpperCase)
    .subscribe(observer);

【典型应用】:用户行为埋点、实时数据同步、订单状态变更通知等。

策略模式与模板方法模式的实战对比

在订单优惠计算场景中,两种模式可协同使用:

// 策略模式:定义算法族
public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal originalPrice, BigDecimal couponPrice);
}
// 具体策略
public class FullReductionStrategy implements DiscountStrategy { ... }
public class DiscountRateStrategy implements DiscountStrategy { ... }
// 模板方法:定义算法骨架
public abstract class OrderProcessor {
    // 模板方法
    public final BigDecimal processOrder(Order order) {
        BigDecimal basePrice = calculateBasePrice(order);
        BigDecimal discount = applyDiscount(basePrice, order);
        return finalizePrice(discount);
    }
    protected abstract BigDecimal calculateBasePrice(Order order);
    protected abstract DiscountStrategy getDiscountStrategy();
    private BigDecimal finalizePrice(BigDecimal discountedPrice) {
        // 统一处理税费、运费等
        return discountedPrice.add(calculatedTax(discountedPrice));
    }
}

【设计权衡】:

  • 策略模式:适合算法可替换场景(如不同优惠规则)
  • 模板方法:适合算法骨架固定、部分步骤可变的场景

【Spring应用】:JdbcTemplate是模板方法模式的典范,将数据库操作抽象为固定流程。

主流框架中的设计模式实战剖析

深入分析Spring、MyBatis等框架中的模式应用,揭示设计模式在真实项目中的落地细节:

Spring框架中的模式组合应用

核心容器的模式矩阵

模块 应用模式 代码示例 设计价值
BeanFactory 工厂模式+单例模式 DefaultListableBeanFactory 解耦对象创建与使用
AOP代理 代理模式+策略模式 JdkDynamicAopProxy 动态增强方法行为
事件机制 观察者模式 ApplicationEventPublisher 实现组件解耦通信
资源加载 装饰器模式 ResourceLoader 动态扩展资源处理能力

AOP代理的双重实现机制

Spring AOP通过Advisor(通知器)组合Advice(通知)与Pointcut(切点),最终由代理对象执行增强逻辑:

// 核心组件
public interface Advisor {
    Advice getAdvice();
    Pointcut getPointcut();
}
// 通知类型
public interface MethodInterceptor extends Advice {
    Object invoke(MethodInvocation invocation) throws Throwable;
}
// 代理创建入口
public class ProxyFactory extends ProxyCreatorSupport {
    public Object getProxy(ClassLoader classLoader) {
        return new ProxyFactory(this).createAopProxy().getProxy(classLoader);
    }
}

【面试高频追问】:Spring AOP与AspectJ AOP的区别?
答:Spring AOP基于动态代理(JDK/CGLIB),仅支持方法级切面;AspectJ基于字节码增强,支持字段、构造器等全粒度切面。

DispatcherServlet的请求处理流程

Spring MVC通过责任链模式处理请求,核心组件包括:

  • HandlerMapping:匹配请求到处理器(策略模式)
  • HandlerAdapter:适配不同类型的处理器(适配器模式)
  • HandlerInterceptor:拦截器链(责任链模式)

【典型流程】:

  1. DispatcherServlet接收请求
  2. 通过HandlerMapping获取HandlerExecutionChain
  3. 执行拦截器preHandle
  4. 通过HandlerAdapter调用处理器
  5. 执行视图渲染
  6. 执行拦截器afterCompletion

MyBatis中的设计模式应用

动态SQL的建造者模式

MyBatis的SqlSource体系采用建造者模式构建SQL:

// 建造者接口
public interface SqlSource {
    BoundSql getBoundSql(Object parameterObject);
}
// 动态SQL实现
public class DynamicSqlSource implements SqlSource {
    private final Configuration configuration;
    private final SqlNode rootSqlNode;
    @Override
    public BoundSql getBoundSql(Object parameterObject) {
        DynamicContext context = new DynamicContext(configuration, parameterObject);
        rootSqlNode.apply(context);
        SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
        return sqlSourceParser.parse(context.getSql(), parameterObject, context.getBindings());
    }
}

【关键点】:通过SqlNode接口的多种实现(IfSqlNode、TrimSqlNode等)组合实现动态SQL。

插件体系的责任链模式

MyBatis插件通过InterceptorChain构建责任链:

// 责任链处理
public class InterceptorChain {
    private final List interceptors = new ArrayList<>();
    public Object pluginAll(Object target) {
        for (Interceptor interceptor : interceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    }
}
// 插件接口
public interface Interceptor {
    Object intercept(Invocation invocation) throws Throwable;
    Object plugin(Object target);
}

【典型插件】:PageInterceptor(分页)、CacheInterceptor(缓存)均通过责任链拦截执行器方法。

高频面试问题深度解析

基于1000+份真实面试反馈,提炼最具区分度的问题及参考答案:

设计模式类问题TOP 10

设计原则类问题

  • 问:开闭原则如何落地?
    答:通过抽象接口+实现类解耦,新增功能时扩展实现类而非修改现有代码。例如Spring的ApplicationContextInitializer扩展点。
  • 问:依赖倒置原则与控制反转的区别?
    答:依赖倒置是设计原则(高层模块不依赖低层模块),控制反转是实现手段(将对象创建权交给容器)。
  • 问:接口隔离原则如何避免“胖接口”?
    答:按角色拆分接口,例如MyBatis的StatementHandler拆分为BaseStatementHandler与具体实现类。

实现细节类问题

  • 问:Spring事务失效的常见场景?
    答:①非public方法 ②自调用问题 ③异常被捕获未抛出 ④代理失效(如使用@Transactional的类未被Spring管理)。
  • 问:CGLIB代理为何不能代理final类?
    答:CGLIB通过继承生成子类,final类无法被继承,故无法生成代理对象。
  • 问:单例模式如何解决序列化问题?
    答:实现readResolve()方法返回唯一实例,防止反序列化创建新对象。

模式对比类问题

对比维度 适配器模式 装饰器模式 代理模式
核心目的 接口转换 功能增强 控制访问
关系类型 一对一 树形嵌套 一对一/一对多
典型应用 Log4j适配器 Java IO流 Spring AOP

系统化准备策略

从知识体系构建到实战演练的全流程指南:

设计模式学习路线图

四阶段学习法

  1. 基础认知:理解GOF 23种模式定义与UML图,推荐《研磨设计模式》
  2. 框架映射:将模式对应到Spring/MyBatis源码,绘制模式分布图
  3. 场景实战:在个人项目中刻意应用设计模式,记录决策过程
  4. 深度追问:准备“为什么用此模式”、“替代方案对比”等高阶问题

高价值学习资源

  • 源码阅读:Spring Framework 5.3+源码(重点:DefaultSingletonBeanRegistry、JdkDynamicAopProxy)
  • 开源项目:MyBatis Plugin(插件体系)、Netty HandlerChain(责任链)
  • 实战项目:自研轻量级DIY Spring(实现IoC容器+AOP代理)
  • 面试题库:LeetCode设计模式专题、牛客网高频面试题

常见设计模式误用场景

误用模式 典型场景 正确做法
过度使用单例 将所有工具类设为单例 仅共享状态对象用单例,无状态类用静态方法
滥用装饰器 为简单功能添加多层装饰 装饰层数≤3,考虑组合模式替代
错误使用工厂 为单例对象创建工厂 仅当创建逻辑复杂时使用工厂
混淆代理与装饰 代理实现功能增强 代理侧重控制访问,装饰侧重增强功能

面试加分项清单

超越标准答案的差异化竞争力构建:

技术深度拓展方向

设计模式底层原理

  • 代理模式:理解JVM字节码增强原理(ASM/Javassist)
  • 工厂模式:掌握Spring容器启动流程中的BeanDefinition注册时机
  • 策略模式:研究JDK并发包中策略模式的应用(如ThreadLocalRandom)

业务场景映射

在电商场景中设计模式的组合应用:

  • 下单流程:责任链(优惠计算)+策略(支付方式)+观察者(库存扣减)
  • 商品搜索:装饰器(过滤条件)+工厂(搜索策略)+模板方法(排序规则)
  • 订单状态机:状态模式(订单状态)+命令模式(状态变更)

架构级设计模式思考

高级工程师应具备的模式演进视角:

  • 模式组合:在复杂系统中混合使用多种模式(如Spring中工厂+单例+代理)
  • 模式演进:根据系统复杂度动态调整模式(简单系统用简单工厂,复杂系统用抽象工厂)
  • 模式重构:通过重构将“模式反模式”(如上帝类)逐步转化为合理设计

【企业案例】:某支付系统从简单工厂重构为策略+工厂组合模式,新增支付渠道开发周期从3天缩短至2小时。

网友们还关心的问题

设计模式学习时间投入建议

根据岗位要求差异化投入:

岗位级别 建议学习时间 重点掌握模式 应试策略
初级(1-2年) 30-50小时 单例、工厂、观察者 理解定义+能画UML图
中级(3-5年) 80-120小时 策略、装饰器、代理 源码分析+手写实现
高级(5年+) 持续深化 组合模式+架构演进 场景设计+陷阱规避

实战项目设计建议

推荐3个可落地的实战项目方向:

  • DIY Spring容器:实现基础IoC+AOP,理解Bean生命周期
  • 订单状态机引擎:用状态模式+策略模式实现订单流转
  • 日志收集系统:责任链模式实现多级日志处理

【关键建议】:在GitHub记录开发过程,面试时可展示设计决策文档。

设计模式与职业发展

不同阶段的设计模式价值:

  • 1-3年:提升代码质量,减少重复造轮子
  • 3-5年:支撑系统扩展,避免“屎山”积累
  • 5年+:主导架构演进,设计可维护的系统

【真实反馈】:某工程师通过设计模式重构核心模块,系统性能提升40%,获晋升P7。