AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

如何在 Spring 项目中优雅地使用设计模式

2025-11-13 242
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文深入探讨在Spring项目中如何优雅应用设计模式，结合依赖注入与IoC特性，通过工厂、策略、装饰者等模式提升代码可维护性与扩展性，助力构建高效、灵活的Java应用。

如何在 Spring 项目中优雅地使用设计模式

引言

设计模式是软件开发中的经典智慧结晶，它们提供了经过验证的解决方案来处理常见的设计问题。在 Spring 项目中，设计模式的应用可以显著提升代码的可维护性、可扩展性和可重用性。Spring 框架本身就是一个设计模式的集大成者，它广泛使用了工厂模式、单例模式、代理模式等多种设计模式。

本文将深入探讨如何在 Spring 项目中优雅地使用设计模式，通过实际代码示例展示各种模式的应用场景和实现方式。我们将从基础的创建型模式开始，逐步深入到结构型和行为型模式，并探讨如何在 Spring 的依赖注入环境中更好地应用这些模式。

创建型模式在 Spring 中的应用

工厂模式

工厂模式是 Spring 框架的核心设计模式之一。Spring 的 IoC 容器本质上就是一个工厂，负责创建和管理对象实例。在实际项目中，我们可以通过自定义工厂来处理复杂的对象创建逻辑。

