java中的23种设计模式实战(含Java代码示例、核心思想、适用场景)

设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结,使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性,这篇文章主要介绍了java中的23种设计模式的相关资料,需要的朋友可以参考下

前言

Java 中的设计模式是一套经过长期实践总结的可复用代码设计解决方案，核心用于解决软件设计中反复出现的问题，提升代码的可复用性、可维护性、扩展性和松耦合性，是 Java 高级开发、框架设计和面试的核心考点。

设计模式主流遵循 Gang of Four 定义的 23 种经典设计模式，并按设计目的和应用场景分为三大核心类别：创建型模式（解决对象创建问题）、结构型模式（解决类 / 对象的组合结构问题）、行为型模式（解决类 / 对象之间的交互和职责分配问题）。

以下按类别详细讲解高频常用的设计模式（含 Java 代码示例、核心思想、适用场景），兼顾理解与实战，同时标注框架中典型应用（如 Spring、MyBatis 等），贴合企业开发实际。

一、创建型模式（共 5 种）

核心目标：封装对象的创建过程，将对象创建与业务逻辑解耦，避免直接使用 new 关键字导致的耦合过高、创建逻辑复杂等问题，方便后续替换或扩展对象类型。

1. 单例模式（Singleton）

• 核心思想：保证一个类在整个应用中只有一个实例，并提供全局唯一的访问入口。
• 适用场景：工具类、配置类、数据库连接池、Redis 客户端实例（避免频繁创建销毁资源）。
• Java 经典实现（懒汉式 - 双重检查锁，线程安全 + 懒加载）：

  public class Singleton {
      // volatile 禁止指令重排，保证实例初始化完成后再被访问
      private static volatile Singleton instance;
      
      // 私有构造方法，禁止外部new创建
      private Singleton() {}
      
      // 双重检查锁：第一次检查避免频繁加锁，第二次检查保证线程安全
      public static Singleton getInstance() {
          if (instance == null) {
              synchronized (Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }
  

• 框架应用：Spring 中所有单例 Bean（默认作用域 singleton）、MyBatis 的 SqlSessionFactory。

2. 工厂方法模式（Factory Method）

• 核心思想：定义创建对象的接口，让子类决定具体创建哪个类的实例，将对象创建延迟到子类。
• 适用场景：产品类型有多个子类，且后续可能扩展新子类（如日志框架支持文件日志、控制台日志）。
• Java 示例：

  // 产品接口
  public interface Logger {
      void log(String msg);
  }
  // 具体产品1：控制台日志
  public class ConsoleLogger implements Logger {
      @Override
      public void log(String msg) {
          System.out.println("控制台日志：" + msg);
      }
  }
  // 具体产品2：文件日志
  public class FileLogger implements Logger {
      @Override
      public void log(String msg) {
          System.out.println("文件日志：" + msg);
      }
  }
  // 工厂接口
  public interface LoggerFactory {
      Logger createLogger();
  }
  // 具体工厂1：创建控制台日志
  public class ConsoleLoggerFactory implements LoggerFactory {
      @Override
      public Logger createLogger() {
          return new ConsoleLogger();
      }
  }
  // 具体工厂2：创建文件日志
  public class FileLoggerFactory implements LoggerFactory {
      @Override
      public Logger createLogger() {
          return new FileLogger();
      }
  }
  // 使用
  public class Test {
      public static void main(String[] args) {
          LoggerFactory factory = new ConsoleLoggerFactory();
          Logger logger = factory.createLogger();
          logger.log("Hello Design Pattern");
      }
  }
  

• 扩展：简单工厂模式（非 GoF 23 种，是工厂方法的简化版），由一个工厂类负责所有产品创建，适合产品类型少的场景（如 JDK 的 java.text.DateFormat）。

3. 抽象工厂模式（Abstract Factory）

• 核心思想：创建一系列相关 / 相互依赖的对象，而无需指定它们的具体类，提供一个工厂接口用于创建多个产品族的对象。
• 适用场景：存在多个产品族，且产品族内的对象需配套使用（如电脑品牌：联想（主板 + CPU）、戴尔（主板 + CPU），每个品牌是一个产品族）。
• 框架应用：Spring 的 BeanFactory（顶层抽象工厂，负责创建各类 Bean 实例）、MyBatis 的数据源工厂 DataSourceFactory。

4. 建造者模式（Builder）

• 核心思想：将复杂对象的构建过程与表示分离，让同一个构建过程可以创建不同的表示，分步构建复杂对象。
• 适用场景：对象有多个属性，且部分属性可选（如实体类 User 有姓名、年龄、手机号、地址等，创建时可能只传部分属性）。
• Java 示例（链式调用，企业常用）：

  public class User {
      // 必选属性
      private final String name;
      private final int age;
      // 可选属性
      private String phone;
      private String address;
      
      // 私有构造方法，仅由Builder调用
      private User(Builder builder) {
          this.name = builder.name;
          this.age = builder.age;
          this.phone = builder.phone;
          this.address = builder.address;
      }
      
      // 静态内部建造者类
      public static class Builder {
          // 必选属性（无默认值，强制构造时传入）
          private final String name;
          private final int age;
          // 可选属性（有默认值）
          private String phone = "";
          private String address = "";
          
          // 建造者构造方法，传入必选属性
          public Builder(String name, int age) {
              this.name = name;
              this.age = age;
          }
          
          // 链式设置可选属性
          public Builder phone(String phone) {
              this.phone = phone;
              return this;
          }
          public Builder address(String address) {
              this.address = address;
              return this;
          }
          
          // 构建最终对象
          public User build() {
              return new User(this);
          }
      }
      
      // 测试
      public static void main(String[] args) {
          // 链式构建，灵活设置可选属性
          User user = new User.Builder("张三", 25)
                  .phone("13800138000")
                  .address("北京市")
                  .build();
      }
  }
  

• 框架应用：MyBatis 的 SqlSessionFactoryBuilder、Spring 的 BeanDefinitionBuilder、JDK 的 StringBuilder（简化版建造者）。

5. 原型模式（Prototype）

• 核心思想：通过复制（克隆）已有实例创建新对象，避免重复执行复杂的创建逻辑，提升创建效率。
• 适用场景：对象创建成本高（如需要查询数据库、调用远程接口），且对象属性大部分相同，仅少量差异。
• Java 实现：实现 Cloneable 接口，重写 clone() 方法（浅克隆）；深克隆需通过序列化实现。
• 框架应用：Spring 中 Bean 的 prototype 作用域（每次获取都克隆一个新实例）。

二、结构型模式（共 7 种）

核心目标：优化类或对象的组合结构，通过合理的继承、聚合、组合等方式，实现功能复用、扩展，同时保证结构的灵活性和稳定性，解决 “如何将现有代码组合成更强大的结构” 问题。

1. 代理模式（Proxy）

• 核心思想：为目标对象提供一个代理对象，由代理对象控制对目标对象的访问，在目标方法执行前后可添加额外逻辑（如日志、权限、缓存）。
• 分类：静态代理（编译期生成代理类）、动态代理（运行期生成代理类，Java 原生 JDK 动态代理、CGLIB）。
• 适用场景：日志记录、权限控制、远程调用（RPC）、缓存增强、事务管理。
• Java 动态代理示例（JDK 原生，基于接口）：

  // 目标接口
  public interface UserService {
      void queryUser(Long id);
  }
  // 目标实现类
  public class UserServiceImpl implements UserService {
      @Override
      public void queryUser(Long id) {
          System.out.println("查询用户，ID：" + id);
      }
  }
  // 动态代理处理器
  public class ProxyHandler implements InvocationHandler {
      // 目标对象
      private final Object target;
      
      public ProxyHandler(Object target) {
          this.target = target;
      }
      
      // 重写invoke方法，实现代理逻辑
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          // 前置增强：日志记录
          System.out.println("方法执行前：" + method.getName() + "，参数：" + Arrays.toString(args));
          // 执行目标方法
          Object result = method.invoke(target, args);
          // 后置增强
          System.out.println("方法执行后：" + method.getName());
          return result;
      }
  }
  // 使用
  public class Test {
      public static void main(String[] args) {
          UserService target = new UserServiceImpl();
          // 运行期生成代理类
          UserService proxy = (UserService) Proxy.newProxyInstance(
                  target.getClass().getClassLoader(),
                  target.getClass().getInterfaces(),
                  new ProxyHandler(target)
          );
          // 调用代理方法
          proxy.queryUser(1L);
      }
  }
  

• 框架应用：Spring AOP（核心基于动态代理，JDK 代理 + CGLIB 结合）、MyBatis 的 Mapper 代理（动态生成 Mapper 实现类）、RPC 框架的远程代理。

2. 装饰器模式（Decorator）

• 核心思想：动态地给一个对象添加额外的功能，通过包装目标对象实现功能扩展，替代继承（避免继承体系臃肿）。
• 核心特点：装饰器与目标对象实现同一接口 / 继承同一父类，包含目标对象的引用，层层包装。
• 适用场景：需要灵活给对象添加 / 移除功能，且功能可组合（如日志、加密、压缩等功能的动态组合）。
• 框架应用：JDK 的 java.io 包（BufferedReader 装饰 FileReader、ObjectOutputStream 装饰 FileOutputStream）、Spring 的 Decorator 模式实现缓存增强。
• 示例：JDK 原生装饰器使用

  // 基础流（目标对象）
  Reader reader = new FileReader("test.txt");
  // 装饰器包装，添加缓冲功能
  Reader bufferedReader = new BufferedReader(reader);
  

3. 适配器模式（Adapter）

• 核心思想：将一个类的接口转换成客户端期望的另一个接口，让原本接口不兼容的类可以一起工作，分为类适配器（继承）和对象适配器（组合，推荐）。
• 适用场景：集成第三方组件（接口与项目不一致）、复用现有代码（接口不匹配）、跨系统接口对接。
• 框架应用：Spring 的 HandlerAdapter（适配不同的处理器 Handler）、JDK 的 java.util.Arrays.asList()（将数组适配为集合）、java.io.InputStreamReader（将字节流适配为字符流）。

4. 组合模式（Composite）

• 核心思想：将对象组合成树形结构，表示 “部分 - 整体” 的层次关系，让客户端对单个对象和组合对象的使用保持一致。
• 适用场景：树形结构数据处理（如菜单树、部门树、文件目录树）、多级组件嵌套（如 UI 组件）。
• 框架应用：Spring 的 ApplicationContext（容器的层级结构）、MyBatis 的动态 SQL 节点（SqlNode 及其子类的组合）。

5. 其他常用结构型模式

• 享元模式（Flyweight）：复用大量细粒度对象，减少内存占用，核心是 “池化思想”（如 JDK 字符串常量池、数据库连接池、Redis 连接池）；
• 桥接模式（Bridge）：将抽象与实现分离，让二者可以独立变化，避免多层继承（如 JDBC 的 Driver 接口，抽象层与不同数据库的实现层分离）；
• 外观模式（Facade）：为复杂的子系统提供一个统一的入口，简化客户端调用（如 Spring 的 ApplicationContext 作为容器的外观，屏蔽底层 Bean 创建、依赖注入的复杂逻辑）。

三、行为型模式（共 11 种）

核心目标：定义类 / 对象之间的交互规则和职责分配，解决 “如何让对象之间高效、灵活地通信和协作” 问题，提升代码的可扩展性和交互效率。

1. 策略模式（Strategy）

• 核心思想：定义一系列算法，将每个算法封装成独立的策略类，使它们可以互相替换，算法的变化独立于使用算法的客户端。
• 适用场景：多种算法 / 策略可选（如排序算法、支付方式、日志存储方式），且后续可能扩展新策略，避免大量 if-else/switch 分支。
• Java 示例：

  // 策略接口
  public interface PayStrategy {
      void pay(double amount);
  }
  // 具体策略1：支付宝支付
  public class AliPayStrategy implements PayStrategy {
      @Override
      public void pay(double amount) {
          System.out.println("使用支付宝支付：" + amount + "元");
      }
  }
  // 具体策略2：微信支付
  public class WxPayStrategy implements PayStrategy {
      @Override
      public void pay(double amount) {
          System.out.println("使用微信支付：" + amount + "元");
      }
  }
  // 上下文：封装策略的使用
  public class PayContext {
      private PayStrategy strategy;
      
      // 动态设置策略
      public void setStrategy(PayStrategy strategy) {
          this.strategy = strategy;
      }
      
      // 执行支付
      public void doPay(double amount) {
          strategy.pay(amount);
      }
  }
  // 使用
  public class Test {
      public static void main(String[] args) {
          PayContext context = new PayContext();
          // 选择支付宝支付策略
          context.setStrategy(new AliPayStrategy());
          context.doPay(100.0);
          // 切换为微信支付策略
          context.setStrategy(new WxPayStrategy());
          context.doPay(50.0);
      }
  }
  

• 框架应用：Spring 的 Resource 接口（不同资源加载策略：文件、类路径、网络）、MyBatis 的分页插件（不同数据库的分页策略）。

2. 观察者模式（Observer）

• 核心思想：定义一对多的依赖关系，当一个对象（被观察者 / 主题）的状态发生变化时，所有依赖它的对象（观察者）都会被通知并自动更新。
• 适用场景：事件驱动、消息通知、状态监听（如订单支付成功后，通知库存扣减、物流创建、积分发放）。
• Java 实现：JDK 原生 java.util.Observable（被观察者）和 java.util.Observer（观察者），或自定义接口。
• 框架应用：Spring 的 ApplicationEvent 和 ApplicationListener（事件监听机制）、Guava 的 EventBus、Android 的事件监听。

3. 模板方法模式（Template Method）

• 核心思想：在父类中定义一个算法的骨架，将算法中可变的步骤延迟到子类中实现，固定算法结构，灵活定制步骤。
• 适用场景：多个子类有共同的算法流程，仅部分步骤不同（如数据库操作：连接→执行 SQL→关闭连接，其中 “执行 SQL” 是可变步骤）。
• Java 示例：

  // 抽象父类：定义算法骨架
  public abstract class DbTemplate {
      // 模板方法：final 禁止子类重写，固定算法结构
      public final void execute() {
          // 固定步骤1：获取连接
          getConnection();
          // 可变步骤2：执行SQL（子类实现）
          doExecute();
          // 固定步骤3：关闭连接
          closeConnection();
      }
      
      // 固定方法
      private void getConnection() {
          System.out.println("获取数据库连接");
      }
      private void closeConnection() {
          System.out.println("关闭数据库连接");
      }
      
      // 抽象方法：可变步骤，子类实现
      protected abstract void doExecute();
  }
  // 具体子类1：执行查询SQL
  public class QueryDbTemplate extends DbTemplate {
      @Override
      protected void doExecute() {
          System.out.println("执行查询SQL：select * from user");
      }
  }
  // 具体子类2：执行插入SQL
  public class InsertDbTemplate extends DbTemplate {
      @Override
      protected void doExecute() {
          System.out.println("执行插入SQL：insert into user values(1, '张三')");
      }
  }
  // 使用
  public class Test {
      public static void main(String[] args) {
          DbTemplate queryTemplate = new QueryDbTemplate();
          queryTemplate.execute();
          
          DbTemplate insertTemplate = new InsertDbTemplate();
          insertTemplate.execute();
      }
  }
  

• 框架应用：Spring 的 JdbcTemplate（数据库操作模板）、MyBatis 的 BaseExecutor（执行器的模板方法）、Servlet 的 doGet/doPost（父类 HttpServlet 定义骨架）。

4. 迭代器模式（Iterator）

• 核心思想：提供一个统一的遍历接口，遍历聚合对象（如集合、数组）的元素，而无需暴露聚合对象的内部结构。
• 适用场景：遍历各种聚合对象，保证遍历方式的一致性（如遍历 List、Set、Map 等）。
• 框架应用：JDK 集合框架的 java.util.Iterator 接口（所有集合都实现了迭代器）、Spring 的 Iterable 实现类。

5. 其他高频行为型模式

• 责任链模式（Chain of Responsibility）：将请求的处理者组成一条链，请求沿着链传递，直到有一个处理者处理它（如 SpringMVC 的拦截器链、过滤器链 FilterChain、MyBatis 的插件链）；
• 命令模式（Command）：将请求封装成命令对象，将请求的发起者和处理者解耦（如 Spring 的 JmsTemplate 命令模式、GUI 中的按钮点击命令）；
• 状态模式（State）：将对象的状态封装成独立的状态类，对象的行为随状态变化而变化（如订单状态：待支付→已支付→待发货→已发货，不同状态对应不同行为）；
• 享元模式（Flyweight）：复用大量细粒度对象，减少内存占用（如 JDK 字符串常量池、数据库连接池）。

四、设计模式核心原则（SOLID）

所有设计模式都基于 SOLID 五大设计原则，这是设计模式的 “灵魂”，理解原则比死记模式更重要：

• 单一职责原则（SRP）：一个类只负责一个职责，避免 “万能类”；
• 开闭原则（OCP）：对扩展开放，对修改关闭（核心原则，设计模式的最终目标）；
• 里氏替换原则（LSP）：子类可以完全替换父类，且不会影响程序的正确性；
• 接口隔离原则（ISP）：将大接口拆分为多个小接口，客户端只依赖需要的接口，避免 “胖接口”；
• 依赖倒置原则（DIP）：依赖抽象，而非具体实现（如依赖接口 / 抽象类，不依赖具体子类，Spring 依赖注入的核心）。

五、框架中的设计模式综合应用（高频面试）

主流 Java 框架都是设计模式的集大成者，掌握 “框架 + 模式” 的结合，能快速理解框架底层设计：

• Spring：单例模式（Bean 单例）、工厂模式（BeanFactory）、代理模式（AOP）、装饰器模式（Bean 包装）、模板方法模式（JdbcTemplate）、观察者模式（事件监听）、适配器模式（HandlerAdapter）；
• MyBatis：代理模式（Mapper 动态代理）、工厂模式（SqlSessionFactory）、建造者模式（SqlSessionFactoryBuilder）、策略模式（分页 / 数据源）、模板方法模式（BaseExecutor）、装饰器模式（缓存装饰器）；
• JDK：装饰器模式（IO 流）、迭代器模式（集合）、单例模式（Runtime）、工厂模式（DateFormat）、适配器模式（InputStreamReader）。

六、学习建议

• 先懂原则，再学模式：SOLID 原则是设计模式的基础，理解原则后，能快速判断何时该用哪种模式；
• 从高频到低频：优先掌握单例、工厂、代理、装饰器、策略、模板方法等高频模式，覆盖 80% 的开发场景；
• 结合框架理解：通过 Spring/MyBatis 源码分析模式的实际应用，避免 “纸上谈兵”；
• 避免过度设计：设计模式是 “工具”，而非 “教条”，简单场景直接写代码，复杂场景再用模式，避免为了用模式而用模式。

核心总结

Java 设计模式以 GoF 23 种为核心，分创建型、结构型、行为型三大类，核心目标是解耦、复用、扩展、维护，所有模式都遵循 SOLID 五大原则。

实际开发中，没有最优的模式，只有最适合的模式，关键是根据业务场景选择合适的模式，结合框架的原生实现，让代码更优雅、更易维护。

您可能感兴趣的文章:

• Java设计模式之装饰者模式详解和代码实例
• Java设计模式之策略模式示例详解
• Java设计模式之监听器模式实例详解
• 实例解析观察者模式及其在Java设计模式开发中的运用
• Java开发中的23种设计模式详解(推荐)
• Java设计模式之工厂模式案例详解
• java设计模式之模板方法模式详解
• Java中常用的设计模式之装饰器模式详解
• Java设计模式之java策略模式详解
• Java设计模式--适配器模式详解