23种设计模式说明

以下是常见的 23 种设计模式 分类及其核心思想、应用场景和简单代码示例，帮助你在实际开发中灵活运用：

---

一、创建型模式（5种）

解决对象创建问题，降低对象耦合。

1. 单例模式（Singleton）

• 核心思想：确保一个类只有一个实例，并提供全局访问点。

• 场景：数据库连接池、配置管理、日志对象。

• 示例：

  public class Singleton {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;}
  }

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

• 核心思想：定义创建对象的接口，由子类决定实例化哪个类。

• 场景：日志记录器、数据库连接工厂。

• 示例：

  interface Product {void use();
  }class ConcreteProductA implements Product {public void use() { System.out.println("Product A"); }
  }abstract class Creator {public abstract Product createProduct();
  }class ConcreteCreatorA extends Creator {public Product createProduct() { return new ConcreteProductA(); }
  }

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

• 核心思想：提供一个接口，创建一系列相关或依赖对象。

• 场景：跨平台的 UI 组件库（如按钮、文本框）。

• 示例：

  interface Button { void render(); }
  interface TextField { void input(); }class WindowsButton implements Button { public void render() { /* Windows 风格按钮 */ } }
  class MacButton implements Button { public void render() { /* Mac 风格按钮 */ } }interface GUIFactory {Button createButton();TextField createTextField();
  }class WindowsFactory implements GUIFactory {public Button createButton() { return new WindowsButton(); }public TextField createTextField() { return new WindowsTextField(); }
  }

4. 建造者模式（Builder）

• 核心思想：分步骤构建复杂对象，隔离构造细节。

• 场景：构造复杂对象（如 SQL 查询、HTTP 请求）。

• 示例：

  java

  复制

  class Computer {private String cpu;private String ram;// 省略其他属性和构造方法static class Builder {private String cpu;private String ram;public Builder setCpu(String cpu) { this.cpu = cpu; return this; }public Builder setRam(String ram) { this.ram = ram; return this; }public Computer build() { return new Computer(this); }}
  }// 使用
  Computer computer = new Computer.Builder().setCpu("Intel i7").setRam("16GB").build();

5. 原型模式（Prototype）

• 核心思想：通过复制现有对象来创建新对象。

• 场景：避免重复初始化开销（如游戏中的怪物生成）。

• 示例：

  java

  复制

  interface Prototype extends Cloneable {Prototype clone();
  }class ConcretePrototype implements Prototype {public Prototype clone() {return (ConcretePrototype) super.clone();}
  }

---

二、结构型模式（7种）

处理类或对象的组合，构建灵活结构。

6. 适配器模式（Adapter）

• 核心思想：将一个接口转换为另一个客户端期望的接口。

• 场景：整合不兼容的第三方库。

• 示例：

  java

  复制

  class LegacyLibrary {public void specificRequest() { /* 旧接口 */ }
  }interface Target {void request();
  }class Adapter implements Target {private LegacyLibrary legacy;public Adapter(LegacyLibrary legacy) { this.legacy = legacy; }public void request() { legacy.specificRequest(); }
  }

• 备注实战经验：接口转换的中间层，比如标准品接口视作标准，分别对接不同的客户，为了减少标准品的改动，添加一层专门对接客户的接口适配层。

7. 装饰器模式（Decorator）

• 核心思想：动态地为对象添加额外职责。

• 场景：Java I/O 流（如 BufferedReader 装饰 FileReader）。

• 示例：

  java

  复制

  interface Coffee {double getCost();String getDescription();
  }class SimpleCoffee implements Coffee {public double getCost() { return 1.0; }public String getDescription() { return "Coffee"; }
  }abstract class CoffeeDecorator implements Coffee {protected Coffee decoratedCoffee;public CoffeeDecorator(Coffee coffee) { this.decoratedCoffee = coffee; }
  }class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) { super(coffee); }public double getCost() { return super.getCost() + 0.5; }public String getDescription() { return super.getDescription() + ", Milk"; }
  }

8. 代理模式（Proxy）

• 核心思想：为其他对象提供一种代理以控制访问。

• 场景：延迟加载（Lazy Initialization）、权限控制。

• 示例： 

  interface Image {void display();
  }class RealImage implements Image {public RealImage(String filename) { loadFromDisk(filename); }private void loadFromDisk(String filename) { /* 加载图片 */ }public void display() { /* 显示图片 */ }
  }class ProxyImage implements Image {private RealImage realImage;private String filename;public ProxyImage(String filename) { this.filename = filename; }public void display() {if (realImage == null) {realImage = new RealImage(filename);}realImage.display();}
  }

9. 外观模式（Facade）

• 核心思想：为复杂子系统提供一个统一的高层接口。

• 场景：简化 API 调用（如订单支付流程封装）。

