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中的事件监听机制就是观察者模式的一个应用。
// 自定义事件
public class MyEvent extends ApplicationEvent { private String message; public MyEvent(Object source, String message) { super(source); this.message = message; } public String getMessage() { return message; }
} // 事件发布者
@Component
public class EventPublisher { @Autowired private ApplicationEventPublisher applicationEventPublisher; public void publishEvent(String message) { MyEvent event = new MyEvent(this, message); applicationEventPublisher.publishEvent(event); }
} // 事件监听者
@Component
public class MyEventListener { @EventListener public void handleMyEvent(MyEvent event) { System.out.println("Received event - " + event.getMessage()); }
}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）
模板方法模式在一个抽象类中定义了一个算法的骨架，而将一些步骤延迟到子类中实现。
// 抽象类
public abstract class AbstractShoppingCart { public final void processOrder() { addToCart(); calculateTotalPrice(); pay(); } protected abstract void addToCart(); protected abstract void calculateTotalPrice(); protected abstract void pay();
} // 具体实现类
public class SuishiShoppingCart extends AbstractShoppingCart { @Override protected void addToCart() { System.out.println("将商品加入购物车"); } @Override protected void calculateTotalPrice() { System.out.println("计算总价"); } @Override protected void pay() { System.out.println("完成支付"); }
}7. 适配器模式（Adapter Pattern）
适配器模式将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
// 目标接口
public interface Target { void request();
} // 源类
public class Adaptee { public void specificRequest() { System.out.println("Called specificRequest()"); }
} // 适配器类
public class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } @Override public void request() { adaptee.specificRequest(); }
}8. 装饰者模式（Decorator Pattern）
装饰者模式动态地给一个对象添加一些额外的职责。就扩展功能而言，它比生成子类方式更为灵活。
// 组件接口
public interface Component { void operation();
} // 具体组件
public class ConcreteComponent implements Component { @Override public void operation() { System.out.println("ConcreteComponent's operation"); }
} // 装饰器抽象类
public abstract class Decorator implements Component { protected Component component; public Decorator(Component component) { this.component = component; } @Override public void operation() { component.operation(); }
} // 具体装饰器
public class ConcreteDecoratorA extends Decorator { public ConcreteDecoratorA(Component component) { super(component); } @Override public void operation() { super.operation(); addedBehavior(); } public void addedBehavior() { System.out.println("ConcreteDecoratorA's added behavior"); }
}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(); }
}