自学内容网 自学内容网
自学内容网 > 正文

设计模式实战：在线购物系统的设计与实现

🕗 发布于 2024-07-21 08:58 设计模式  

简介

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

问题描述

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

设计分析

业务流程说明

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

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

流程图
浏览商品
添加商品到购物车
查看购物车
确认商品
提交订单
选择支付方式
支付
支付成功
更新订单状态
通知用户

模块依赖关系图
ShoppingCart
Order
PaymentContext
PaymentStrategy
Observer

模式选择

购物车设计
  • 模式选择：组合模式
  • 原因：组合模式适用于将对象组合成树形结构以表示部分-整体层次。购物车中的商品可以看作树结构中的叶子节点，而购物车本身可以看作树的根节点。使用组合模式能够方便地处理购物车中商品的添加和总价计算。
订单处理设计
  • 模式选择：命令模式
  • 原因：命令模式用于将请求封装成对象，使得可以用不同的请求、队列或者日志来参数化其他对象。订单处理需要支持提交和取消操作，使用命令模式可以将这些操作封装成独立的对象，从而使系统更灵活和易于扩展。
支付方式设计
  • 模式选择：策略模式
  • 原因：策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。系统需要支持多种支付方式，使用策略模式可以使支付方式的实现更加灵活，方便添加新的支付方式而不影响现有代码。
通知用户设计
  • 模式选择：观察者模式
  • 原因：观察者模式定义了对象之间的一对多依赖，当一个对象改变状态时，其所有依赖者都会收到通知并自动更新。订单状态变化时需要通知用户，使用观察者模式可以实现这一需求，确保用户及时获取订单状态的更新。

详细设计与实现

数据模型

组合模式（购物车设计）
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;
    }
}
命令模式（订单处理）
// 订单类
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();
    }
}
策略模式（支付方式）
// 支付策略接口
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);
    }
}
观察者模式（通知用户）
// 观察者接口
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);
    }
}

使用示例

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();
    }
}

设计模式类图

组合模式（购物车设计）
contains
«interface»
ProductComponent
+double getPrice()
Product
+String name
+double price
+double getPrice()
+String getName()
ShoppingCart
+List<ProductComponent> items
+addItem(ProductComponent item)
+removeItem(ProductComponent item)
+double getPrice()
命令模式（订单处理）
uses
«interface»
OrderCommand
+void execute()
SubmitOrderCommand
-Order order
+SubmitOrderCommand(Order order)
+void execute()
CancelOrderCommand
-Order order
+CancelOrderCommand(Order order)
+void execute()
Order
+String status
+void submit()
+void cancel()
+void addObserver(Observer observer)
+void notifyObservers()
策略模式（支付方式）
«interface»
PaymentStrategy
+void pay(double amount)
CreditCardPayment
+void pay(double amount)
AlipayPayment
+void pay(double amount)
PaymentContext
-PaymentStrategy strategy
+void setPaymentStrategy(PaymentStrategy strategy)
+void pay(double amount)
观察者模式（通知用户）
«interface»
Observer
+void update(String message)
User
-String name
+User(String name)
+void update(String message)
Order
-List<Observer> observers
+void addObserver(Observer observer)
+void notifyObservers()
+void submit()
+void cancel()

整体类图

owns
contains
generates
notifies
uses
uses
User
+String name
+User(String name)
+void update(String message)
ShoppingCart
+List<ProductComponent> items
+addItem(ProductComponent item)
+removeItem(ProductComponent item)
+double getPrice()
Product
+String name
+double price
+double getPrice()
Order
+String status
+void submit()
+void cancel()
+void addObserver(Observer observer)
+void notifyObservers()
«interface»
OrderCommand
+void execute()
SubmitOrderCommand
-Order order
+SubmitOrderCommand(Order order)
+void execute()
CancelOrderCommand
-Order order
+CancelOrderCommand(Order order)
+void execute()
«interface»
PaymentStrategy
+void pay(double amount)
PaymentContext
-PaymentStrategy strategy
+void setPaymentStrategy(PaymentStrategy strategy)
+void pay(double amount)
CreditCardPayment
+void pay(double amount)
AlipayPayment
+void pay(double amount)
«interface»
Observer
+void update(String message)

总结与反思

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

专栏推广

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

推荐两个专栏：

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


原文地址：https://blog.csdn.net/qq_40254606/article/details/140574469

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024