• 示例：

  java

  复制

  class PaymentService {public void processPayment() { /* 处理支付 */ }
  }
  class InventoryService {public void updateInventory() { /* 更新库存 */ }
  }class OrderFacade {private PaymentService paymentService;private InventoryService inventoryService;public void placeOrder() {paymentService.processPayment();inventoryService.updateInventory();}
  }

• 备注实战：入库场景下各种入库复杂场景，统一封装一个高阶入库接口，用于处理所有入库逻辑，函数内部通过查询sku对比订单信息来决定那种业务类型入库。

10. 桥接模式（Bridge）

• 核心思想：将抽象与实现分离，使它们可以独立变化。

• 场景：跨平台图形渲染（如不同操作系统下的绘图 API）。

• 示例：

  java

  复制

  interface Renderer {void renderCircle(float radius);
  }class VectorRenderer implements Renderer {public void renderCircle(float radius) { /* 矢量渲染 */ }
  }abstract class Shape {protected Renderer renderer;public Shape(Renderer renderer) { this.renderer = renderer; }abstract void draw();
  }class Circle extends Shape {private float radius;public Circle(Renderer renderer, float radius) {super(renderer);this.radius = radius;}public void draw() { renderer.renderCircle(radius); }
  }

---

三、行为型模式（11种）

关注对象之间的通信和职责分配。

11. 观察者模式（Observer）

• 核心思想：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者自动更新。

• 场景：事件驱动系统（如 GUI 按钮点击事件）。

• 示例：

  java

  复制

  interface Observer {void update(String message);
  }class ConcreteObserver implements Observer {public void update(String message) { System.out.println("Received: " + message); }
  }class Subject {private List<Observer> observers = new ArrayList<>();public void addObserver(Observer observer) { observers.add(observer); }public void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}
  }

• 备注实战：消息队列

12. 策略模式（Strategy）

• 核心思想：定义一系列算法，封装每个算法，并使它们可互换。

• 场景：支付方式选择（支付宝、微信、信用卡）。

• 示例：

  java

  复制

  interface PaymentStrategy {void pay(int amount);
  }class AlipayStrategy implements PaymentStrategy {public void pay(int amount) { /* 支付宝支付 */ }
  }class Context {private PaymentStrategy strategy;public void setStrategy(PaymentStrategy strategy) { this.strategy = strategy; }public void executePayment(int amount) { strategy.pay(amount); }
  }

• 备注实战：报表的统一路由，根据不同类型选择不同报表设计。

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

• 核心思想：定义一个算法的骨架，将某些步骤延迟到子类实现。

• 场景：框架中的流程控制（如 Spring 的 JdbcTemplate）。

• 示例：

  java

  复制

  abstract class Game {abstract void initialize();abstract void startPlay();abstract void endPlay();public final void play() {initialize();startPlay();endPlay();}
  }class Cricket extends Game {void initialize() { /* 初始化板球游戏 */ }void startPlay() { /* 开始游戏 */ }void endPlay() { /* 结束游戏 */ }
  }

14. 责任链模式（Chain of Responsibility）

• 核心思想：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。

• 场景：审批流程、异常处理链。

• 示例：

  java

  复制

  abstract class Handler {protected Handler next;public void setNext(Handler next) { this.next = next; }public abstract void handleRequest(int request);
  }class ConcreteHandlerA extends Handler {public void handleRequest(int request) {if (request <= 10) { /* 处理请求 */ }else if (next != null) { next.handleRequest(request); }}
  }

• 备注实战：事件监听，一个业务流程完成后，广播一条通知，监听端分别做对应收尾工作。

---

四、设计模式总结

• 优先理解问题场景：不要为了用模式而用模式。

• 关注开闭原则（OCP）：通过扩展而非修改现有代码来实现变化。

• 框架中的应用：如 Spring 的依赖注入（工厂模式）、AOP（代理模式）。

附：模式速查表

类型	模式名称	一句话核心思想
创建型	单例、工厂、建造者	灵活创建对象，解耦实例化过程
结构型	适配器、代理、装饰器	组合对象，构建灵活结构
行为型	观察者、策略、模板方法	定义对象交互方式，解耦行为逻辑

掌握这些模式能显著提升代码的可维护性和扩展性！

Spring boot中的设计模式

Spring Boot 作为 Spring 框架的扩展，在底层大量使用了设计模式来简化开发、提高扩展性和维护性。以下是 Spring Boot 中常见的 设计模式及其应用场景 的详细解析：

---

1. 单例模式（Singleton）

• 应用场景：Spring 容器管理的 Bean 默认是单例的，确保全局唯一实例。

• 源码示例：

  java

  复制

  @Service
  public class UserService {// 默认单例，Spring 容器中只有一个 UserService 实例
  }

• 实现原理：通过 DefaultSingletonBeanRegistry 的 singletonObjects 缓存管理单例 Bean。

---

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

• 应用场景：Bean 的创建通过工厂方法解耦。

• 源码示例：

  java

  复制

  @Configuration
  public class AppConfig {@Bean // 工厂方法，由 Spring 调用此方法创建 DataSource 实例public DataSource dataSource() {return new HikariDataSource();}
  }

