java面试中的设计模式

一、为何设计模式是Java面试的“必考项”?

在Java技术栈中,设计模式早已不是理论层面的“锦上添花”,而是企业级系统构建的基石。从Spring框架底层到微服务架构,从高并发系统到高可用中间件,设计模式的身影无处不在。面试官考察设计模式,核心目的有三:其一,检验你是否具备抽象建模能力;其二,判断你能否在真实业务场景中灵活应用;其三,评估你对系统扩展性与可维护性的理解深度。

据2024年国内头部互联网企业(阿里、腾讯、字节、华为等)校招与社招面经统计,**设计模式相关问题**在后端开发岗位面试中出现频率高达89.7%,其中“单例模式线程安全实现”、“代理模式在AOP中的应用”、“策略模式替代if-else”等成为高频考点。更值得注意的是,**高级工程师岗位往往要求候选人能结合源码分析**(如Spring中FactoryBean的工厂模式、JDK动态代理的代理模式),而非仅停留在概念层面。

⚠️ 常见误区:将设计模式等同于“背口诀”。实际上,面试官更关注你是否理解模式背后的**设计原则**——开闭原则(OCP)、依赖倒置原则(DIP)、接口隔离原则(ISP)等。例如,工厂模式并非简单“创建对象”,而是为了解耦对象的创建与使用,使系统更易扩展新产品族。

二、设计模式的底层逻辑:六大原则深度拆解

所有23种经典设计模式均服务于六大核心设计原则,掌握这些原则是理解模式本质的关键:

① 单一职责原则(SRP)

一个类只负责一个职责。违反SRP会导致类职责混乱、维护困难。例如:

// ❌ 违反SRP:UserManager既要管理用户信息,又要处理日志
public class UserManager {
    public void save(User user) {  }
    public void log(String action) {  }
}
// ✅ 符合SRP:拆分为两个类
public class UserManager {
    public void save(User user) {  }
}
public class Logger {
    public void log(String action) {  }
}

② 里氏替换原则(LSP)

子类对象能替换父类对象而不影响程序正确性。若子类重写父类方法后导致行为异常,则违反LSP。例如:

class Rectangle { int w, h; }
class Square extends Rectangle {
    void setSide(int s) { w = h = s; }
}
// ❌ 调用setW(5)后,square.getH()应为5,但若父类setW仅改w则出错

③ 依赖倒置原则(DIP)

高层模块不依赖低层模块,二者都依赖抽象。Spring的@Autowired正是DIP的典型应用——Controller依赖Service接口而非具体实现类。

④ 接口隔离原则(ISP)

客户端不应依赖它不需要的接口。将庞大接口拆分为小而专的接口,如:

// ❌ 大而全接口
interface Worker { void work(); void eat(); }
// ✅ 拆分为Workable与Eatable
interface Workable { void work(); }
interface Eat { void eat(); }

⑤ 迪米特法则(LoD)

一个对象应尽量少了解其他对象。例如避免在Service中直接调用Repository以外的类,减少耦合。

⑥ 开闭原则(OCP)

对扩展开放,对修改关闭。策略模式正是OCP的典范——新增新算法只需添加新策略类,无需修改原有上下文代码。

三、高频考点设计模式详解(附真实面试题)

3.1 创建型模式

单例模式
工厂模式
建造者模式

单例模式:线程安全与性能的平衡

单例模式确保一个类只有一个实例,并提供全局访问点。Java中常见实现方式及面试陷阱:

  • 饿汉式:类加载即创建,线程安全但可能浪费资源
  • 懒汉式(线程不安全):面试中若直接写出此版会被扣分
  • 双重检查锁(DCL):需加volatile防止指令重排序
  • 静态内部类:推荐写法,利用JVM类加载机制保证线程安全
public class Singleton {
    private Singleton() {}
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

💡 真实场景:Spring容器中Bean默认单例;数据库连接池、缓存管理器常采用单例。

工厂模式:解耦对象创建

工厂模式将对象创建逻辑集中管理,使系统更易扩展新产品。常见变体:

  • 简单工厂:非23种标准模式,但面试常考
  • 工厂方法:定义创建接口,子类决定实例化哪个类
  • 抽象工厂:创建产品族(如MySQL/JDBC驱动系列)
// 工厂方法示例:JDBC驱动注册
interface Driver { void connect(); }
class MySQLDriver implements Driver { public void connect() { ... } }
class DriverFactory {
    public Driver createDriver(String type) {
        return switch(type) {
            case "mysql" -> new MySQLDriver();
            case "oracle" -> new OracleDriver();
            default -> throw new IllegalArgumentException();
        };
    }
}

💡 Spring中BeanFactory是工厂模式的典型应用;MyBatis中SqlSessionFactory用于创建SqlSession。

建造者模式:复杂对象的分步构建

当对象构造参数众多或存在可选参数时,建造者模式避免构造函数爆炸。常见于:

