Java23种设计模式结合SpringBoot案例

大家好，欢迎来到IT知识分享网。

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

一、创建型模式（5种）

1. 单例模式（Singleton）

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

@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 的特性，可以显著提升代码的可维护性和可扩展性。