当前位置: 首页 > article >正文

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:legacyPaymentServicenewPaymentServicenewPaymentService是通过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:simplePaymentdecoratedPaymentdecoratedPayment是通过组合LoggingPaymentDecoratorTaxPaymentDecorator来装饰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();  
    }  
}

http://www.kler.cn/a/371597.html

相关文章:

  • 一道巧妙的卡特兰数建模
  • 【python GUI编码入门-03】掌握Tkinter如何高效绑定键盘和鼠标事件
  • 交叉编译 lmbench(riscv64)
  • 前端零基础入门到上班:【Day3】从零开始构建网页骨架HTML
  • Educational Codeforces Round 88 E. Modular Stability
  • 2024年9月电子学会青少年软件编程Python等级考试(三级)真题试卷
  • Linux 命令行参数 环境变量
  • 自己动手给ESP8285 / ESP8266 1MB 编译新版AT 固件
  • 第二代支付系统报文交换标准【大额支付系统分册】(版本1.5.6)
  • 【笔记】复数基础复数相乘的物理意义:旋转+缩放
  • synchronized基本用法、原理?
  • 论文阅读 - Pre-trained Online Contrastive Learning for Insurance Fraud Detection
  • es实现自动补全
  • k8s_Pod健康检查
  • Mamba应用领域
  • 【C++】踏上C++学习之旅(四):细说“内联函数“的那些事
  • 如何实现PHP的安全最大化
  • ETF申购赎回指南:详解注意事项与低费率券商推荐!
  • 双十一我都入手了啥大件?这几款超值好物分享给你
  • c++习题36-奇数单增序列
  • 【17】 傅立叶分析
  • Java项目实战II基于Spring Boot的小型诊疗预约平台(开发文档+数据库+源码)
  • 【LeetCode热题100】链表
  • 初识算法 · 前缀和(1)
  • 使用TimeShift备份和恢复Ubuntu Linux
  • jeecgbootvue2菜单路由配置静态文件夹(public)下的html