  • StringBuilder:链式追加字符串
  • OkHttp的Request.Builder:构建HTTP请求
  • Lombok的@Builder:注解自动生成建造者代码
public class Meal {
    private String main;
    private String side;
    private String drink;
    private Meal(Builder builder) {
        this.main = builder.main;
        this.side = builder.side;
        this.drink = builder.drink;
    }
    public static class Builder {
        private String main;
        private String side = " fries"; // 默认值
        private String drink = " water";
        public Builder setMain(String main) { this.main = main; return this; }
        public Builder setSide(String side) { this.side = side; return this; }
        public Builder setDrink(String drink) { this.drink = drink; return this; }
        public Meal build() { return new Meal(this); }
    }
}

3.2 结构型模式

代理模式
装饰器模式
适配器模式

代理模式:AOP的底层基石

代理模式为对象提供代理以控制访问。Java中两大实现方式:

  • 静态代理:手动编写代理类(如JDK动态代理生成的$Proxy0)
  • 动态代理:JDK动态代理(基于接口)与CGLIB(基于继承)

⚡ 面试高频问题:JDK动态代理与CGLIB的区别?

  • JDK代理要求目标类实现接口;CGLIB通过继承实现,可代理无接口类
  • JDK代理使用InvocationHandler;CGLIB使用MethodInterceptor
  • Spring AOP默认:有接口用JDK,无接口用CGLIB
// JDK动态代理核心代码
public class LoggingProxy implements InvocationHandler {
    private final Object target;
    public LoggingProxy(Object target) { this.target = target; }
    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;
    }
}

装饰器模式:动态增强功能

装饰器模式在不修改原对象的前提下,动态添加新功能。典型应用:

  • Java IO流:BufferedInputStream装饰FileInputStream
  • Servlet过滤器链:FilterChain层层包装
  • Spring Security:SecurityContextPersistenceFilter等
interface Component { void operation(); }
class ConcreteComponent implements Component {
    public void operation() { System.out.println("核心逻辑"); }
}
class Decorator implements Component {
    protected Component component;
    public Decorator(Component component) { this.component = component; }
    public void operation() { component.operation(); }
}
class LoggingDecorator extends Decorator {
    public LoggingDecorator(Component component) { super(component); }
    public void operation() {
        System.out.println("【日志】开始执行");
        super.operation();
        System.out.println("【日志】执行结束");
    }
}

适配器模式:兼容性改造器

适配器模式将接口转换为客户期望的接口。常见场景:

  • Log4j2桥接器:将SLF4J日志适配到Log4j2实现
  • Spring的HandlerAdapter:统一处理不同类型的Controller
  • JDK的Collections.synchronizedList
// Spring HandlerAdapter示例
interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(Object handler);
}
class SimpleControllerHandlerAdapter implements HandlerAdapter {
    public boolean supports(Object handler) {
        return handler instanceof Controller;
    }
    public ModelAndView handle(Object handler) {
        return ((Controller) handler).handleRequest(...);
    }
}

3.3 行为型模式

观察者模式
策略模式
模板方法

观察者模式:事件驱动架构的核心

观察者模式定义对象间的一对多依赖关系。Java中实现方式:

  • JDK内置Observer接口(已过时,不推荐)
  • Guava EventBus:基于注解的事件总线
  • Spring ApplicationEvent:ApplicationContext事件机制

⚡ 真实案例:用户注册成功后,发送欢迎邮件、积分奖励、日志记录等操作可通过观察者模式解耦:

// Spring事件发布
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher publisher;
    public void register(User user) {
        // 保存用户...
        publisher.publishEvent(new UserRegisteredEvent(this, user));
    }
}
// 监听器
@Component
public class WelcomeEmailListener {
    @EventListener
    public void onUserRegistered(UserRegisteredEvent event) {
        emailService.send(event.getUser().getEmail(), "欢迎注册!");
    }
}

策略模式:替代冗长的if-else

策略模式定义一系列算法,使它们可互换。面试中高频考察“如何用策略模式优化if-else”:

  • 传统if-else:新增规则需修改源码
  • 策略+工厂:新增策略类即可,符合开闭原则
