网站首页 > java教程正文

Java23种设计模式结合SpringBoot案例

temp10 2025-07-28 20:13:16 java教程 2 ℃ 0 评论

以下是 Java 23种设计模式 结合 Spring Boot注解的案例列表，涵盖 创建型、结构型、行为型 三大类设计模式，并结合 Spring Boot 的特性（如依赖注入、组件扫描、自动配置等）进行实现：

一、创建型模式（5种）

1. 单例模式（Singleton）

场景：全局唯一资源管理（如数据库连接池）
Spring Boot 实现：

Java23种设计模式结合SpringBoot案例

@Component
public class DatabasePool {
    public void connect() {
        System.out.println("连接数据库");
    }
}

核心思想：Spring 容器默认以单例模式管理 @Component、@Service 等注解的 Bean。

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

场景：支付系统（支持多支付渠道扩展）
Spring Boot 实现：

// 接口
public interface Payment {
    void pay(BigDecimal amount);
}

// 具体实现
@Component("alipay")
public class Alipay implements Payment {
    public void pay(BigDecimal amount) {
        System.out.println("支付宝支付：" + amount);
    }
}

@Component("wechatpay")
public class WechatPay implements Payment {
    public void pay(BigDecimal amount) {
        System.out.println("微信支付：" + amount);
    }
}

// 工厂类（结合 @Autowired 自动注入）
@Service
public class PaymentFactory {
    @Autowired
    private ApplicationContext context;

    public Payment createPayment(String type) {
        return (Payment) context.getBean(type);
    }
}

核心思想：通过 @Component 注解注册具体实现类，工厂类通过 ApplicationContext 动态获取 Bean。

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

场景：电子产品家族生产（如苹果手机+耳机）
Spring Boot 实现：

// 接口
public interface Phone {
    void call();
}
public interface Earphone {
    void play();
}

// 具体实现
@Component("iPhone")
public class iPhone implements Phone {
    public void call() { System.out.println("iPhone打电话"); }
}

@Component("airpods")
public class AirPods implements Earphone {
    public void play() { System.out.println("AirPods播放音乐"); }
}

// 抽象工厂接口
public interface TechFactory {
    Phone createPhone();
    Earphone createEarphone();
}

// 具体工厂（结合 @Primary 优先注入）
@Service
public class AppleFactory implements TechFactory {
    @Autowired
    @Qualifier("iPhone")
    private Phone phone;

    @Autowired
    @Qualifier("airpods")
    private Earphone earphone;

    public Phone createPhone() { return phone; }
    public Earphone createEarphone() { return earphone; }
}

核心思想：通过 @Component 注解注册产品族，工厂类通过 @Autowired 注入依赖。

4. 建造者模式（Builder）

场景：复杂对象配置（如HTTP请求构建）
Spring Boot 实现：

@Component
public class HttpRequestBuilder {
    public HttpRequest build(String method, String url) {
        return new HttpRequest.Builder()
            .setMethod(method)
            .setUrl(url)
            .build();
    }
}

// HttpRequest 类同上文

核心思想：通过 @Component 注解注册建造者，Spring 管理其生命周期。

5. 原型模式（Prototype）

场景：对象克隆（如缓存模板对象）
Spring Boot 实现：

@Component
@Scope("prototype")
public class Document implements Cloneable {
    private String content;

