通过Java设计模式提高业务流程灵活性的策略

引言

在软件开发中，随着业务需求的不断变化，系统的灵活性成为了一个重要的考量因素。Java设计模式作为一种经过验证的解决方案，可以有效地提高系统的可维护性、扩展性和灵活性。本文将探讨几种关键的设计模式，以及它们如何帮助我们构建更加灵活的业务流程，并附上一些示例代码。

1. 单例模式 - 控制资源访问

单例模式确保一个类只有一个实例，并提供一个全局访问点。以下是一个简单的单例实现：

java

深色版本

1public class Singleton {
2    private static Singleton instance;
3
4    private Singleton() {}
5
6    public static synchronized Singleton getInstance() {
7        if (instance == null) {
8            instance = new Singleton();
9        }
10        return instance;
11    }
12}

2. 工厂方法模式 - 灵活创建对象

假设我们有一个支付系统，支持多种支付方式（如信用卡、支付宝、微信支付）：

java

深色版本

1// 接口
2interface PaymentMethod {
3    void pay(double amount);
4}
5
6// 具体实现
7class CreditCardPayment implements PaymentMethod {
8    @Override
9    public void pay(double amount) {
10        System.out.println("Paid " + amount + " using Credit Card");
11    }
12}
13
14class AlipayPayment implements PaymentMethod {
15    @Override
16    public void pay(double amount) {
17        System.out.println("Paid " + amount + " using Alipay");
18    }
19}
20
21// 工厂
22interface PaymentFactory {
23    PaymentMethod createPayment();
24}
25
26class CreditCardFactory implements PaymentFactory {
27    @Override
28    public PaymentMethod createPayment() {
29        return new CreditCardPayment();
30    }
31}
32
33class AlipayFactory implements PaymentFactory {
34    @Override
35    public PaymentMethod createPayment() {
36        return new AlipayPayment();
37    }
38}
39
40// 使用
41public class PaymentProcessor {
42    private final PaymentMethod paymentMethod;
43
44    public PaymentProcessor(PaymentFactory factory) {
45        this.paymentMethod = factory.createPayment();
46    }
47
48    public void processPayment(double amount) {
49        paymentMethod.pay(amount);
50    }
51
52    public static void main(String[] args) {
53        // 创建支付处理器实例
54        PaymentProcessor ccProcessor = new PaymentProcessor(new CreditCardFactory());
55        ccProcessor.processPayment(100);
56
57        PaymentProcessor alipayProcessor = new PaymentProcessor(new AlipayFactory());
58        alipayProcessor.processPayment(200);
59    }
60}

3. 模板方法模式 - 标准化流程

模板方法模式用于定义算法的骨架，而将一些步骤延迟到子类中。比如，一个订单处理的流程：

java

深色版本

1abstract class OrderProcessTemplate {
2    public final void processOrder(Order order) {
3        preCheck(order);
4        doPayment(order);
5        sendConfirmation(order);
6        postProcess(order);
7    }
8
9    protected void preCheck(Order order) {
10        System.out.println("Pre-checking the order...");
11    }
12
13    protected abstract void doPayment(Order order);
14
15    protected void sendConfirmation(Order order) {
16        System.out.println("Sending confirmation email...");
17    }
18
19    protected void postProcess(Order order) {
20        System.out.println("Post-processing the order...");
21    }
22}
23
24class CreditCardOrderProcess extends OrderProcessTemplate {
25    @Override
26    protected void doPayment(Order order) {
27        System.out.println("Processing payment with Credit Card...");
28    }
29}
30
31class PayPalOrderProcess extends OrderProcessTemplate {
32    @Override
33    protected void doPayment(Order order) {
34        System.out.println("Processing payment with PayPal...");
35    }
36}
37
38// 使用
39public class ClientApp {
40    public static void main(String[] args) {
41        Order order = new Order();
42
43        OrderProcessTemplate ccProcess = new CreditCardOrderProcess();
44        ccProcess.processOrder(order);
45
46        OrderProcessTemplate paypalProcess = new PayPalOrderProcess();
47        paypalProcess.processOrder(order);
48    }
49}

4. 观察者模式 - 动态响应事件

假设我们需要通知多个订阅者关于订单状态的变化：

java

深色版本

1import java.util.ArrayList;
2import java.util.List;
3
4interface Observer {
5    void update(String message);
6}
7
8interface Subject {
9    void registerObserver(Observer o);
10    void removeObserver(Observer o);
11    void notifyObservers(String message);
12}
13
14class Order implements Subject {
15    private List<Observer> observers = new ArrayList<>();
16    private String status;
17
18    @Override
19    public void registerObserver(Observer o) {
20        observers.add(o);
21    }
22
23    @Override
24    public void removeObserver(Observer o) {
25        observers.remove(o);
26    }
27
28    @Override
29    public void notifyObservers(String message) {
30        for (Observer observer : observers) {
31            observer.update(message);
32        }
33    }
34
35    public void setStatus(String status) {
36        this.status = status;
37        notifyObservers(status);
38    }
39}
40
41class OrderNotification implements Observer {
42    @Override
43    public void update(String message) {
44        System.out.println("Notification: " + message);
45    }
46}
47
48// 使用
49public class NotificationDemo {
50    public static void main(String[] args) {
51        Order order = new Order();
52        OrderNotification notification = new OrderNotification();
53
54        order.registerObserver(notification);
55        order.setStatus("Shipped");
56    }
57}