设计模式说明

ashane13142025-03-05 23:11

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());
    }

    @Override
    public 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 中的应用，有助于更好地掌握框架设计思想，并在实际开发中编写高内聚、低耦合的代码。

相关推荐
n北斗2 分钟前
docker拉取失败
java·开发语言
WeiLai11126 分钟前
面试基础--MySQL SQL 优化深度解析
java·后端·sql·mysql·面试·架构
舌尖上的五香9 分钟前
FastExcel/EasyExcel简介以及源码解析
java
跟着汪老师学编程11 分钟前
12、JavaEE概述
java·java-ee
佩服许仙31 分钟前
List删除异常原理
java
神秘的t32 分钟前
优选算法合集————双指针(专题三)
java·数据结构·算法·二分查找
liubing518838 分钟前
解决java-jar报错：xxx.jar 中没有主清单属性的方法
java·pycharm·jar
搞不懂语言的程序员43 分钟前
数据库事务的 ACID，通过MVCC能做什么
java·开发语言·数据库
Lkkkkkkkcy1 小时前
自己的网页加一个搜索框，调用deepseek的API
java·vue
java—大象1 小时前
基于SpringBoot+mybatis+layui就业管理系统设计和实现
java·数据库·spring boot·后端·layui·mybatis
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04Windows 11 安装 Dify 完整指南 非docker环境05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06DeepSeek本地部署详细指南07WPF 复杂页面布局及漂亮 UI 界面设计全解析08本地部署DeepSeek教程（Mac版本）09在Windows下安装Ollama并体验DeepSeek r1大模型10npm install 报错解决方案全记录