    public Document clone() {
        try {
            return (Document) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

核心思想：通过 @Scope("prototype") 注解配置 Spring 以原型模式管理 Bean。

二、结构型模式（7种）

6. 适配器模式（Adapter）

场景：旧接口与新接口兼容
Spring Boot 实现：

// 旧接口
public interface OldStorage {
    void store(String data);
}

// 新接口
public interface NewStorage {
    void save(String data);
}

// 适配器类
@Component
public class StorageAdapter implements NewStorage {
    @Autowired
    private OldStorage oldStorage;

    public void save(String data) {
        oldStorage.store(data);
    }
}

核心思想：通过 @Autowired 注入旧接口实现，适配新接口。

7. 代理模式（Proxy）

场景：权限控制（如远程服务调用）
Spring Boot 实现：

// 接口
public interface Service {
    void execute();
}

// 真实实现
@Service
public class RealService implements Service {
    public void execute() {
        System.out.println("执行真实服务");
    }
}

// 代理类（结合 AOP）
@Aspect
@Component
public class ServiceProxy {
    @Autowired
    private RealService realService;

    @Around("execution(* com.example.Service.execute(..))")
    public Object checkPermission(ProceedingJoinPoint joinPoint) throws Throwable {
        if (hasPermission()) {
            return joinPoint.proceed();
        } else {
            System.out.println("无权限访问");
            return null;
        }
    }

    private boolean hasPermission() {
        return true; // 模拟权限检查
    }
}

核心思想：通过 Spring AOP 实现代理逻辑（如权限校验）。

8. 门面模式（Facade）

场景：简化复杂系统交互
Spring Boot 实现：

@Service
public class DBFacade {
    @Autowired
    private DBConnection connection;
    @Autowired
    private SQLExecutor executor;

    public void query(String sql) {
        connection.connect();
        executor.execute(sql);
    }
}

核心思想：通过 @Service 注解封装复杂逻辑，提供统一入口。

9. 组合模式（Composite）

场景：树形结构管理（如文件系统）
Spring Boot 实现：

@Component
public class FileComponent {
    public void display() {
        System.out.println("文件/文件夹");
    }
}

@Component
public class Folder extends FileComponent {
    @Autowired
    private List<FileComponent> components;

    public void display() {
        System.out.println("文件夹:");
        for (FileComponent component : components) {
            component.display();
        }
    }
}

核心思想：通过 @Component 注解管理组合结构，Spring 自动注入子组件。

10. 装饰器模式（Decorator）

场景：动态添加功能（如文本增强）
Spring Boot 实现：

@Component
public class PlainText {
    public String getContent() {
        return "原始文本";
    }
}

@Component
@Primary
public class BoldDecorator implements Text {
    @Autowired
    private Text text;

    public String getContent() {
        return "**" + text.getContent() + "**";
    }
}

核心思想：通过 @Primary 注解优先注入装饰器，动态扩展功能。

11. 享元模式（Flyweight）

场景：减少内存占用（如字体缓存）
Spring Boot 实现：

@Component
public class FontFactory {
    private Map<String, Font> fontCache = new HashMap<>();

    public Font getFont(String fontFamily, int fontSize) {
        String key = fontFamily + "-" + fontSize;
        if (!fontCache.containsKey(key)) {
            fontCache.put(key, new Font(fontFamily, fontSize));
        }
        return fontCache.get(key);
    }
}

核心思想：通过 @Component 注解注册工厂类，Spring 管理其生命周期。

12. 桥接模式（Bridge）

场景：抽象与实现分离
Spring Boot 实现：

// 实现接口
public interface Renderer {
    void renderCircle(float radius);
}

@Component
public class VectorRenderer implements Renderer {
    public void renderCircle(float radius) {
        System.out.println("绘制向量圆，半径：" + radius);
    }
}

// 抽象类
public abstract class Shape {
    protected Renderer renderer;

    public Shape(Renderer renderer) {
        this.renderer = renderer;
    }

    public abstract void draw();
}

@Component
public class Circle extends Shape {
    public Circle(Renderer renderer) {
        super(renderer);
    }

    public void draw() {
        renderer.renderCircle(5.0f);
    }
}

核心思想：通过 @Component 注解注册实现类，Spring 自动注入依赖。

三、行为型模式（11种）

13. 策略模式（Strategy）

场景：算法动态切换
Spring Boot 实现：

// 接口
public interface DiscountStrategy {
    BigDecimal applyDiscount(BigDecimal price);
}

@Component("christmas")
public class ChristmasDiscount implements DiscountStrategy {
    public BigDecimal applyDiscount(BigDecimal price) {
        return price.multiply(BigDecimal.valueOf(0.9));
    }
}

@Component("none")
public class NoDiscount implements DiscountStrategy {
    public BigDecimal applyDiscount(BigDecimal price) {
        return price;
    }
}

// 上下文类
@Service
public class ShoppingCart {
    @Autowired
    private ApplicationContext context;

    public BigDecimal checkout(BigDecimal price, String strategy) {
        DiscountStrategy discount = (DiscountStrategy) context.getBean(strategy);
        return discount.applyDiscount(price);
    }
}

核心思想：通过 @Component 注解注册策略类，上下文动态选择策略。

14. 观察者模式（Observer）

场景：事件通知
Spring Boot 实现：

// 事件
public class MessageEvent extends ApplicationEvent {
    public MessageEvent(String message) {
        super(message);
    }
}

// 监听器
@Component
public class UserNotifier {
    @EventListener
    public void handleEvent(MessageEvent event) {
        System.out.println("收到消息：" + event.getSource());
    }
}

// 发布事件
@Service
public class Publisher {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void sendNotification(String message) {
        publisher.publishEvent(new MessageEvent(message));
    }
}

核心思想：通过 @EventListener 注解监听 Spring 事件。

15. 命令模式（Command）

场景：请求封装
Spring Boot 实现：

@Component
public class AddCommand implements Command {
    @Autowired
    private List<String> list;
    private String item;

    public AddCommand(String item) {
        this.item = item;
    }

    public void execute() {
        list.add(item);
    }

    public void undo() {
        list.remove(item);
    }
}

核心思想：通过 @Component 注册命令对象，Spring 管理其生命周期。

16. 状态模式（State）

场景：状态驱动行为
Spring Boot 实现：

// 接口
public interface OrderState {
    void handle(Order order);
}

@Component("created")
public class CreatedState implements OrderState {
    public void handle(Order order) {
        System.out.println("订单已创建，等待支付");
        order.setState(new PaidState());
    }
}

@Component("paid")
public class PaidState implements OrderState {
    public void handle(Order order) {
        System.out.println("订单已支付，等待发货");
        order.setState(new ShippedState());
    }
}

// 上下文类
@Component
public class Order {
    private OrderState state;

    public Order() {
        this.state = new CreatedState();
    }

    public void setState(OrderState state) {
        this.state = state;
    }

    public void process() {
        state.handle(this);
    }
}

核心思想：通过 @Component 注解注册状态类，Spring 自动注入依赖。

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

场景：算法骨架固定
Spring Boot 实现：

public abstract class ReportTemplate {
    public final void generateReport() {
        collectData();
        formatData();
        printReport();
    }

    protected abstract void collectData();
    protected abstract void formatData();

    protected void printReport() {
        System.out.println("生成PDF报告");
    }
}

@Component
public class SalesReport extends ReportTemplate {
    protected void collectData() {
        System.out.println("收集销售数据");
    }

    protected void formatData() {
        System.out.println("格式化销售数据");
    }
}

核心思想：通过 @Component 注解注册模板类，Spring 管理其实例。

18. 访问者模式（Visitor）

场景：对元素集合新增操作
Spring Boot 实现：

// 接口
public interface Element {
    void accept(Visitor visitor);
}

@Component
public class Product implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public interface Visitor {
    void visit(Product product);
}

@Component
public class PriceVisitor implements Visitor {
    public void visit(Product product) {
        System.out.println("计算产品价格");
    }
}

核心思想：通过 @Component 注解注册访问者和元素，Spring 自动注入依赖。

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

场景：请求处理链
Spring Boot 实现：

// 接口
public interface Handler {
    void setNext(Handler handler);
    void handleRequest(String request);
}

@Component
public class AuthHandler implements Handler {
    private Handler next;

    public void setNext(Handler handler) {
        this.next = handler;
    }

    public void handleRequest(String request) {
        if (request.equals("auth")) {
            System.out.println("认证处理");
        } else if (next != null) {
            next.handleRequest(request);
        }
    }
}

核心思想：通过 @Component 注解注册处理器，Spring 管理责任链。

20. 迭代器模式（Iterator）

场景：顺序访问集合元素
Spring Boot 实现：

@Component
public class ProductIterator implements Iterator<String> {
    private List<String> products = Arrays.asList("A", "B", "C");
    private int index = 0;

    public boolean hasNext() {
        return index < products.size();
    }

    public String next() {
        return products.get(index++);
    }
}

核心思想：通过 @Component 注解注册迭代器，Spring 管理其生命周期。

21. 中介者模式（Mediator）

场景：解耦对象交互
Spring Boot 实现：

// 接口
public interface ChatMediator {
    void sendMessage(String message, User user);
}

@Component
public class ChatRoom implements ChatMediator {
    public void sendMessage(String message, User user) {
        System.out.println(user.getName() + " 发送消息：" + message);
    }
}

@Component
public class User {
    @Autowired
    private ChatMediator mediator;

    private String name;

    public User(String name) {
        this.name = name;
    }

    public void send(String message) {
        mediator.sendMessage(message, this);
    }

    public String getName() {
        return name;
    }
}

核心思想：通过 @Component 注解注册中介者和参与者，Spring 管理依赖。

22. 解释器模式（Interpreter）

场景：语言解析
Spring Boot 实现：

// 抽象表达式
public interface Expression {
    boolean interpret(String context);
}

@Component
public class AndExpression implements Expression {
    private Expression left;
    private Expression right;

    public AndExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    public boolean interpret(String context) {
        return left.interpret(context) && right.interpret(context);
    }
}

核心思想：通过 @Component 注解注册表达式，Spring 管理其组合。

23. 备忘录模式（Memento）

场景：对象状态恢复
Spring Boot 实现：

@Component
public class Editor {
    private String content;

    public Memento save() {
        return new Memento(content);
    }

    public void restore(Memento memento) {
        this.content = memento.getContent();
    }
}

@Component
public class Memento {
    private String content;

    public Memento(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

核心思想：通过 @Component 注解注册备忘录类，Spring 管理状态保存与恢复。

总结

Spring Boot 通过 依赖注入（@Autowired）、组件扫描（@Component） 和 自动配置（@EnableAutoConfiguration） 等特性，天然支持设计模式的实现。

创建型模式：利用 @Component、@Scope 和 @Bean 简化对象创建。
结构型模式：通过组合与代理（AOP）实现结构解耦。
行为型模式：结合事件驱动（@EventListener）和策略模式（动态注入）实现灵活行为管理。

在实际开发中，根据需求选择合适的设计模式，并结合 Spring Boot 的特性，可以显著提升代码的可维护性和可扩展性。

上一篇：面试题:Java 中的 23 种设计模式详解
下一篇：设计模式之 Prototype(原型)（prototype function）

网站首页 > java教程正文

Java23种设计模式结合SpringBoot案例

一、创建型模式（5种）

1. 单例模式（Singleton）

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

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

4. 建造者模式（Builder）

5. 原型模式（Prototype）

二、结构型模式（7种）

6. 适配器模式（Adapter）

7. 代理模式（Proxy）

8. 门面模式（Facade）

9. 组合模式（Composite）

10. 装饰器模式（Decorator）

11. 享元模式（Flyweight）

12. 桥接模式（Bridge）

三、行为型模式（11种）

13. 策略模式（Strategy）

14. 观察者模式（Observer）

15. 命令模式（Command）

16. 状态模式（State）

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

18. 访问者模式（Visitor）

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

20. 迭代器模式（Iterator）

21. 中介者模式（Mediator）

22. 解释器模式（Interpreter）

23. 备忘录模式（Memento）

总结

猜你喜欢

本文暂时没有评论，来添加一个吧(●'◡'●)

取消回复欢迎你发表评论:

网站首页 > java教程 正文

Java23种设计模式结合SpringBoot案例

一、创建型模式（5种）

1. 单例模式（Singleton）

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

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

4. 建造者模式（Builder）

5. 原型模式（Prototype）

二、结构型模式（7种）

6. 适配器模式（Adapter）

7. 代理模式（Proxy）

8. 门面模式（Facade）

9. 组合模式（Composite）

10. 装饰器模式（Decorator）

11. 享元模式（Flyweight）

12. 桥接模式（Bridge）

三、行为型模式（11种）

13. 策略模式（Strategy）

14. 观察者模式（Observer）

15. 命令模式（Command）

16. 状态模式（State）

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

18. 访问者模式（Visitor）

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

20. 迭代器模式（Iterator）

21. 中介者模式（Mediator）

22. 解释器模式（Interpreter）

23. 备忘录模式（Memento）

总结

猜你喜欢

本文暂时没有评论，来添加一个吧(●'◡'●)

取消回复欢迎 你 发表评论:

网站首页 > java教程正文

取消回复欢迎你发表评论: