20240620每日后端---------Spring Boot中的 5 大设计模式最佳实践和示例这些是我经常使用的设计模式并且非常喜欢

在这里插入图片描述
在本文中，我们将深入探讨五种基本设计模式，并探讨在 Spring Boot 项目中有效应用它们的最佳实践。每个模式都将附有一个实际示例来演示其实现。

单例模式

Singleton 模式确保一个类只有一个实例，并提供对它的全局访问点。这对于管理资源（如数据库连接或缓存对象）特别有用。以下是如何在 Spring Boot 中实现它：

public class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {
        // Private constructor to prevent instantiation
    }
    public static synchronized DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

工厂方法模式

工厂方法模式提供了一个用于在超类中创建对象的接口，允许子类更改将要创建的对象的类型。这对于将对象创建逻辑与客户端代码分离非常有用。让我们看一个 Spring Boot 中的示例：

public interface PaymentProcessor {
    void processPayment();
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment() {
        // Process credit card payment logic
    }
}
public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment() {
        // Process PayPal payment logic
    }
}
public interface PaymentProcessorFactory {
    PaymentProcessor createPaymentProcessor();
}
@Component
public class PaymentProcessorFactoryImpl implements PaymentProcessorFactory {
    @Override
    public PaymentProcessor createPaymentProcessor() {
        // Logic to determine which processor to create (based on configuration, etc.)
        return new CreditCardProcessor();
    }
}

观察者模式

Observer 模式定义了对象之间的一对多依赖关系，确保当一个对象更改状态时，其依赖项会自动收到通知和更新。这通常用于事件驱动系统。让我们在 Spring Boot 中实现它：

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class OrderListener implements ApplicationListener<OrderEvent> {
    @Override
    public void onApplicationEvent(OrderEvent event) {
        // Handle order event
    }
}

public class OrderEvent extends ApplicationEvent {
    public OrderEvent(Object source) {
        super(source);
    }
}

@Component
public class OrderService {
    private ApplicationEventPublisher eventPublisher;
    public OrderService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    public void placeOrder() {
        // Logic to place order
        // Publish order event
        eventPublisher.publishEvent(new OrderEvent(this));
    }
}

装饰器模式

Decorator 模式允许将行为动态添加到对象中，而不会影响同一类中其他对象的行为。这对于向现有类添加日志记录、缓存或加密等功能非常有用。让我们在 Spring Boot 中实现它：

public interface DataService {
    void fetchData();
}

@Component
public class DataServiceImplementation implements DataService {
    @Override
    public void fetchData() {
        // Fetch data implementation
    }
}
@Component
public class LoggingDecorator implements DataService {
    private DataService delegate;
    public LoggingDecorator(DataService delegate) {
        this.delegate = delegate;
    }
    @Override
    public void fetchData() {
        // Logging logic before fetching data
        delegate.fetchData();
        // Logging logic after fetching data
    }
}

策略模式：

Strategy 模式定义了一系列算法，封装了每个算法，并使它们可以互换。当您有多个可以互换使用的算法时，这很有用。让我们在 Spring Boot 中实现它：

public interface CompressionStrategy {
    void compress(String file);
}

@Component
public class ZipCompressionStrategy implements CompressionStrategy {
    @Override
    public void compress(String file) {
        // Zip compression logic
    }
}
@Component
public class RarCompressionStrategy implements CompressionStrategy {
    @Override
    public void compress(String file) {
        // RAR compression logic
    }
}
@Component
public class CompressionContext {
    private CompressionStrategy strategy;
    public CompressionContext(CompressionStrategy strategy) {
        this.strategy = strategy;
    }
    public void setStrategy(CompressionStrategy strategy) {
        this.strategy = strategy;
    }
    public void compressFile(String file) {
        strategy.compress(file);
    }
}