@Component
public class OrderProcessorFactory {
   
@Autowired
private Map<String, OrderProcessor> processorMap;

public OrderProcessor getProcessor(String orderType) {
   
    return processorMap.getOrDefault(orderType, 
        processorMap.get("default"));
}

@Component("regular")
public class RegularOrderProcessor implements OrderProcessor {
   
@Override
public void process(Order order) {
   
    // 处理普通订单逻辑
    System.out.println("Processing regular order: " + order.getId());
}

@Component("premium")
public class PremiumOrderProcessor implements OrderProcessor {
   
@Override
public void process(Order order) {
   
    // 处理高级订单逻辑
    System.out.println("Processing premium order: " + order.getId());
}
}

@Component("default")
public class DefaultOrderProcessor implements OrderProcessor {
   
@Override
public void process(Order order) {
   
    System.out.println("Processing default order: " + order.getId());
}
}

这种基于 Spring 的工厂模式利用了依赖注入的优势，通过 Map 注入所有实现类，避免了硬编码的条件判断。

建造者模式

建造者模式特别适用于需要复杂对象构建的场景。在 Spring 项目中，我们可以将建造者模式与 Bean 的生命周期管理相结合。
@Component
public class OrderBuilder {
   
private String orderId;
private String customerId;
private List<OrderItem> items = new ArrayList<>();
private String shippingAddress;
private String paymentMethod;
private LocalDateTime orderDate;

public OrderBuilder setOrderId(String orderId) {
   
    this.orderId = orderId;
    return this;
}

public OrderBuilder setCustomerId(String customerId) {
   
    this.customerId = customerId;
    return this;
}

public OrderBuilder addItem(OrderItem item) {
   
    this.items.add(item);
    return this;
}

public OrderBuilder addItems(List<OrderItem> items) {
   
    this.items.addAll(items);
    return this;
}

public OrderBuilder setShippingAddress(String shippingAddress) {
   
    this.shippingAddress = shippingAddress;
    return this;
}

public OrderBuilder setPaymentMethod(String paymentMethod) {
   
    this.paymentMethod = paymentMethod;
    return this;
}

public Order build() {
   
    Order order = new Order();
    order.setId(orderId);
    order.setCustomerId(customerId);
    order.setItems(items);
    order.setShippingAddress(shippingAddress);
    order.setPaymentMethod(paymentMethod);
    order.setOrderDate(orderDate != null ? orderDate : LocalDateTime.now());
    order.setStatus(OrderStatus.CREATED);
    order.setTotalAmount(calculateTotalAmount());
    return order;
}

private BigDecimal calculateTotalAmount() {
   
    return items.stream()
        .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
        .reduce(BigDecimal.ZERO, BigDecimal::add);
}
}

@Service
public class OrderService {
   
@Autowired
private OrderBuilder orderBuilder;

public Order createOrder(String customerId, List<OrderItem> items, String shippingAddress) {
   
    return orderBuilder
        .setCustomerId(customerId)
        .addItems(items)
        .setShippingAddress(shippingAddress)
        .setPaymentMethod("CREDIT_CARD")
        .build();
}
}

建造者模式使得复杂的对象创建过程更加清晰和可控，特别适合在业务逻辑复杂、对象属性较多的场景中使用。

结构型模式在 Spring 中的应用

适配器模式

适配器模式在 Spring 项目中有着广泛的应用，特别是在集成外部系统或处理不同格式的数据时。

public interface PaymentProcessor {
   
PaymentResult processPayment(PaymentRequest request);
}

@Component
public class StripePaymentAdapter implements PaymentProcessor {
   
@Autowired
private StripeService stripeService;

@Override
public PaymentResult processPayment(PaymentRequest request) {
   
    StripePaymentRequest stripeRequest = convertToStripeRequest(request);
    StripePaymentResponse stripeResponse = stripeService.charge(stripeRequest);
    return convertToPaymentResult(stripeResponse);
}

private StripePaymentRequest convertToStripeRequest(PaymentRequest request) {
   
    StripePaymentRequest stripeRequest = new StripePaymentRequest();
    stripeRequest.setAmount(request.getAmount());
    stripeRequest.setCurrency(request.getCurrency());
    stripeRequest.setSource(request.getPaymentMethod());
    return stripeRequest;
}

private PaymentResult convertToPaymentResult(StripePaymentResponse response) {
   
    PaymentResult result = new PaymentResult();
    result.setSuccess(response.isSuccess());
    result.setTransactionId(response.getTransactionId());
    result.setMessage(response.getMessage());
    return result;
}
}

@Component
public class PayPalPaymentAdapter implements PaymentProcessor {
   
@Autowired
private PayPalService payPalService;

@Override
public PaymentResult processPayment(PaymentRequest request) {
   
    PayPalPaymentRequest payPalRequest = convertToPayPalRequest(request);
    PayPalPaymentResponse payPalResponse = payPalService.process(payPalRequest);
    return convertToPaymentResult(payPalResponse);
}

private PayPalPaymentRequest convertToPayPalRequest(PaymentRequest request) {
   
    PayPalPaymentRequest payPalRequest = new PayPalPaymentRequest();
    payPalRequest.setAmount(request.getAmount());
    payPalRequest.setCurrency(request.getCurrency());
    payPalRequest.setPayerEmail(request.getCustomerEmail());
    return payPalRequest;
}

private PaymentResult convertToPaymentResult(PayPalPaymentResponse response) {
   
    PaymentResult result = new PaymentResult();
    result.setSuccess(response.isSuccess());
    result.setTransactionId(response.getTransactionId());
    result.setMessage(response.getMessage());
    return result;
}
}

@Service
public class PaymentService {
   
@Autowired
private Map<String, PaymentProcessor> paymentProcessorMap;

public PaymentResult processPayment(String provider, PaymentRequest request) {
   
    PaymentProcessor processor = paymentProcessorMap.get(provider);
    if (processor == null) {
   
        throw new IllegalArgumentException("Unknown payment provider: " + provider);
    }
    return processor.processPayment(request);
}
}

通过适配器模式，我们可以轻松集成不同的支付服务，而无需修改核心业务逻辑。

装饰器模式

装饰器模式在 Spring 项目中常用于添加横切关注点，如日志记录、性能监控、安全检查等。

public interface OrderService {
   
Order createOrder(OrderRequest request);
Order updateOrder(String orderId, OrderUpdateRequest request);
void cancelOrder(String orderId);
}

@Service
public class OrderServiceImpl implements OrderService {
   
@Autowired
private OrderRepository orderRepository;

@Override
public Order createOrder(OrderRequest request) {
   
    Order order = new Order();
    order.setId(generateOrderId());
    order.setCustomerId(request.getCustomerId());
    order.setItems(request.getItems());
    order.setStatus(OrderStatus.CREATED);
    order.setTotalAmount(calculateTotal(request.getItems()));
    return orderRepository.save(order);
}

@Override
public Order updateOrder(String orderId, OrderUpdateRequest request) {
   
    Order order = orderRepository.findById(orderId)
        .orElseThrow(() -> new OrderNotFoundException(orderId));

    if (request.getItems() != null) {
   
        order.setItems(request.getItems());
    }
    if (request.getShippingAddress() != null) {
   
        order.setShippingAddress(request.getShippingAddress());
    }

    order.setTotalAmount(calculateTotal(order.getItems()));
    return orderRepository.save(order);
}

@Override
public void cancelOrder(String orderId) {
   
    Order order = orderRepository.findById(orderId)
        .orElseThrow(() -> new OrderNotFoundException(orderId));

    if (order.getStatus() != OrderStatus.CREATED) {
   
        throw new IllegalStateException("Only created orders can be cancelled");
    }

    order.setStatus(OrderStatus.CANCELLED);
    orderRepository.save(order);
}

private String generateOrderId() {
   
    return "ORD-" + System.currentTimeMillis();
}

private BigDecimal calculateTotal(List<OrderItem> items) {
   
    return items.stream()
        .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
        .reduce(BigDecimal.ZERO, BigDecimal::add);
}
}

@Component
public class LoggingOrderServiceDecorator implements OrderService {
   
@Autowired
private OrderService orderService;

@Override
public Order createOrder(OrderRequest request) {
   
    log.info("Creating order for customer: {}", request.getCustomerId());
    long startTime = System.currentTimeMillis();

    try {
   
        Order result = orderService.createOrder(request);
        log.info("Order created successfully: {} in {}ms", 
            result.getId(), System.currentTimeMillis() - startTime);
        return result;
    } catch (Exception e) {
   
        log.error("Failed to create order for customer: {}", 
            request.getCustomerId(), e);
        throw e;
    }
}

@Override
public Order updateOrder(String orderId, OrderUpdateRequest request) {
   
    log.info("Updating order: {}", orderId);
    long startTime = System.currentTimeMillis();

    try {
   
        Order result = orderService.updateOrder(orderId, request);
        log.info("Order updated successfully: {} in {}ms", 
            orderId, System.currentTimeMillis() - startTime);
        return result;
    } catch (Exception e) {
   
        log.error("Failed to update order: {}", orderId, e);
        throw e;
    }
}

@Override
public void cancelOrder(String orderId) {
   
    log.info("Cancelling order: {}", orderId);
    long startTime = System.currentTimeMillis();

    try {
   
        orderService.cancelOrder(orderId);
        log.info("Order cancelled successfully: {} in {}ms", 
            orderId, System.currentTimeMillis() - startTime);
    } catch (Exception e) {
   
        log.error("Failed to cancel order: {}", orderId, e);
        throw e;
    }
}
}

@Component
public class CachingOrderServiceDecorator implements OrderService {
   
@Autowired
private OrderService orderService;

@Autowired
private CacheManager cacheManager;

@Override
public Order createOrder(OrderRequest request) {
   
    Order order = orderService.createOrder(request);
    // 清除相关缓存
    evictCache("customer_orders_" + request.getCustomerId());
    return order;
}

@Override
public Order updateOrder(String orderId, OrderUpdateRequest request) {
   
    Order order = orderService.updateOrder(orderId, request);
    // 清除相关缓存
    evictCache("order_" + orderId);
    evictCache("customer_orders_" + order.getCustomerId());
    return order;
}

@Override
public void cancelOrder(String orderId) {
   
    Order order = orderService.getOrderById(orderId); // 假设有此方法
    orderService.cancelOrder(orderId);
    // 清除相关缓存
    evictCache("order_" + orderId);
    evictCache("customer_orders_" + order.getCustomerId());
}

private void evictCache(String key) {
   
    Cache cache = cacheManager.getCache("orders");
    if (cache != null) {
   
        cache.evict(key);
    }
}
}

装饰器模式允许我们在不修改原有代码的情况下添加新的功能，这完全符合开闭原则。

行为型模式在 Spring 中的应用

策略模式

策略模式在 Spring 项目中应用广泛，特别适合处理业务逻辑的多种实现方式。

public interface DiscountStrategy {
   
BigDecimal calculateDiscount(Order order);
boolean isApplicable(Order order);
}

```js
@Component("percentage")
public class PercentageDiscountStrategy implements DiscountStrategy {
   
@Value("${discount.percentage.threshold:100}")
private BigDecimal threshold;

@Value("${discount.percentage.rate:0.1}")
private BigDecimal rate;

@Override
public BigDecimal calculateDiscount(Order order) {
   
    if (order.getTotalAmount().compareTo(threshold) > 0) {
   
        return order.getTotalAmount().multiply(rate);
    }
    return BigDecimal.ZERO;
}

@Override
public boolean isApplicable(Order order) {
   
    return order.getTotalAmount().compareTo(threshold) > 0;
}
}

@Component("fixed")
public class FixedDiscountStrategy implements DiscountStrategy {
@Value("${discount.fixed.amount:5}")
private BigDecimal fixedAmount;

@Override
public BigDecimal calculateDiscount(Order order) {
return fixedAmount;
}

@Override
public boolean isApplicable(Order order) {
return order.getItems().size() > 5;
}
}

```js
@Component("bulk")
public class BulkDiscountStrategy implements DiscountStrategy {

@Override
public BigDecimal calculateDiscount(Order order) {
    long bulkItems = order.getItems().stream()
        .filter(item -> item.getQuantity() > 10)
        .count();

    if (bulkItems > 0) {
        return order.getTotalAmount().multiply(BigDecimal.valueOf(0.15));
    }
    return BigDecimal.ZERO;
}

@Override
public boolean isApplicable(Order order) {
    return order.getItems().stream().anyMatch(item -> item.getQuantity() > 10);
}
}

@Service
public class DiscountService {
   
@Autowired
private List<DiscountStrategy> strategies;

public BigDecimal calculateBestDiscount(Order order) {
   
    return strategies.stream()
        .filter(strategy -> strategy.isApplicable(order))
        .map(strategy -> strategy.calculateDiscount(order))
        .max(BigDecimal::compareTo)
        .orElse(BigDecimal.ZERO);
}

public List<Discount> getAllApplicableDiscounts(Order order) {
   
    return strategies.stream()
        .filter(strategy -> strategy.isApplicable(order))
        .map(strategy -> new Discount(
            strategy.getClass().getSimpleName(),
            strategy.calculateDiscount(order)
        ))
        .collect(Collectors.toList());
}
}

策略模式使得我们可以轻松地添加新的折扣策略，而无需修改现有的代码。

观察者模式

观察者模式在 Spring 中通过事件驱动机制得到了很好的支持，Spring 的事件系统就是观察者模式的典型实现。

public class OrderCreatedEvent {
   
private final Order order;
private final LocalDateTime timestamp;
public OrderCreatedEvent(Order order) {
   
    this.order = order;
    this.timestamp = LocalDateTime.now();
}

// getters
}

public class OrderStatusChangedEvent {
   
private final String orderId;
private final OrderStatus oldStatus;
private final OrderStatus newStatus;
private final LocalDateTime timestamp;
public OrderStatusChangedEvent(String orderId, OrderStatus oldStatus, OrderStatus newStatus) {
   
    this.orderId = orderId;
    this.oldStatus = oldStatus;
    this.newStatus = newStatus;
    this.timestamp = LocalDateTime.now();
}

// getters
}

@Component
public class OrderEventPublisher {
   
@Autowired
private ApplicationEventPublisher eventPublisher;

public void publishOrderCreated(Order order) {
   
    eventPublisher.publishEvent(new OrderCreatedEvent(order));
}

public void publishOrderStatusChanged(String orderId, OrderStatus oldStatus, OrderStatus newStatus) {
   
    eventPublisher.publishEvent(new OrderStatusChangedEvent(orderId, oldStatus, newStatus));
}
}

@Component
public class InventoryUpdateEventListener {
   
@EventListener
@Async
public void handleOrderCreated(OrderCreatedEvent event) {
   
    Order order = event.getOrder();
    // 异步更新库存
    order.getItems().forEach(item -> {
   
        inventoryService.reserve(item.getProductId(), item.getQuantity());
    });
}

@EventListener
@Async
public void handleOrderStatusChanged(OrderStatusChangedEvent event) {
   
    if (event.getNewStatus() == OrderStatus.CANCELLED) {
   
        // 订单取消时释放库存
        inventoryService.release(event.getOrderId());
    }
}
}

@Component
public class EmailNotificationEventListener {
   
@EventListener
public void handleOrderCreated(OrderCreatedEvent event) {
   
    Order order = event.getOrder();
    emailService.sendOrderConfirmation(order.getCustomerId(), order.getId());
}

@EventListener
public void handleOrderStatusChanged(OrderStatusChangedEvent event) {
   
    if (event.getNewStatus() == OrderStatus.SHIPPED) {
   
        emailService.sendShippingNotification(
            event.getOrderId(), 
            "Your order has been shipped!"
        );
    }
}
}

@Component
public class AnalyticsEventListener {
   
@EventListener
@Async
public void handleOrderCreated(OrderCreatedEvent event) {
   
    Order order = event.getOrder();
    analyticsService.recordOrderMetrics(
        order.getId(),
        order.getTotalAmount(),
        order.getItems().size()
    );
}
}

Spring 的事件系统使得观察者模式的实现变得非常简单，同时支持同步和异步事件处理。

模板方法模式

模板方法模式在 Spring 中可以通过抽象类和回调机制来实现，特别适合处理有固定流程但某些步骤可变的业务场景。

public abstract class OrderProcessingTemplate {
   
public final Order processOrder(OrderRequest request) {
   
    // 验证订单
    validateOrder(request);

    // 创建订单
    Order order = createOrder(request);

    // 应用折扣
    applyDiscounts(order);

    // 计算税费
    calculateTax(order);

    // 保存订单
    Order savedOrder = saveOrder(order);

    // 发布事件
    publishOrderCreatedEvent(savedOrder);

    return savedOrder;
}

protected abstract void validateOrder(OrderRequest request);

protected abstract Order createOrder(OrderRequest request);

protected abstract void applyDiscounts(Order order);

protected abstract void calculateTax(Order order);

protected abstract Order saveOrder(Order order);

protected abstract void publishOrderCreatedEvent(Order order);
}

@Service
public class StandardOrderProcessingService extends OrderProcessingTemplate {
   
@Autowired
private OrderRepository orderRepository;

@Autowired
private DiscountService discountService;

@Autowired
private TaxCalculator taxCalculator;

@Autowired
private OrderEventPublisher eventPublisher;

@Override
protected void validateOrder(OrderRequest request) {
   
    if (request.getItems().isEmpty()) {
   
        throw new IllegalArgumentException("Order must have at least one item");
    }
    if (request.getCustomerId() == null) {
   
        throw new IllegalArgumentException("Customer ID is required");
    }
}

@Override
protected Order createOrder(OrderRequest request) {
   
    Order order = new Order();
    order.setId("ORD-" + System.currentTimeMillis());
    order.setCustomerId(request.getCustomerId());
    order.setItems(request.getItems());
    order.setStatus(OrderStatus.CREATED);
    order.setShippingAddress(request.getShippingAddress());
    order.setPaymentMethod(request.getPaymentMethod());
    return order;
}

@Override
protected void applyDiscounts(Order order) {
   
    BigDecimal discount = discountService.calculateBestDiscount(order);
    order.setDiscount(discount);
    order.setTotalAmount(order.getTotalAmount().subtract(discount));
}

@Override
protected void calculateTax(Order order) {
   
    BigDecimal tax = taxCalculator.calculateTax(order);
    order.setTax(tax);
    order.setTotalAmount(order.getTotalAmount().add(tax));
}

@Override
protected Order saveOrder(Order order) {
   
    return orderRepository.save(order);
}

@Override
protected void publishOrderCreatedEvent(Order order) {
   
    eventPublisher.publishOrderCreated(order);
}
}

@Service
public class PremiumOrderProcessingService extends OrderProcessingTemplate {
   
@Autowired
private OrderRepository orderRepository;

@Autowired
private PremiumDiscountService premiumDiscountService;

@Autowired
private TaxCalculator taxCalculator;

@Autowired
private OrderEventPublisher eventPublisher;

@Override
protected void validateOrder(OrderRequest request) {
   
    // 额外的验证逻辑
    validatePremiumCustomer(request.getCustomerId());
    super.validateOrder(request);
}

private void validatePremiumCustomer(String customerId) {
   
    // 验证是否为高级客户
    if (!customerService.isPremiumCustomer(customerId)) {
   
        throw new IllegalArgumentException("Only premium customers can use this service");
    }
}

@Override
protected Order createOrder(OrderRequest request) {
   
    Order order = new Order();
    order.setId("PREMIUM-ORD-" + System.currentTimeMillis());
    order.setCustomerId(request.getCustomerId());
    order.setItems(request.getItems());
    order.setStatus(OrderStatus.CREATED);
    order.setShippingAddress(request.getShippingAddress());
    order.setPaymentMethod(request.getPaymentMethod());
    order.setPriority(OrderPriority.HIGH);
    return order;
}

@Override
protected void applyDiscounts(Order order) {
   
    // 使用高级折扣服务
    BigDecimal discount = premiumDiscountService.calculatePremiumDiscount(order);
    order.setDiscount(discount);
    order.setTotalAmount(order.getTotalAmount().subtract(discount));
}

@Override
protected void calculateTax(Order order) {
   
    BigDecimal tax = taxCalculator.calculateTax(order);
    order.setTax(tax);
    order.setTotalAmount(order.getTotalAmount().add(tax));
}

@Override
protected Order saveOrder(Order order) {
   
    return orderRepository.save(order);
}

@Override
protected void publishOrderCreatedEvent(Order order) {
   
    eventPublisher.publishOrderCreated(order);
    // 额外的高级订单事件
    eventPublisher.publishPremiumOrderCreated(order);
}
}

模板方法模式使得我们可以定义算法的骨架，同时允许子类重写特定的步骤。

组合多种设计模式

在实际项目中，往往需要组合多种设计模式来解决复杂的业务问题。让我们看一个综合示例：

// 策略接口
public interface PaymentValidationStrategy {
   
boolean validate(PaymentRequest request);
String getErrorMessage();
}

// 策略实现
@Component("creditCard")
public class CreditCardValidationStrategy implements PaymentValidationStrategy {
   
@Override
public boolean validate(PaymentRequest request) {
   
    String cardNumber = request.getCardNumber();
    return cardNumber != null && 
           cardNumber.matches("\\d{16}") && 
           validateCardNumber(cardNumber);
}

@Override
public String getErrorMessage() {
   
    return "Invalid credit card number";
}

private boolean validateCardNumber(String cardNumber) {
   
    // 简单的Luhn算法验证
    int sum = 0;
    boolean alternate = false;
    for (int i = cardNumber.length() - 1; i >= 0; i--) {
   
        int n = Integer.parseInt(cardNumber.substring(i, i + 1));
        if (alternate) {
   
            n *= 2;
            if (n > 9) {
   
                n = (n % 10) + 1;
            }
        }
        sum += n;
        alternate = !alternate;
    }
    return (sum % 10 == 0);
}
}

@Component("paypal")
public class PayPalValidationStrategy implements PaymentValidationStrategy {
   

@Override
public boolean validate(PaymentRequest request) {
   
    String email = request.getEmail();
    return email != null && email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
}

@Override
public String getErrorMessage() {
   
    return "Invalid PayPal email address";
}
}

// 工厂
@Component
public class PaymentValidationStrategyFactory {
   
@Autowired
private Map<String, PaymentValidationStrategy> strategyMap;

public PaymentValidationStrategy getStrategy(String paymentMethod) {
   
    return strategyMap.get(paymentMethod);
}
}

// 模板方法
public abstract class PaymentProcessingTemplate {
   
@Autowired
private PaymentValidationStrategyFactory factory;

public final PaymentResult processPayment(PaymentRequest request) {
   
    // 获取验证策略
    PaymentValidationStrategy strategy = factory.getStrategy(request.getPaymentMethod());

    // 验证支付信息
    if (!strategy.validate(request)) {
   
        return PaymentResult.failure(strategy.getErrorMessage());
    }

    // 执行具体的支付处理
    return executePayment(request);
}

protected abstract PaymentResult executePayment(PaymentRequest request);
}

// 具体实现
@Service("creditCard")
public class CreditCardPaymentService extends PaymentProcessingTemplate {
   
@Override
protected PaymentResult executePayment(PaymentRequest request) {
   
    // 信用卡支付处理逻辑
    try {
   
        // 调用支付网关
        PaymentGatewayResponse response = paymentGateway.chargeCreditCard(request);
        return PaymentResult.success(response.getTransactionId());
    } catch (Exception e) {
   
        return PaymentResult.failure("Payment failed: " + e.getMessage());
    }
}
}

@Service("paypal")
public class PayPalPaymentService extends PaymentProcessingTemplate {
   
@Override
protected PaymentResult executePayment(PaymentRequest request) {
   
    // PayPal支付处理逻辑
    try {
   
        // 调用PayPal API
        PayPalResponse response = payPalService.processPayment(request);
        return PaymentResult.success(response.getTransactionId());
    } catch (Exception e) {
   
        return PaymentResult.failure("Payment failed: " + e.getMessage());
    }
}
}

// 门面模式
@Component
public class PaymentFacade {
   
@Autowired
private Map<String, PaymentProcessingTemplate> paymentServices;

public PaymentResult processPayment(PaymentRequest request) {
   
    PaymentProcessingTemplate service = paymentServices.get(request.getPaymentMethod());
    if (service == null) {
   
        return PaymentResult.failure("Unsupported payment method: " + request.getPaymentMethod());
    }
    return service.processPayment(request);
}
}

// 适配器
@Component
public class ExternalPaymentAdapter implements PaymentProcessor {
   
@Autowired
private PaymentFacade paymentFacade;

@Override
public PaymentResult processPayment(PaymentRequest request) {
   
    // 适配外部系统的请求格式
    PaymentRequest adaptedRequest = adaptRequest(request);
    return paymentFacade.processPayment(adaptedRequest);
}

private PaymentRequest adaptRequest(PaymentRequest request) {
   
    // 转换请求格式
    PaymentRequest adapted = new PaymentRequest();
    adapted.setAmount(request.getAmount());
    adapted.setCurrency(request.getCurrency());
    adapted.setPaymentMethod(request.getPaymentMethod());
    // 添加其他必要的字段转换
    return adapted;
}
}

最佳实践和注意事项

依赖注入与设计模式的结合

Spring 的依赖注入机制为设计模式的应用提供了强大的支持。在使用设计模式时，要充分利用 Spring 的特性：

