电商项目常用的五个设计模式场景及分析实现

电商设计模式总结

1 单点登录模

1 业务介绍

单点登录（Single Sign-On, SSO）模块允许用户在多个相关应用系统之间进行无缝的身份验证。用户只需登录一次，然后可以访问所有连接的应用程序而无需重新登录。在电商应用中，这对于提供一致性用户体验非常重要。

2 实现介绍

**单例模式（Singleton Pattern）**是一种创建型设计模式，它确保类只有一个实例，并提供一个全局访问点。在单点登录模块中，我们选择使用单例模式来管理已登录用户的状态。这是因为我们需要在不同的应用组件中共享用户的登录状态，而且不希望多次实例化登录管理器。

public class LoginManager {
    // 私有静态内部类确保线程安全的延迟初始化
    private static class SingletonHelper {
        private static final LoginManager INSTANCE = new LoginManager();
    }

    private Map<Integer, Boolean> loggedInUsers;

    private LoginManager() {
        loggedInUsers = new HashMap<>();
    }

    public static LoginManager getInstance() {
        return SingletonHelper.INSTANCE;
    }

    public void login(int userId) {
        loggedInUsers.put(userId, true);
    }

    public void logout(int userId) {
        loggedInUsers.remove(userId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

设计模式说明：

• 单例模式被用来确保系统中只有一个LoginManager实例。这是因为登录状态需要全局管理，多个实例会导致数据不一致性。单例模式通过静态内部类方式实现了懒加载，确保了线程安全。

2 商品详情模块

1 业务介绍

商品详情模块负责展示商品的详细信息，包括商品描述、价格、评价等。在电商应用中，这个模块允许用户深入了解商品，从而做出购买决策。

2 实现介绍

**装饰器模式（Decorator Pattern）**是一种结构性设计模式，允许你通过将对象包装在装饰器类中来动态地为对象添加新的行为。在商品详情模块中，我们使用装饰器模式来动态地添加商品的价格信息和评价信息。

// 基本商品接口
public interface Product {
    String getDescription();
}

// 基本商品类
public class BasicProduct implements Product {
    @Override
    public String getDescription() {
        return "Basic product description";
    }
}

// 商品装饰器抽象类
public abstract class ProductDecorator implements Product {
    protected Product product;

    public ProductDecorator(Product product) {
        this.product = product;
    }
}

// 价格信息装饰器
public class PriceDecorator extends ProductDecorator {
    public PriceDecorator(Product product) {
        super(product);
    }

    @Override
    public String getDescription() {
        return product.getDescription() + " with price information";
    }
}

// 评价信息装饰器
public class ReviewDecorator extends ProductDecorator {
    public ReviewDecorator(Product product) {
        super(product);
    }

    @Override
    public String getDescription() {
        return product.getDescription() + " with reviews";
    }
}
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

设计模式说明：

• 装饰器模式允许我们在运行时动态地为对象添加新的行为，而不需要修改其代码。在商品详情模块中，BasicProduct是基本的商品类，而PriceDecorator和ReviewDecorator是装饰器，可以用来添加价格信息和评价信息。

3 订单模块

1 业务介绍

订单模块负责处理用户购物车中的商品、生成订单、支付、发货等流程。在电商应用中，订单模块是用户购买商品和完成交易的关键部分。

2 实现介绍

**工厂模式（Factory Pattern）**是一种创建型设计模式，它提供了一种将对象的创建与其使用分离的方法。在订单模块中，我们使用工厂模式来根据订单类型创建不同类型的订单。

// 订单接口
public interface Order {
    double calculateTotal();
}

// 常规订单类
public class RegularOrder implements Order {
    @Override
    public double calculateTotal() {
        return 100.0;
    }
}

// 促销订单类
public class PromoOrder implements Order {
    @Override
    public double calculateTotal() {
        return 80.0;
    }
}

// 订单工厂类
public class OrderFactory {
    public Order createOrder(String orderType) {
        switch (orderType.toLowerCase()) {
            case "regular":
                return new RegularOrder();
            case "promo":
                return new PromoOrder();
            default:
                throw new IllegalArgumentException("Invalid order type.");
        }
    }
}
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

设计模式说明：

• 工厂模式用于封装对象的创建逻辑。在订单模块中，OrderFactory负责根据订单类型创建不同类型的订单对象。这种方式使得新增订单类型变得容易，而不需要修改已有的代码。

通过上述详细实现和设计模式的选择，我们建立了一个具有良好扩展性和可维护性的电商应用。设计模式有助于提高代码的可读性和可维护性，并将业务逻辑与底层实现分离，使系统更加灵活和可维护。

当在电商项目中使用观察者模式和策略模式时，以下是包含详细实现代码的综合说明：

4 观察者模式（Observer Pattern）

1 业务介绍：

观察者模式用于维护对象之间的一对多依赖关系。在电商项目中，这一模式适用于实时通知用户关于商品价格和库存的变化，确保他们随时获得最新信息。

实现介绍：

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

// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题类
class Product implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private double price;

    public void setPrice(double price) {
        this.price = price;
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(price);
        }
    }
}

// 观察者接口
interface Observer {
    void update(double price);
}

// 具体观察者类
class User implements Observer {
    private String name;

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