// 策略接口
interface DiscountStrategy {
    BigDecimal calculate(BigDecimal original);
}
// 具体策略
class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal original) {
        return original.multiply(new BigDecimal("0.8"));
    }
}
// 上下文
class PriceContext {
    private DiscountStrategy strategy;
    public PriceContext(DiscountStrategy strategy) { this.strategy = strategy; }
    public BigDecimal getPrice(BigDecimal original) {
        return strategy.calculate(original);
    }
}
// 优化后:通过Map注册策略
enum DiscountType { VIP, GROUP, SEASONAL }
class DiscountFactory {
    private static final Map STRATEGIES = new HashMap<>();
    static {
        STRATEGIES.put(DiscountType.VIP, new VipDiscount());
        // 其他策略...
    }
    public static DiscountStrategy getStrategy(DiscountType type) {
        return STRATEGIES.get(type);
    }
}

模板方法:复用算法骨架

模板方法定义算法骨架,子类重写特定步骤。典型应用:

  • Servlet的doGet/doPost:service()为模板方法
  • Spring JdbcTemplate:execute()封装连接管理
  • MyBatis BaseExecutor:query()定义查询流程
abstract class DataProcessor {
    public final void process() {
        open(); // 钩子方法
        read();
        transform();
        write();
        close();
    }
    protected abstract void read();
    protected abstract void write();
    protected void open() { } // 默认空实现
    protected void close() { }
}
class CSVProcessor extends DataProcessor {
    protected void read() {  }
    protected void write() {  }
}

3.4 高频补充模式

门面模式(Facade)

为子系统提供统一入口。Spring中DispatcherServlet是典型门面,统一处理所有HTTP请求。

责任链模式(Chain of Responsibility)

将请求沿处理链传递。MyBatis的Interceptor链、Spring Security过滤器链均基于此模式。

状态模式(State)

允许对象在内部状态改变时改变行为。电商订单状态流转(待付款→已付款→已发货)可避免大量状态if-else。

四、Spring与JDK源码中的设计模式实战解析

深入源码是理解设计模式的终极途径。以下为高频考察点:

4.1 Spring框架中的模式应用

🔍 源码定位技巧:

4.2 JDK核心类中的模式

💡 面试加分点:能说出具体类名及源码位置,例如:

“Spring中BeanDefinitionReader利用装饰器模式包装InputStream,通过XmlBeanDefinitionReader解析XML配置。”

五、网友最关心的10个问题深度解答

Q1:如何向面试官展示设计模式能力?
Q2:实际项目中用过哪些模式?
Q3:单例与静态类的区别?
Q4:代理与装饰器的区别?
Q5:如何选择代理模式的实现方式?

如何向面试官展示设计模式能力?

❌ 错误做法:背诵模式定义

✅ 正确姿势:

  1. 结合项目:描述具体业务场景(如“订单状态管理”)
  2. 说明问题:原方案存在什么痛点(如“if-else嵌套5层”)
  3. 展示方案:用策略模式重构,新增状态只需加类
  4. 量化收益:代码行数减少40%,新需求开发时间缩短60%

实际项目中用过哪些模式?

推荐回答模板:

“在电商促销系统中,我使用策略模式重构了优惠计算模块。原方案if-else判断10种优惠类型,新增活动需修改核心逻辑。重构后:1)定义DiscountStrategy接口;2)为每种活动实现策略类;3)通过配置中心动态加载策略。结果:新活动上线周期从3天缩短到2小时。”

单例与静态类的区别?

  • 单例:可继承、实现接口、支持懒加载、线程安全可控
  • 静态类:无法实现接口、无法继承、类加载即初始化

💡 关键差异:单例对象可被注入(如Spring管理),静态类只能通过类名调用。

代理与装饰器的区别?

  • 代理:控制访问,侧重“代理对象代替真实对象”
  • 装饰器:增强功能,侧重“动态添加行为”

💡 形象理解:代理是“中介”,装饰器是“外挂”。

如何选择代理模式的实现方式?

  1. 目标类有接口 → JDK动态代理(性能好、无依赖)
  2. 目标类无接口 → CGLIB(需引入依赖)
  3. 需要拦截构造器 → CGLIB
  4. 追求极致性能 → 字节码技术(ASM)

⚡ Spring 5+默认:有接口用JDK,无接口用CGLIB(基于字节码生成)

六、学习资源与成长路径推荐

经典书籍

  • 《设计模式:可复用面向对象软件的基础》——GoF经典
  • 《Head First设计模式》——新手友好
  • 《Spring源码深度解析》——结合框架实战

在线资源

  • Refactoring.Guru中文站:https://refactoringguru.cn/design-patterns
  • GitHub项目:spring-framework源码阅读指南
  • 技术博客:Java技术栈、 Hollis、纯洁的微笑

学习路径建议

  1. 掌握六大设计原则(优先级最高)
  2. 动手实现5种核心模式(单例、工厂、代理、策略、观察者)
  3. 精读Spring核心类源码(BeanFactory、AopProxy)
  4. 在项目中刻意应用,而非强行套用

常见错误认知纠正