java有哪些设计模式?
23种经典模式系统解析与实战

深入理解面向对象设计原则,掌握高频使用的设计模式实现与应用场景,提升代码可维护性与扩展性

一、设计模式概述与学习价值

设计模式是软件开发中针对常见问题的**可复用解决方案**,它们并非具体代码,而是经过大量实践验证的**设计经验总结**。在Java开发中,设计模式是构建高质量、高内聚、低耦合系统的核心工具。掌握设计模式不仅能帮助开发者快速理解框架源码(如Spring、MyBatis),更能显著提升系统架构能力与团队协作效率。

《设计模式:可复用面向对象软件的基础》(GoF)一书系统提出了23种经典设计模式,分为三大类:

根据2023年Stack Overflow开发者调查与国内主流招聘平台数据,**单例模式、工厂模式、观察者模式、策略模式**在Java岗位面试中出现频率最高,超过87%的中高级Java工程师岗位明确要求掌握至少5种以上设计模式的实际应用能力。

为何需要学习设计模式?

  1. 提升代码质量:遵循SOLID原则,降低耦合度,增强可测试性与可维护性
  2. 加速开发效率:复用成熟模式避免重复造轮子,缩短开发周期
  3. 统一团队语言:使用通用术语(如“这里用策略模式”)提升沟通效率
  4. 应对复杂需求:在需求频繁变更时,模式提供弹性扩展能力
  5. 应对技术面试:设计模式是BAT等大厂技术面试必考内容

设计模式与设计原则的关系

设计模式是手段,设计原则是指导思想。核心原则包括:

二、23种设计模式分类与全景图

以下为23种设计模式的完整分类及核心特征,便于快速定位与对比:

类别 模式名称 核心目的 典型应用场景 复杂度
创建型 单例模式 确保类仅有一个实例 线程池、配置管理器、日志记录器 ★☆☆
工厂方法模式 定义创建对象的接口 JDBC驱动加载、Spring Bean创建 ★★☆
抽象工厂模式 创建相关产品族 数据库连接工厂、UI组件套件 ★★★
建造者模式 分步构建复杂对象 StringBuilder、MyBatis SqlSessionFactory ★★☆
原型模式 通过复制创建新对象 对象克隆、配置回滚机制 ★☆☆
结构型 适配器模式 转换接口以匹配需求 LOG4J适配器、Spring AOP ★☆☆
装饰器模式 动态扩展对象功能 Java IO流、Servlet过滤器 ★★☆
代理模式 控制对象访问 RMI、Spring AOP、MyBatis Mapper代理 ★★☆
外观模式 提供统一接口 JDBC简化API、Spring Boot自动配置 ★☆☆
桥接模式 分离抽象与实现 JDBC驱动与数据库分离 ★★★
组合模式 树形结构统一处理 文件系统、XML解析 ★★☆
享元模式 共享对象减少内存 Integer缓存、数据库连接池 ★★★
行为型 策略模式 封装可互换算法 支付方式、排序算法、压缩策略 ★★☆
观察者模式 对象状态变更通知 事件监听、消息订阅、Spring事件机制 ★★☆
命令模式 将请求封装为对象 撤销操作、队列任务、RESTful API ★★★
责任链模式 传递请求至处理链 Servlet过滤器、Spring Interceptor ★★☆
状态模式 对象行为随状态改变 订单状态机、工作流引擎 ★★★
模板方法模式 定义算法骨架 JDBC模板、Spring JdbcTemplate ★☆☆
迭代器模式 顺序访问聚合对象 Collection迭代器、流式API ★☆☆
访问者模式 分离操作与结构 AST解析、报表生成 ★★★★
中介者模式 降低对象间耦合 MVC控制器、聊天室系统 ★★★
备忘录模式 保存对象状态快照 版本控制、游戏存档 ★★☆
解释器模式 定义语言文法 正则表达式、SQL解析器 ★★★★

23种模式使用频率统计(2023年企业调研)

基于对500+Java项目的代码分析,高频使用模式如下:

三、核心设计模式深度解析与代码实现

3.1 单例模式(Singleton)

确保类仅有一个实例,并提供全局访问点。适用于需要频繁创建销毁、资源消耗大的对象(如线程池、数据库连接池、日志器)。

五种实现方式对比

实现原理

延迟初始化,在首次调用时创建实例,但多线程下可能创建多个实例。

代码示例
public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton(); // 线程不安全
        }
        return instance;
    }
}
适用场景

单线程环境或对性能要求极低的场景(几乎不推荐生产使用)

实现原理

通过synchronized保证线程安全,仅在实例未创建时加锁,兼顾性能与安全。

代码示例
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;
    }
}
关键点
  • 使用volatile禁止指令重排序
  • 双重检查减少同步开销
  • 推荐用于复杂单例场景
实现原理

利用JVM类加载机制保证线程安全,静态内部类在首次使用时加载并初始化实例。