• 扩展应用：BeanFactory 接口定义了 Bean 的工厂方法 getBean()。

---

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

• 应用场景：根据不同环境创建不同的 Bean（如多数据源）。

• 源码示例：

  java

  复制

  @Configuration
  public class DataSourceConfig {@Bean@Profile("dev") // 根据 Profile 选择工厂实现public DataSource devDataSource() { /* 开发环境数据源 */ }@Bean@Profile("prod")public DataSource prodDataSource() { /* 生产环境数据源 */ }
  }

---

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

• 应用场景：定义算法骨架，子类实现具体步骤（如 JdbcTemplate）。

• 源码示例：

  java

  复制

  public class JdbcTemplate extends JdbcAccessor {public <T> T query(String sql, ResultSetExtractor<T> rse) {// 定义执行流程：获取连接、创建语句、执行查询、处理结果Connection con = DataSourceUtils.getConnection(getDataSource());Statement stmt = con.createStatement();ResultSet rs = stmt.executeQuery(sql);return rse.extractData(rs); // 由回调处理结果}
  }

---

5. 代理模式（Proxy）

• 应用场景：AOP 切面编程、事务管理。

• 源码示例：

  java

  复制

  @Service
  public class UserService {@Transactional // Spring 通过动态代理添加事务管理逻辑public void saveUser(User user) { /* ... */ }
  }

• 实现原理：

  • 使用 JDK 动态代理（基于接口）或 CGLIB（基于类）生成代理对象。

  • 代理类在方法调用前后插入切面逻辑（如 @Around 通知）。

---

6. 适配器模式（Adapter）

• 应用场景：Spring MVC 中的 HandlerAdapter 处理不同类型的控制器。

• 源码示例：

  java

  复制

  public class RequestMappingHandlerAdapter implements HandlerAdapter {public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) {// 将 HTTP 请求适配到 @RequestMapping 方法}
  }

---

7. 观察者模式（Observer）

• 应用场景：Spring 事件驱动模型（如 ApplicationEvent 和 ApplicationListener）。

• 源码示例：

  java

  复制

  // 自定义事件
  public class OrderCreatedEvent extends ApplicationEvent { /* ... */ }// 监听事件
  @Component
  public class EmailListener implements ApplicationListener<OrderCreatedEvent> {public void onApplicationEvent(OrderCreatedEvent event) {// 发送邮件通知}
  }// 发布事件
  @Autowired
  private ApplicationEventPublisher publisher;
  publisher.publishEvent(new OrderCreatedEvent(this, order));

---

8. 策略模式（Strategy）

• 应用场景：多数据源路由、缓存策略选择。

• 源码示例：

  java

  复制

  public interface CacheStrategy {Object get(String key);
  }@Component("redisCache")
  public class RedisCacheStrategy implements CacheStrategy { /* ... */ }@Component("localCache")
  public class LocalCacheStrategy implements CacheStrategy { /* ... */ }// 根据条件动态选择策略
  @Autowired
  private Map<String, CacheStrategy> strategies;public CacheStrategy getStrategy(String type) {return strategies.get(type + "Cache");
  }

---

9. 装饰器模式（Decorator）

• 应用场景：增强请求/响应对象（如 HttpServletRequestWrapper）。

• 源码示例：

  java

  复制

  public class CachingHttpServletRequest extends HttpServletRequestWrapper {private byte[] cachedBody;public CachingHttpServletRequest(HttpServletRequest request) {super(request);// 缓存请求体以便多次读取this.cachedBody = StreamUtils.copyToByteArray(request.getInputStream());}@Overridepublic ServletInputStream getInputStream() {return new CachedBodyServletInputStream(cachedBody);}
  }

---

10. 责任链模式（Chain of Responsibility）

• 应用场景：Spring Security 的过滤器链、拦截器链。

• 源码示例：

  java

  复制

  public class SecurityFilterChain {private List<Filter> filters;public void doFilter(ServletRequest request, ServletResponse response) {for (Filter filter : filters) {filter.doFilter(request, response, chain);}}
  }

---

11. 建造者模式（Builder）

• 应用场景：构建复杂配置对象（如 SpringApplicationBuilder）。

• 源码示例：

  java

  复制

  new SpringApplicationBuilder().sources(Parent.class).child(Application.class).bannerMode(Banner.Mode.OFF).run(args);

---

总结

Spring Boot 通过灵活运用设计模式，实现了以下目标：

1. 解耦与扩展性：如工厂模式、策略模式。

2. 代码复用：如模板方法模式、装饰器模式。

3. 动态行为控制：如代理模式、观察者模式。

4. 简化复杂逻辑：如建造者模式、责任链模式。

理解这些模式在 Spring Boot 中的应用，有助于更好地掌握框架设计思想，并在实际开发中编写高内聚、低耦合的代码。