引言
在软件开发中，随着业务需求的不断变化，系统的灵活性成为了一个重要的考量因素。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}结论
Java设计模式是提升业务流程灵活性的重要工具。通过合理运用上述提到的设计模式，我们可以在不牺牲性能的情况下，提高系统的可维护性和扩展性。当然，设计模式的应用也需要根据实际情况来定，过度使用可能会导致不必要的复杂度。因此，在实际项目中应该权衡利弊，灵活选择最适合的设计模式来满足业务需求。