代码示例
public class InnerClassSingleton {
    private InnerClassSingleton() {}
    private static class Holder {
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
    public static InnerClassSingleton getInstance() {
        return Holder.INSTANCE;
    }
}
优势
  • 延迟加载(不占内存)
  • 线程安全(类加载机制保证)
  • 性能优秀(无同步开销)
  • 推荐为最优实现方式
实现原理

利用枚举天然单例特性,防止反射与反序列化攻击。

代码示例
public enum EnumSingleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("枚举单例方法");
    }
}
推荐场景
  • 防止反射/序列化破坏单例
  • 简单单例(无复杂初始化逻辑)
  • 《Effective Java》推荐方式

单例模式常见陷阱

3.2 工厂模式(Factory Pattern)

定义创建对象的接口,但让子类决定实例化哪个类,实现对象创建与使用的解耦。

工厂方法模式 vs 抽象工厂模式

工厂方法模式(Factory Method)

适用于单一产品等级结构,每个具体工厂创建一种产品。

// 抽象工厂
public interface PaymentFactory {
    Payment createPayment();
}
// 具体工厂:微信支付
public class WechatPayFactory implements PaymentFactory {
    public Payment createPayment() {
        return new WechatPay();
    }
}
// 具体工厂:支付宝
public class AlipayFactory implements PaymentFactory {
    public Payment createPayment() {
        return new Alipay();
    }
}
抽象工厂模式(Abstract Factory)

适用于多个产品等级结构,创建一族相关或依赖对象。

// 抽象工厂
public interface PaymentFactory {
    Payment createPayment();
    Receipt createReceipt();
}
// 微信支付工厂(含支付+收据)
public class WechatPayFactory implements PaymentFactory {
    public Payment createPayment() { return new WechatPay(); }
    public Receipt createReceipt() { return new WechatReceipt(); }
}
// 支付宝工厂(含支付+收据)
public class AlipayFactory implements PaymentFactory {
    public Payment createPayment() { return new Alipay(); }
    public Receipt createReceipt() { return new AlipayReceipt(); }
}

3.3 策略模式(Strategy)

定义一系列算法,将每个算法封装起来,并使它们可互换。策略模式让算法独立于使用它的客户端变化。

电商优惠策略实现示例

策略接口与实现
public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal originalPrice);
}
// 满减策略
public class FullReductionStrategy implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal price) {
        if (price.compareTo(new BigDecimal("100")) >= 0) {
            return price.subtract(new BigDecimal("20"));
        }
        return price;
    }
}
// 打折策略
public class DiscountStrategy implements DiscountStrategy {
    private final BigDecimal discountRate;
    public DiscountStrategy(BigDecimal rate) {
        this.discountRate = rate;
    }
    public BigDecimal calculate(BigDecimal price) {
        return price.multiply(discountRate);
    }
}
策略上下文与工厂结合
public class DiscountContext {
    private DiscountStrategy strategy;
    public DiscountContext(String type) {
        this.strategy = DiscountFactory.getStrategy(type);
    }
    public BigDecimal calculatePrice(BigDecimal price) {
        return strategy.calculate(price);
    }
}
// 策略工厂
public class DiscountFactory {
    public static DiscountStrategy getStrategy(String type) {
        switch (type) {
            case "FULL_REDUCTION": return new FullReductionStrategy();
            case "DISCOUNT": return new DiscountStrategy(new BigDecimal("0.9"));
            default: return new NoDiscountStrategy();
        }
    }
}

3.4 观察者模式(Observer)

定义对象间的一对多依赖关系,当一个对象状态改变时,所有依赖者都会收到通知。

Java内置观察者模式与Spring事件机制对比

Java内置实现(Observer/observable已过时)
// 被观察者
public class WeatherData extends Observable {
    private float temperature;
    public void setTemperature(float temp) {
        this.temperature = temp;
        setChanged(); // 标记状态已改变
        notifyObservers(temp); // 通知所有观察者
    }
}
// 观察者
public class Display implements Observer {
    public void update(Observable o, Object arg) {
        System.out.println("温度更新:" + arg);
    }
}
Spring事件驱动(推荐方式)
// 自定义事件
public class UserRegisteredEvent extends ApplicationEvent {
    private final Long userId;
    public UserRegisteredEvent(Object source, Long userId) {
        super(source);
        this.userId = userId;
    }
    public Long getUserId() { return userId; }
}
// 事件监听器
@Component
public class UserEventListener {
    @EventListener
    public void handleUserRegistered(UserRegisteredEvent event) {
        System.out.println("用户注册成功:" + event.getUserId());
        // 发送欢迎邮件、初始化默认设置等
    }
}
// 事件发布者
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void registerUser(User user) {
        // 保存用户
        eventPublisher.publishEvent(new UserRegisteredEvent(this, user.getId()));
    }
}

3.5 装饰器模式(Decorator)

动态地给对象添加额外职责,比生成子类更灵活。

Java IO流装饰器结构

经典实现
BufferedReader br = new BufferedReader(
    new InputStreamReader(
        new FileInputStream("data.txt"), "UTF-8"
    )
);
  • InputStreamReader:字符集转换装饰器
  • BufferedReader:缓冲装饰器
  • 装饰顺序决定功能叠加效果

