设计模式实战：在线购物系统的设计与实现_购物车用什么模式实现

简介

本篇文章将介绍如何设计一个在线购物系统，系统包括购物车、订单处理、支付等功能。我们将通过这一项目，应用组合模式、命令模式、策略模式和观察者模式来解决具体的设计问题。

问题描述

设计一个在线购物系统，用户可以浏览商品、将商品添加到购物车、提交订单并完成支付。系统需要支持多种支付方式，并且能够在订单状态变化时通知用户。

设计分析

业务流程说明

整个在线购物系统的业务流程如下：

1. 用户浏览商品并将商品添加到购物车。
2. 用户查看购物车并确认商品。
3. 用户提交订单，系统生成订单。
4. 用户选择支付方式并进行支付。
5. 系统处理支付请求，完成支付。
6. 支付完成后，系统更新订单状态，并通知用户。

流程图

模块依赖关系图

模式选择

购物车设计

• 模式选择：组合模式
• 原因：组合模式适用于将对象组合成树形结构以表示部分-整体层次。购物车中的商品可以看作树结构中的叶子节点，而购物车本身可以看作树的根节点。使用组合模式能够方便地处理购物车中商品的添加和总价计算。

订单处理设计

• 模式选择：命令模式
• 原因：命令模式用于将请求封装成对象，使得可以用不同的请求、队列或者日志来参数化其他对象。订单处理需要支持提交和取消操作，使用命令模式可以将这些操作封装成独立的对象，从而使系统更灵活和易于扩展。

支付方式设计

• 模式选择：策略模式
• 原因：策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。系统需要支持多种支付方式，使用策略模式可以使支付方式的实现更加灵活，方便添加新的支付方式而不影响现有代码。

通知用户设计

• 模式选择：观察者模式
• 原因：观察者模式定义了对象之间的一对多依赖，当一个对象改变状态时，其所有依赖者都会收到通知并自动更新。订单状态变化时需要通知用户，使用观察者模式可以实现这一需求，确保用户及时获取订单状态的更新。

详细设计与实现

数据模型

组合模式（购物车设计）

import java.util.ArrayList;
import java.util.List;

// 产品接口
interface ProductComponent {
    double getPrice();
}

// 商品类
class Product implements ProductComponent {
    private String name;
    private double price;

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

    @Override
    public double getPrice() {
        return this.price;
    }

    public String getName() {
        return name;
    }
}

// 购物车类
class ShoppingCart implements ProductComponent {
    private List<ProductComponent> items = new ArrayList<>();

    public void addItem(ProductComponent item) {
        items.add(item);
    }

    public void removeItem(ProductComponent item) {
        items.remove(item);
    }

    @Override
    public double getPrice() {
        return items.stream().mapToDouble(ProductComponent::getPrice).sum();
    }

    public List<ProductComponent> getItems() {
        return items;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

命令模式（订单处理）

// 订单类
class Order {
    private String status;

    public void submit() {
        this.status = "Submitted";
        notifyObservers();
    }

    public void cancel() {
        this.status = "Canceled";
        notifyObservers();
    }

    public String getStatus() {
        return status;
    }

    private List<Observer> observers = new ArrayList<>();

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

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update("Order status changed to " + status);
        }
    }
}

// 命令接口
interface OrderCommand {
    void execute();
}

// 提交订单命令
class SubmitOrderCommand implements OrderCommand {
    private Order order;

    public SubmitOrderCommand(Order order) {
        this.order = order;
    }

    @Override
    public void execute() {
        order.submit();
    }
}

// 取消订单命令
class CancelOrderCommand implements OrderCommand {
    private Order order;

    public CancelOrderCommand(Order order) {
        this.order = order;
    }

    @Override
    public void execute() {
        order.cancel();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

策略模式（支付方式）

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

// 信用卡支付策略
class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 信用卡支付逻辑
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

// 支付宝支付策略
class AlipayPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 支付宝支付逻辑
        System.out.println("Paid " + amount + " using Alipay.");
    }
}

// 支付上下文
class PaymentContext {
    private PaymentStrategy strategy;

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

    public void pay(double amount) {
        strategy.pay(amount);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

观察者模式（通知用户）

// 观察者接口
interface Observer {
    void update(String message);
}

// 用户类
class User implements Observer {
    private String name;

    public User(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println("Notify " + name + ": " + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

使用示例

public class Main {
    public static void main(String[] args) {
        // 创建用户
        User user = new User("Alice");

        // 创建商品
        Product product1 = new Product("Laptop", 1000);
        Product product2 = new Product("Phone", 500);

        // 创建购物车并添加商品
        ShoppingCart cart = new ShoppingCart();
        cart.addItem(product1);
        cart.addItem(product2);
        System.out.println("Total cart price: " + cart.getPrice());

        // 创建订单并添加观察者
        Order order = new Order();
        order.addObserver(user);

        // 提交订单
        OrderCommand submitOrder = new SubmitOrderCommand(order);
        submitOrder.execute();

        // 选择支付方式并支付
        PaymentContext paymentContext = new PaymentContext();
        paymentContext.setPaymentStrategy(new CreditCardPayment());
        paymentContext.pay(cart.getPrice());

        // 取消订单
        OrderCommand cancelOrder = new CancelOrderCommand(order);
        cancelOrder.execute();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

设计模式类图

组合模式（购物车设计）

命令模式（订单处理）

策略模式（支付方式）

观察者模式（通知用户）

整体类图

总结与反思

通过本项目，我们综合应用了组合模式、命令模式、策略模式和观察者模式，解决了在线购物系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。

专栏推广

如果你喜欢这篇文章，请关注、收藏、点赞，并查看我的专栏“深入学习设计模式”获取更多内容。你的支持是我持续创作的动力！

推荐两个专栏：

• 从零开始学习算法
• 深入学习设计模式

通过这样详细的设计和实现过程，读者可以在实践中深入理解并应用设计模式。这种结构不仅能够提升文章的实用性和可读性，还能有效推广专栏内容。