    @Override
    public void update(double price) {
        System.out.println(name + " 收到通知：商品价格更新为 $" + price);
    }
}

// 示例用法
public class ObserverPatternExample {
    public static void main(String[] args) {
        Product product = new Product();
        
        User user1 = new User("Alice");
        User user2 = new User("Bob");
        
        product.registerObserver(user1);
        product.registerObserver(user2);
        
        product.setPrice(50.0);
        product.setPrice(55.0);
    }
}
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
64
65
66
67
68
69
70
71
72

说明：

• 观察者模式实现了解耦合，商品不需要直接知道哪些用户关注它，而用户也不需要主动轮询商品的状态。
• 这种模式有助于电商平台实时向用户提供最新信息，提高了用户体验和客户忠诚度。

5 策略模式（Strategy Pattern）

1 业务介绍：

策略模式允许在运行时选择算法或策略，使客户端能够灵活地切换不同的行为。在电商项目中，策略模式可以用于处理不同的支付方式，如信用卡支付、支付宝支付、微信支付等。

实现介绍：

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

// 具体支付策略类
class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;
    private String name;

    public CreditCardPayment(String cardNumber, String name) {
        this.cardNumber = cardNumber;
        this.name = name;
    }

    @Override
    public void pay(double amount) {
        System.out.println("支付 $" + amount + " 到 " + name + " 的信用卡 " + cardNumber);
    }
}

class PayPalPayment implements PaymentStrategy {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void pay(double amount) {
        System.out.println("通过 PayPal 支付 $" + amount + " 到 " + email);
    }
}

// 订单类使用策略模式
class Order {
    private PaymentStrategy paymentStrategy;

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

    public void checkout(double totalAmount) {
        paymentStrategy.pay(totalAmount);
    }
}

// 示例用法
public class StrategyPatternExample {
    public static void main(String[] args) {
        Order order = new Order();
        
        // 选择信用卡支付
        order.setPaymentStrategy(new CreditCardPayment("1234-5678-9876-5432", "Alice"));
        order.checkout(100.0);
        
        // 切换到 PayPal 支付
        order.setPaymentStrategy(new PayPalPayment("alice@example.com"));
        order.checkout(75.0);
    }
}
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

说明：

• 策略模式将支付方式的选择和订单处理逻辑分离，订单对象不需要关心具体的支付细节。
• 客户端可以根据需要选择不同的支付策略，从而实现支付方式的灵活切换，而不需要修改订单处理代码。

这两个设计模式的综合应用在电商项目中提供了良好的可维护性和可扩展性，同时满足了实时通知和支付方式灵活切换的需求。根据项目需求，可以继续探索其他设计模式来解决不同的业务问题。