  • 使用 @Autowired 注入策略实现类
  • 利用 Map<String, Interface> 注入所有实现类
  • 使用 @Qualifier 指定具体的实现
  • 通过配置类定义 Bean 的创建逻辑

性能考虑

在应用设计模式时，要注意性能影响：

  • 避免过度设计，只在确实需要时才使用设计模式
  • 考虑模式的性能开销，特别是在高频调用的场景中
  • 使用缓存减少重复计算
  • 合理使用异步处理

测试友好性

设计模式应该支持良好的测试性：

  • 使用接口定义契约，便于模拟测试
  • 避免在构造函数中执行复杂逻辑
  • 保持方法的单一职责
  • 提供清晰的依赖关系

总结

设计模式在 Spring 项目中的应用能够显著提升代码质量和可维护性。通过合理选择和组合不同的设计模式，我们可以构建出更加灵活、可扩展的系统。关键是要理解每种模式的适用场景，避免过度使用设计模式导致的复杂性增加。

在实际项目中，我们应该根据具体的业务需求和技术约束，选择最适合的设计模式。Spring 框架提供了丰富的特性来支持设计模式的实现，我们应该充分利用这些特性来简化模式的实现和维护。

记住，设计模式是解决问题的工具，而不是目标本身。选择合适的模式，结合 Spring 的特性，可以让我们构建出更加优雅和高效的系统。


关于作者



🌟 我是suxiaoxiang，一位热爱技术的开发者

💡 专注于Java生态和前沿技术分享

🚀 持续输出高质量技术内容



如果这篇文章对你有帮助，请支持一下：




👍 点赞

⭐ 收藏

👀 关注


您的支持是我持续创作的动力！感谢每一位读者的关注与认可！


文章标签：
Java
Spring
设计模式
监控
缓存
Suxiaoxiang
目录
相关文章
Suxiaoxiang
|
1月前
|
缓存 监控 Java
用 Spring Boot 3 构建高性能 RESTful API 的 10 个关键技巧
本文介绍使用 Spring Boot 3 构建高性能 RESTful API 的 10 大关键技巧，涵盖启动优化、数据库连接池、缓存策略、异步处理、分页查询、限流熔断、日志监控等方面。通过合理配置与代码优化，显著提升响应速度、并发能力与系统稳定性，助力打造高效云原生应用。
Suxiaoxiang
383 3
阿里云开发者
|
1月前
|
存储 缓存 Java
重构一个类，JVM竟省下2.9G内存？
通过重构核心类，将 `HashMap<Long, HashSet<String>>` 优化为 `Long2ObjectOpenHashMap<int[]>`，结合数据分布特征与紧凑存储，JVM 堆内存从 3.13GB 降至 211MB，降幅达 94%，验证了高效数据结构在海量场景下的巨大价值。
阿里云开发者
249 24
重构一个类，JVM竟省下2.9G内存？
Suxiaoxiang
|
1月前
|
Java Nacos Sentinel
Spring Cloud Alibaba 深度实战：Nacos + Sentinel + Gateway 整合指南
本指南深入整合Spring Cloud Alibaba核心组件：Nacos实现服务注册与配置管理，Sentinel提供流量控制与熔断降级，Gateway构建统一API网关。涵盖环境搭建、动态配置、服务调用与监控，助你打造高可用微服务架构。（238字）
Suxiaoxiang
617 10
阿里云云原生
|
1月前
|
SQL 数据采集 人工智能
评估工程正成为下一轮 Agent 演进的重点
面向 RL 和在数据层（SQL 或 SPL 环境）中直接调用大模型的自动化评估实践。
阿里云云原生
958 219
Suxiaoxiang
|
1月前
|
开发框架 Java 测试技术
领域驱动设计（DDD）在中小型项目中的落地实践
本文探讨领域驱动设计（DDD）在中小型项目中的落地实践，涵盖核心概念如领域模型、聚合、限界上下文与事件驱动架构，并结合电商订单系统案例，展示分层架构、仓储模式与领域服务的实际应用，助力团队构建高内聚、易维护的业务系统。
Suxiaoxiang
374 10
Suxiaoxiang
|
Nacos 微服务 监控
Nacos：微服务架构中的“服务管家”与“配置中心”
Nacos是阿里巴巴开源的微服务“服务管家”与“配置中心”，集服务注册发现、动态配置管理、健康检查、DNS发现等功能于一体，支持多语言、多协议接入，助力构建高可用、易运维的云原生应用体系。
Suxiaoxiang
590 155
modelscope
|
1月前
|
自然语言处理 语音技术 Apache
阶跃星辰发布首个开源 LLM 级音频编辑大模型 Step-Audio-EditX
阶跃星辰发布全球首个开源LLM级音频编辑大模型Step-Audio-EditX，支持零样本TTS、多语言方言及情感、风格、副语言特征精准控制，采用统一LLM框架，实现文本驱动音频创作。
modelscope
526 88
super_he
|
26天前
|
消息中间件 安全 Java
java消费消息且保证消息不丢失
本文介绍Java中如何安全消费消息并防止消息丢失或篡改，涵盖Kafka与RabbitMQ的消息持久化、手动确认机制及偏移量控制，强调事务处理与元数据保留，确保消息完整性与可靠性。
super_he
92 0
弹性计算小冉
|
1月前
|
存储 缓存 编解码
阿里云最便宜云服务器出炉：38元、99元、199元特惠及新品云服务器活动价格参考
2025年截止目前阿里云最便宜的云服务器已经出炉，轻量应用服务器2核2G峰值200M带宽新用户专属优惠价68元1年，每日10点和15点限量抢购价38元1年；经济型e实例2核2G3M带宽99元1年；通用算力型u1实例2核4G5M带宽199元1年。除此之外，新品u2i实例2核2G配置615.72元1年起、4核8G配置1170.26元1年起；九代云服务器c9i实例8核16G配置6037.01元1年起、g9i实例8核32G配置7680.98元1年起。本文为大家分享2025年阿里云最便宜的各个云服务器。
弹性计算小冉
845 6
游客izzodqdjmth2i
|
27天前
|
XML Java 开发者
springboot自动装配的基本原理
Spring Boot自动装配基于“约定大于配置”理念，通过@SpringBootApplication、@EnableAutoConfiguration与spring.factories机制，结合条件注解实现智能Bean加载。它根据依赖自动配置组件，大幅简化开发。其核心是AutoConfigurationImportSelector筛选符合条件的配置类，实现按需装配。开发者可专注业务，享受“开箱即用”的便捷体验。（238字）
游客izzodqdjmth2i
439 8

热门文章

最新文章