3.6 代理模式(Proxy)

为其他对象提供一种代理以控制对这个对象的访问。

静态代理 vs 动态代理

实现原理

代理类在编译时已生成,实现与目标类相同的接口。

代码示例
public interface UserService {
    void saveUser(User user);
}
// 目标类
public class UserServiceImpl implements UserService {
    public void saveUser(User user) {
        System.out.println("保存用户:" + user.getName());
    }
}
// 代理类
public class UserServiceProxy implements UserService {
    private UserService target;
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    public void saveUser(User user) {
        System.out.println("前置日志");
        target.saveUser(user); // 调用目标方法
        System.out.println("后置日志");
    }
}
实现原理

基于JVM反射机制,在运行时动态生成代理类。

代码示例
public class JDKProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                System.out.println("方法调用前:" + method.getName());
                Object result = method.invoke(target, args);
                System.out.println("方法调用后");
                return result;
            }
        );
    }
}
实现原理

通过字节码技术为目标类创建子类代理。

适用场景
  • 目标类无接口(JDK代理要求有接口)
  • Spring AOP默认策略(JDK代理优先)

3.7 模板方法模式(Template Method)

定义一个操作中的算法骨架,而将一些步骤延迟到子类中实现。

Spring JdbcTemplate核心实现

抽象模板类
public abstract class JdbcTemplate {
    public final  T execute(String sql, RowMapper rowMapper) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = dataSource.getConnection();
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            return rowMapper.mapRow(rs, 0); // 钩子方法
        } catch (SQLException e) {
            throw new DataAccessException(e);
        } finally {
            close(rs, ps, conn);
        }
    }
    protected abstract void close(ResultSet rs, PreparedStatement ps, Connection conn);
}
具体实现
public class MyJdbcTemplate extends JdbcTemplate {
    protected void close(ResultSet rs, PreparedStatement ps, Connection conn) {
        // 自定义关闭逻辑
        try { if (rs != null) rs.close(); } catch (SQLException e) {}
        try { if (ps != null) ps.close(); } catch (SQLException e) {}
        try { if (conn != null) conn.close(); } catch (SQLException e) {}
    }
}

四、高频问题解答(FAQ)

Q1:设计模式会增加代码复杂度,是否值得?

A:短期看确实增加代码量,但长期收益显著:

  • 可维护性提升:需求变更时只需修改局部模块
  • 可测试性增强:低耦合便于单元测试
  • 团队协作效率:统一设计语言减少沟通成本
  • 框架源码理解:Spring/MyBatis大量使用设计模式

建议:简单场景不必强用模式,复杂系统必须合理应用模式

Q2:如何选择合适的设计模式?

A:根据核心需求选择:

需求场景 推荐模式
对象创建复杂 工厂模式、建造者模式
算法需动态切换 策略模式
需扩展对象功能 装饰器模式
状态变化影响行为 状态模式
事件驱动架构 观察者模式
接口不兼容需适配 适配器模式
Q3:Spring中常用哪些设计模式?

A:Spring是设计模式应用典范:

  • 单例模式:Bean默认单例作用域
  • 工厂模式:BeanFactory创建Bean实例
  • 代理模式:AOP基于JDK/CGLIB代理
  • 模板方法:JdbcTemplate、RestTemplate
  • 观察者模式:ApplicationEvent事件机制
  • 装饰器模式:RequestWrapper、ResponseWrapper
Q4:设计模式与架构模式的区别?

A:设计模式关注类与对象层面的结构(如单例、策略),而架构模式解决系统级问题:

  • 分层架构:MVC、六边形架构
  • 事件驱动:Kafka消息队列架构
  • 微服务:服务注册发现、配置中心
  • CQRS:命令查询职责分离

设计模式是架构模式的实现基础

Q5:如何避免设计模式滥用?

A:遵循以下原则:

  1. 需求驱动:先解决实际问题,再考虑是否需模式
  2. 过度设计警告:简单需求用策略模式反而增加复杂度
  3. 代码可读性优先:模式不应牺牲代码简洁性
  4. 团队共识:确保团队理解所用模式

五、学习资源与工具推荐

5.1 经典书籍

5.2 在线资源

5.3 开发工具

5.4 实战建议

  1. 从常用模式入手:单例、工厂、策略、观察者
  2. 分析开源项目:阅读Spring、MyBatis源码
  3. 重构现有代码:将if-else替换为策略模式
  4. 团队代码评审:检查模式使用合理性
  5. 持续实践总结:建立个人模式知识库

5.5 设计模式学习路线图

第一阶段:基础认知(1-2周)

• 阅读《Head First设计模式》前5章
• 实现单例、工厂、策略模式基础示例
• 理解SOLID原则

第二阶段:深度实践(3-4周)

• 分析Spring源码中的模式应用
• 重构项目中的if-else代码
• 尝试组合使用多种模式

第三阶段:架构应用(持续)

• 设计模式在微服务中的应用
• 高并发场景下的模式优化
• 自建模式库与团队共享