在电商系统的设计开发过程中，可以使用多种设计模式来解决不同的业务场景。以下是一些常见的业务场景和相应的设计模式应用示例：

• 订单处理：使用状态模式来管理订单的不同状态（例如待支付、已支付、已发货、已完成等），以及状态之间的转换规则。

• 购物车功能：使用享元模式来管理购物车中的商品对象，以减少内存占用和提高性能。

• 支付处理：使用策略模式来支持不同的支付方式（例如支付宝、微信支付、信用卡等），使系统能够灵活地适应不同的支付方式。

• 库存管理：使用观察者模式来实现库存变动的通知机制，以便及时更新库存状态并触发相关业务逻辑。

• 优惠活动：使用策略模式来实现不同的优惠活动算法，使系统能够根据活动规则计算并应用相应的优惠。

下面针对上述5个业务场景，提供对应的设计模式代码应用示例，帮助读者能够更好的理解设计模式在对应场景中的应用。

订单处理 - 状态模式：

设计本质：将处理逻辑封装到状态对象当中，不同的订单状态，执行不同的处理逻辑。

// 订单状态接口
public interface OrderState {
    void processOrder();
}

// 待支付状态
public class PendingPaymentState implements OrderState {
    public void processOrder() {
        // 处理待支付订单的逻辑
    }
}

// 已支付状态
public class PaidState implements OrderState {
    public void processOrder() {
        // 处理已支付订单的逻辑
    }
}

// 订单类
public class Order {
    private OrderState currentState;

    public Order() {
        currentState = new PendingPaymentState();
    }

    public void setState(OrderState state) {
        currentState = state;
    }

    public void processOrder() {
        currentState.processOrder();
    }
}

// 使用示例
Order order = new Order();
order.processOrder(); // 处理待支付订单
order.setState(new PaidState());
order.processOrder(); // 处理已支付订单

购物车功能 - 享元模式：

设计本质：复用购物车商品的基本信息，只改变商品数量即可，减少内存对象数量及其占用的内存资源。

// 商品类
public class Product {
    private String name;
    private double price;
    private int number

    public Product(String name, double price, int number) {
        this.name = name;
        this.price = price;
        this.number = number;
    }

    // 省略其他属性和方法
}

// 购物车类
public class ShoppingCart {
    private Map<String, Product> products = new HashMap<>();

    public void addProduct(String productId, String name, double price, int number) {
        if (!products.containsKey(productId)) {
            Product product = new Product(name, price, number);
            products.put(productId, product);
        } else {
            Product product = products.get(productId);
            product.setNumber(product.getNumber + number);
            products.put(productId, product);
        }
    }

    // 省略其他购物车操作方法
}

// 使用示例
ShoppingCart cart = new ShoppingCart();
cart.addProduct("1", "iPhone", 999.99, 1);
cart.addProduct("2", "MacBook", 1999.99, 2);

cart.addProduct("1", "iPhone", 999.99, 10); //再加购10个iPhone

支付处理 - 策略模式：

设计本质：将支付方式作为一种策略，可以灵活切换支付方式。

// 支付策略接口
public interface PaymentStrategy {
    void pay(double amount);
}

// 支付宝支付策略
public class AlipayStrategy implements PaymentStrategy {
    public void pay(double amount) {
        // 使用支付宝支付逻辑
    }
}

// 微信支付策略
public class WeChatPayStrategy implements PaymentStrategy {
    public void pay(double amount) {
        // 使用微信支付逻辑
    }
}

// 订单类
public class Order {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void processPayment(double amount) {
        paymentStrategy.pay(amount);
    }
}

// 使用示例
Order order = new Order();
order.setPaymentStrategy(new AlipayStrategy());
order.processPayment(100.0); // 使用支付宝支付

order.setPaymentStrategy(new WeChatPayStrategy());
order.processPayment(200.0); // 使用微信支付

库存管理 - 观察者模式：

设计本质：库存管理类获得所有观察者对象的引用，一旦库存变化，则依次使用Java语言的消息传递方式————方法调用传递消息给观察者，观察者则执行对应的库存变更逻辑。

// 库存观察者接口
public interface InventoryObserver {
    void update(int productId, int quantity);
}

// 库存管理类
public class InventoryManager {
    private Map<Integer, Integer> inventory = new HashMap<>();
    private List<InventoryObserver> observers = new ArrayList<>();

    public void addObserver(InventoryObserver observer) {
        observers.add(observer);
    }

    public void removeObserver(InventoryObserver observer) {
        observers.remove(observer);
    }

    public void updateInventory(int productId, int quantity) {
        inventory.put(productId, quantity);
        notifyObservers(productId, quantity);
    }

    private void notifyObservers(int productId, int quantity) {
        for (InventoryObserver observer : observers) {
            observer.update(productId, quantity);
        }
    }
}

// 库存变动日志观察者
public class InventoryLogObserver implements InventoryObserver {
    public void update(int productId, int quantity) {
        // 记录库存变动日志
    }
}

// 使用示例
InventoryManager inventoryManager = new InventoryManager();
InventoryLogObserver logObserver = new InventoryLogObserver();
inventoryManager.addObserver(logObserver);

inventoryManager.updateInventory(1, 10); // 更新库存并触发日志记录

优惠活动 - 策略模式：

设计本质：将优惠活动作为一种策略，可以灵活切换不同的优惠活动。

// 优惠活动策略接口
public interface DiscountStrategy {
    double applyDiscount(double amount);
}

// 满减优惠策略
public class FlatDiscountStrategy implements DiscountStrategy {
    private double threshold;
    private double discountAmount;

    public FlatDiscountStrategy(double threshold, double discountAmount) {
        this.threshold = threshold;
        this.discountAmount = discountAmount;
    }

    public double applyDiscount(double amount) {
        if (amount >= threshold) {
            return amount - discountAmount;
        }
        return amount;
    }
}

// 折扣优惠策略
public class PercentageDiscountStrategy implements DiscountStrategy {
    private double discountPercentage;

    public PercentageDiscountStrategy(double discountPercentage) {
        this.discountPercentage = discountPercentage;
    }

    public double applyDiscount(double amount) {
        return amount * (1 - discountPercentage);
    }
}

// 订单类
public class Order {
    private DiscountStrategy discountStrategy;

    public void setDiscountStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double calculateTotalAmount(double amount) {
        return discountStrategy.applyDiscount(amount);
    }
}

// 使用示例
Order order = new Order();
order.setDiscountStrategy(new FlatDiscountStrategy(100.0, 20.0));
double totalAmount = order.calculateTotalAmount(150.0); // 应用满减优惠策略

order.setDiscountStrategy(new PercentageDiscountStrategy(0.1));
totalAmount = order.calculateTotalAmount(200.0); // 应用折扣优惠策略