  • 1
    阿里技术高P访谈之张俭恭：情义是阿里与外企的最大不同
  • 2
    SVG实例之中国地图
  • 3
    视频直播常见问题与解决办法汇总【系列一】
  • 4
    Java常见面试题：泛型中“T”与“？”的区别
  • 5
    PostgreSQL 最佳实践 - 逻辑增量复制(MySQL <-> PgSQL <-> PgSQL)
  • 6
    独家经验快速跟进：《零售数据中台通关指南》一起走进零售数据中台
  • 7
    程序员如何让自己 Be Cloud Native - 配置篇
  • 8
    ESC
  • 9
    Go调用C/C++的小demo
  • 10
    Linux网卡参数配置详解
  • 1
    你的数据库不是性能差，是你的SQL在“烧钱”：用这条指令让AI化身资深DBA
    49
  • 2
    架构级拆解：AI数字人与数字员工的核心差异，玄晶引擎云原生实践启示
    58
  • 3
    怎么解决无法拉取Docker镜像？不如我们自己建一个加速站（
    62
  • 4
    基于n8n创建自愈式用例库及质量知识图谱
    43
  • 5
    GPT-5.2来了，老金详细给你说说它为什么是王
    58
  • 6
    2025数字员工技术选型白皮书：阿里云/亚马逊等5款产品云原生能力实测
    48
  • 7
    不是监控不行，是你观测得不够：聊聊新一代可观测性（Observability）的真相
    43
  • 8
    机器学习不是“银弹”，但能救你于告警地狱：AIOps 减噪的 3 个实战方法（Motadata 实战版）
    38
  • 9
    Airflow 做 ETL，真不是“排个 DAG 就完事儿”：那些年我踩过的坑与悟出的道
    34
  • 10
    《UGC工具的能力梯度解锁指南》
    39

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    「直播预告」Streaming Lakehouse Meetup EP.2｜Paimon × StarRocks 共话实时湖仓