Spring Boot 经典九设计模式全览

在Spring Boot中，设计模式的应用广泛且重要，它们有助于提高代码的可维护性、可扩展性和复用性。以下是Spring Boot中经典的9种设计模式及其代码案例：

1. 单例模式（Singleton Pattern）

在Spring中，bean默认就是单例模式。Spring通过单例注册表的方式来实现单例，即维护一个Map来存储单例类的实例。

   // 单例模式示例public class SingletonService {private static SingletonService instance;private SingletonService() {}public static SingletonService getInstance() {if (instance == null) {instance = new SingletonService();}return instance;}}

2. 工厂模式（Factory Pattern）

工厂模式用于创建对象，而无需指定创建对象的具体类。Spring Boot中可以通过@Bean注解在配置类中实现工厂方法。

1. 定义接口或抽象类

// 用户接口  
public interface ReturnUser {  List<String> getUserByType();  
}

2. 实现接口或继承抽象类

然后，创建实现该接口或继承该抽象类的具体类。

// 机构用户实现类  
@Component  
public class OrgUserImpl implements ReturnUser {  @Override  public List<String> getUserByType() {  // 业务逻辑  return Arrays.asList("org1", "org2", "org3");  }  
} // 角色用户实现类  
@Component  
public class RoleUserImpl implements ReturnUser {  @Override  public List<String> getUserByType() {  // 业务逻辑  return Arrays.asList("role1", "role2", "role3");  }  
}

3. 创建工厂类

接下来，创建一个工厂类，用于生成具体类的实例。

// 用户工厂类  
@Component  
public class ReturnUserFactory {  @Autowired  private OrgUserImpl orgUser;  @Autowired  private RoleUserImpl roleUser;  public ReturnUser getUserList(String module) {  switch (module) {  case "org":  return orgUser;  case "role":  return roleUser;  default:  return null;  }  }  
}

4. 在Spring Boot中使用工厂类

你可以在你的Spring Boot应用程序中的任何地方使用工厂类来创建对象。例如，在一个控制器中：

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestParam;  
import org.springframework.web.bind.annotation.RestController;  @RestController  
public class ReturnUserController {  @GetMapping("/returnUser")  public String getAnimalSound(@RequestParam String type) {  ReturnUser returnUser  = AnimalFactory.getUserList(type);  if (returnUser != null) {  returnUser.makeSound();  return "The returnUser makes the sound: " + returnUser.makeSound();  } else {  return "Unknown returnUser type";  }  }  
}

3. 代理模式（Proxy Pattern）

1. 定义接口

首先，定义一个接口，这是被代理对象必须实现的。

public interface Service {  void performTask();  
}

2. 实现接口

然后，创建一个实现该接口的具体类。

public class RealService implements Service {  @Override  public void performTask() {  System.out.println("Performing real service task.");  }  
}

3. 创建代理类

接下来，创建一个代理类，它实现了相同的接口，并在调用实际对象的方法之前或之后添加额外的行为。

public class ServiceProxy implements Service {  private final Service realService;  public ServiceProxy(Service realService) {  this.realService = realService;  }  @Override  public void performTask() {  System.out.println("Performing proxy task before real service.");  realService.performTask();  System.out.println("Performing proxy task after real service.");  }  
}

4. 在Spring Boot中使用代理

你可以在你的Spring Boot应用程序中的任何地方使用代理类。例如，在一个控制器中：

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  @RestController  
public class ServiceController {  private final Service service;  // 你可以通过构造函数注入来传递代理对象，或者你可以直接在控制器中创建代理对象  public ServiceController(Service realService) {  this.service = new ServiceProxy(realService);  }  @GetMapping("/service")  public String getService() {  service.performTask();  return "Service task performed with proxy.";  }  
}

但是，请注意，在上面的例子中，我们并没有真正利用Spring的依赖注入来管理代理的创建。在实际应用中，你可能会希望Spring来管理这些代理对象。这可以通过使用Spring AOP（面向切面编程）来实现，它允许你在不修改源代码的情况下向现有对象添加行为。

代理模式为其他对象提供一种代理以控制对这个对象的访问。Spring AOP（面向切面编程）就是代理模式的一个应用。

// 切面类  
@Aspect  
@Component  
public class MyAspect {  @Around("execution(* com.example.service.*.*(..))")  public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {  long start = System.currentTimeMillis();  Object proceed = joinPoint.proceed();  long executionTime = System.currentTimeMillis() - start;  System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");  return proceed;  }  
}

4. 观察者模式（Observer Pattern）

在Spring Boot中使用观察者模式（Observer Pattern）可以让你构建一个能够自动通知和更新依赖对象（观察者）的系统，当某个对象（主题）的状态发生变化时。Spring Boot中的事件监听机制就是观察者模式的一个应用。

1. 定义主题接口

首先，你需要定义一个主题接口，它包含添加、移除和通知观察者的方法。

// Subject.java  
public interface Subject {  void registerObserver(Observer observer);  void removeObserver(Observer observer);  void notifyObservers();  
}

2. 实现具体的主题

接下来，实现一个具体的主题类，该类将维护一个观察者列表，并在状态变化时通知它们。

// ConcreteSubject.java  
import java.util.ArrayList;  
import java.util.List;  public class ConcreteSubject implements Subject {  private List<Observer> observers = new ArrayList<>();  private String state;  @Override  public void registerObserver(Observer observer) {  observers.add(observer);  }  @Override  public void removeObserver(Observer observer) {  observers.remove(observer);  }  @Override  public void notifyObservers() {  for (Observer observer : observers) {  observer.update(this);  }  }  public void setState(String state) {  this.state = state;  notifyObservers();  }  public String getState() {  return state;  }  
}

3. 定义观察者接口

然后，定义一个观察者接口，它包含一个更新方法，当主题状态变化时被调用。

// Observer.java  
public interface Observer {  void update(Subject subject);  
}

4. 实现具体的观察者

实现具体的观察者类，这些类将响应主题的状态变化。

// ConcreteObserver.java  
public class ConcreteObserver implements Observer {  private String name;  public ConcreteObserver(String name) {  this.name = name;  }  @Override  public void update(Subject subject) {  ConcreteSubject concreteSubject = (ConcreteSubject) subject;  System.out.println(name + " received state update: " + concreteSubject.getState());  }  
}

5. 在Spring Boot应用中使用

最后，在Spring Boot应用中使用这些类。你可以通过配置类或直接在控制器、服务等组件中实例化它们。

// ObserverPatternApplication.java  
import org.springframework.boot.CommandLineRunner;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  @SpringBootApplication  
public class ObserverPatternApplication implements CommandLineRunner {  public static void main(String[] args) {  SpringApplication.run(ObserverPatternApplication.class, args);  }  @Override  public void run(String... args) throws Exception {  ConcreteSubject subject = new ConcreteSubject();  Observer observer1 = new ConcreteObserver("Observer 1");  Observer observer2 = new ConcreteObserver("Observer 2");  subject.registerObserver(observer1);  subject.registerObserver(observer2);  subject.setState("New State");  }  
}

在这个示例中，ObserverPatternApplication是我们的Spring Boot应用主类。它创建了一个ConcreteSubject对象，并注册了两个ConcreteObserver对象。然后，它更改主题的状态，这将触发对观察者的通知。

5. 策略模式（Strategy Pattern）

策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以互换。Spring Boot中可以通过接口和不同的实现类来实现策略模式。

// 策略接口  
public interface PaymentStrategy {  void pay(double amount);  
}  // 具体策略实现类：信用卡支付  
@Component  
public class CreditCardPayment implements PaymentStrategy {  @Override  public void pay(double amount) {  System.out.println("Paid " + amount + " using Credit Card");  }  
}  // 具体策略实现类：现金支付  
@Component  
public class CashPayment implements PaymentStrategy {  @Override  public void pay(double amount) {  System.out.println("Paid " + amount + " using Cash");  }  
}  // 上下文类  
@Component  
public class PaymentContext {  @Autowired  private List<PaymentStrategy> paymentStrategies;  public void setPaymentMethod(String method) {  this.paymentMethod = method;  }  public void pay(double amount) {  for (PaymentStrategy strategy : paymentStrategies) {  if (strategy.getClass().getSimpleName().equalsIgnoreCase(this.paymentMethod)) {  strategy.pay(amount);  break;  }  }  }  private String paymentMethod;  
}

6. 模板方法模式（Template Method Pattern）

在Spring Boot中使用模板方法模式（Template Method Pattern）通常涉及创建一个抽象基类，该类定义了一个算法的框架，但将某些步骤的实现留给子类。这样，你可以在不改变算法结构的情况下，通过定义新的子类来改变算法中的某些步骤。

1. 定义抽象基类

首先，你需要创建一个抽象基类，其中包含一个模板方法（通常是final的，以防止子类覆盖它）和一些抽象方法（或钩子方法，这些可以是具体实现，但允许子类根据需要覆盖它们）。

// AbstractClass.java  
public abstract class AbstractClass {  // 模板方法，定义了算法的框架  public final void templateMethod() {  step1();  step2();  hookMethod(); // 钩子方法，允许子类在必要时提供自己的实现  step3();  }  // 抽象方法，由子类实现  protected abstract void step1();  protected abstract void step3();  // 钩子方法，有默认实现，但允许子类覆盖  protected void hookMethod() {  // 默认实现为空，或者提供一些通用的行为  }  // 具体方法，可以包含一些算法的通用步骤  private void step2() {  // 这里是算法的一个具体步骤，通常不需要子类覆盖  }  
}

2. 实现具体子类

然后，你需要创建具体子类，这些子类将提供模板方法中抽象方法和钩子方法的具体实现。

// ConcreteClassA.java  
public class ConcreteClassA extends AbstractClass {  @Override  protected void step1() {  System.out.println("ConcreteClassA implementation of step1");  }  @Override  protected void step3() {  System.out.println("ConcreteClassA implementation of step3");  }  // 可以选择覆盖钩子方法以提供额外的行为  // @Override  // protected void hookMethod() {  //     System.out.println("ConcreteClassA implementation of hookMethod");  // }  
}  // ConcreteClassB.java  
public class ConcreteClassB extends AbstractClass {  @Override  protected void step1() {  System.out.println("ConcreteClassB implementation of step1");  }  @Override  protected void step3() {  System.out.println("ConcreteClassB implementation of step3");  }  // 覆盖钩子方法以提供不同的行为  @Override  protected void hookMethod() {  System.out.println("ConcreteClassB implementation of hookMethod");  }  
}

3. 在Spring Boot应用中使用

最后，在你的Spring Boot应用中，你可以像使用任何其他Spring Bean一样使用这些具体子类。你可以通过配置类、@Component注解或直接在控制器、服务等组件中实例化它们。

// TemplateMethodPatternApplication.java  
import org.springframework.boot.CommandLineRunner;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  @SpringBootApplication  
public class TemplateMethodPatternApplication implements CommandLineRunner {  public static void main(String[] args) {  SpringApplication.run(TemplateMethodPatternApplication.class, args);  }  @Override  public void run(String... args) throws Exception {  AbstractClass concreteClassA = new ConcreteClassA();  AbstractClass concreteClassB = new ConcreteClassB();  // 调用模板方法  concreteClassA.templateMethod();  concreteClassB.templateMethod();  }  
}

在这个示例中，TemplateMethodPatternApplication是我们的Spring Boot应用主类。它创建了两个具体子类的实例，并调用了它们的模板方法。这将按照算法框架执行，并使用子类提供的具体实现。

请注意，虽然在这个例子中我们没有将AbstractClass及其子类作为Spring Bean来管理，但在实际的应用中，你可能会希望这样做以便利用Spring的依赖注入功能。你可以通过添加@Component注解并使用@Autowired或@Bean注解来将这些类集成到Spring的上下文中。

7. 适配器模式（Adapter Pattern）

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许接口不兼容的类一起工作。在Spring Boot应用中，你可以使用适配器模式来适配不同接口或类的实现，以便它们可以无缝地协同工作。

下面是一个如何在Spring Boot中使用适配器模式的示例。

假设我们有一个旧的支付服务（LegacyPaymentService），它的接口和新支付服务（NewPaymentService）的接口不兼容。我们需要一个适配器来使它们可以一起工作。

1. 定义旧的支付服务接口和实现

首先，我们定义一个旧的支付服务接口及其实现：

// LegacyPaymentService.java  
public interface LegacyPaymentService {  void makeLegacyPayment(double amount);  
}  // LegacyPaymentServiceImpl.java  
public class LegacyPaymentServiceImpl implements LegacyPaymentService {  @Override  public void makeLegacyPayment(double amount) {  System.out.println("Making legacy payment of: " + amount);  }  
}

2. 定义新的支付服务接口和实现

接下来，我们定义一个新的支付服务接口及其实现：

// NewPaymentService.java  
public interface NewPaymentService {  void makePayment(double amount);  
}  // NewPaymentServiceImpl.java  
public class NewPaymentServiceImpl implements NewPaymentService {  @Override  public void makePayment(double amount) {  System.out.println("Making new payment of: " + amount);  }  
}

3. 创建适配器类

现在，我们需要创建一个适配器类，它将旧的支付服务适配为新的支付服务：

// LegacyPaymentServiceAdapter.java  
public class LegacyPaymentServiceAdapter implements NewPaymentService {  private LegacyPaymentService legacyPaymentService;  public LegacyPaymentServiceAdapter(LegacyPaymentService legacyPaymentService) {  this.legacyPaymentService = legacyPaymentService;  }  @Override  public void makePayment(double amount) {  legacyPaymentService.makeLegacyPayment(amount);  }  
}

4. 使用Spring Boot配置和测试

最后，我们在Spring Boot应用中配置这些类并进行测试。


import org.springframework.boot.CommandLineRunner;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
import org.springframework.context.annotation.Bean;  @SpringBootApplication  
public class PaymentServiceApplication implements CommandLineRunner {  public static void main(String[] args) {  SpringApplication.run(PaymentServiceApplication.class, args);  }  @Bean  public LegacyPaymentService legacyPaymentService() {  return new LegacyPaymentServiceImpl();  }  @Bean  public NewPaymentService newPaymentService(LegacyPaymentService legacyPaymentService) {  return new LegacyPaymentServiceAdapter(legacyPaymentService);  }  @Override  public void run(String... args) throws Exception {  NewPaymentService paymentService = newPaymentService();  paymentService.makePayment(100.0);  }  
}

在这个示例中，PaymentServiceApplication类是我们的Spring Boot应用主类。它定义了两个Bean：legacyPaymentService和newPaymentService。newPaymentService是通过LegacyPaymentServiceAdapter适配的legacyPaymentService。

当运行Spring Boot应用时，run方法会被调用，并且适配器会将新的支付请求转换为旧的支付请求，并输出相应的日志。

8. 装饰者模式（Decorator Pattern）

装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许你动态地将责任附加到对象上，而无需修改其现有的代码。在Spring Boot应用中，你可以使用装饰者模式来增强或修改对象的行为，而无需使用继承或创建大量的子类。

1. 定义组件接口

首先，我们定义一个接口，该接口将作为要装饰的对象的基类或接口。

// PaymentComponent.java  
public interface PaymentComponent {  void pay(double amount);  
}

2. 实现基础组件

接下来，我们实现这个接口的基础版本，即不添加任何装饰的组件。

// SimplePayment.java  
public class SimplePayment implements PaymentComponent {  @Override  public void pay(double amount) {  System.out.println("Paid: " + amount);  }  
}

3. 创建装饰者基类

现在，我们创建一个装饰者基类，它实现了相同的接口，并持有一个被装饰对象的引用。

// PaymentDecorator.java  
public abstract class PaymentDecorator implements PaymentComponent {  protected PaymentComponent paymentComponent;  public PaymentDecorator(PaymentComponent paymentComponent) {  this.paymentComponent = paymentComponent;  }  @Override  public abstract void pay(double amount);  
}

4. 实现具体的装饰者

然后，我们实现具体的装饰者，这些装饰者将添加额外的行为或修改现有行为。

// LoggingPaymentDecorator.java  
public class LoggingPaymentDecorator extends PaymentDecorator {  public LoggingPaymentDecorator(PaymentComponent paymentComponent) {  super(paymentComponent);  }  @Override  public void pay(double amount) {  System.out.println("Logging payment of: " + amount);  paymentComponent.pay(amount);  }  
}  // TaxPaymentDecorator.java  
public class TaxPaymentDecorator extends PaymentDecorator {  private double taxRate;  public TaxPaymentDecorator(PaymentComponent paymentComponent, double taxRate) {  super(paymentComponent);  this.taxRate = taxRate;  }  @Override  public void pay(double amount) {  double totalAmount = amount * (1 + taxRate);  System.out.println("Applying tax rate of " + (taxRate * 100) + "%");  paymentComponent.pay(totalAmount);  }  
}

5. 使用Spring Boot配置和测试

最后，我们在Spring Boot应用中配置这些类并进行测试。

// PaymentServiceApplication.java  
import org.springframework.boot.CommandLineRunner;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
import org.springframework.context.annotation.Bean;  @SpringBootApplication  
public class PaymentServiceApplication implements CommandLineRunner {  public static void main(String[] args) {  SpringApplication.run(PaymentServiceApplication.class, args);  }  @Bean  public PaymentComponent simplePayment() {  return new SimplePayment();  }  @Bean  public PaymentComponent decoratedPayment(PaymentComponent simplePayment, double taxRate) {  PaymentComponent loggingPayment = new LoggingPaymentDecorator(simplePayment);  return new TaxPaymentDecorator(loggingPayment, taxRate);  }  @Override  public void run(String... args) throws Exception {  PaymentComponent paymentComponent = decoratedPayment(simplePayment(), 0.10); // 10% tax rate  paymentComponent.pay(100.0);  }  
}

在这个示例中，PaymentServiceApplication类是我们的Spring Boot应用主类。它定义了两个Bean：simplePayment和decoratedPayment。decoratedPayment是通过组合LoggingPaymentDecorator和TaxPaymentDecorator来装饰simplePayment的。

然而，需要注意的是，在Spring容器中直接这样配置decoratedPaymentBean可能会有些复杂，因为我们需要传递一个double类型的taxRate参数。在实际应用中，你可能会使用配置属性、环境变量或其他方式来传递这个参数。

为了简化示例，这里直接在run方法中创建了装饰后的对象。但在实际生产环境中，你应该通过配置或注入的方式来管理这些Bean的依赖关系。

9. 原型模式（Prototype Pattern）

原型模式用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。在Spring中，可以通过实现PrototypeBeanFactory来创建原型Bean。

// 原型Bean类  
public class PrototypeBean implements Cloneable {  private String name;  public void setName(String name) {  this.name = name;  }  public String getName() {  return name;  }  @Override  protected Object clone() throws CloneNotSupportedException {  return super.clone();  }  
}  // 配置类  
@Configuration  
public class AppConfig {  @Bean  @Scope("prototype")  public PrototypeBean prototypeBean() {  return new PrototypeBean();  }  
}