Java开发中的常用设计模式实战应用小结

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
 * 单例模式：线程安全的数据库连接池
 * 使用双重检查锁定（DCL）避免多线程问题
 */
public class DatabaseConnectionPool {
    // volatile确保可见性，防止指令重排
    private static volatile DatabaseConnectionPool instance;
    private Connection connection;
    private DatabaseConnectionPool() throws SQLException {
        // 初始化数据库连接（实际生产中会使用连接池框架如HikariCP）
        this.connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "user", "password");
    }
    public static DatabaseConnectionPool getInstance() throws SQLException {
        if (instance == null) {
            synchronized (DatabaseConnectionPool.class) {
                if (instance == null) {
                    instance = new DatabaseConnectionPool();
                }
            }
        }
        return instance;
    }
    public Connection getConnection() {
        return connection;
    }
    // 业务使用示例
    public static void main(String[] args) {
        try {
            DatabaseConnectionPool pool = DatabaseConnectionPool.getInstance();
            Connection conn = pool.getConnection();
            System.out.println("Database connection established: " + conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 工厂方法模式：支付方式工厂
 * 业务场景：电商系统支持微信、支付宝、信用卡支付
 */
// 抽象产品：支付接口
interface Payment {
    void pay(int amount);
}
// 具体产品：微信支付
class WeChatPay implements Payment {
    @Override
    public void pay(int amount) {
        System.out.println("WeChat Pay: " + amount + "元");
    }
}
// 具体产品：支付宝
class Alipay implements Payment {
    @Override
    public void pay(int amount) {
        System.out.println("Alipay: " + amount + "元");
    }
}
// 工厂：根据类型创建支付对象
class PaymentFactory {
    public Payment createPayment(String type) {
        switch (type.toLowerCase()) {
            case "wechat":
                return new WeChatPay();
            case "alipay":
                return new Alipay();
            default:
                throw new IllegalArgumentException("Unsupported payment type: " + type);
        }
    }
}
// 业务调用（无需修改代码即可新增支付方式）
public class PaymentService {
    private PaymentFactory factory = new PaymentFactory();
    public void processPayment(String paymentType, int amount) {
        Payment payment = factory.createPayment(paymentType);
        payment.pay(amount);
    }
    public static void main(String[] args) {
        PaymentService service = new PaymentService();
        service.processPayment("wechat", 100); // 输出：WeChat Pay: 100元
        service.processPayment("alipay", 200);  // 输出：Alipay: 200元
    }
}

import java.util.ArrayList;
import java.util.List;
/**
 * 观察者模式：订单状态通知
 * 业务场景：用户下单后，短信、邮件、APP推送同时通知
 */
// 主题（被观察者）
interface OrderSubject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}
// 观察者接口
interface Observer {
    void update(String orderStatus);
}
// 订单实体（被观察者）
class Order implements OrderSubject {
    private List<Observer> observers = new ArrayList<>();
    private String status;
    public void setStatus(String status) {
        this.status = status;
        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(status);
        }
    }
}
// 具体观察者：短信通知
class SmsObserver implements Observer {
    @Override
    public void update(String status) {
        System.out.println("SMS: 订单状态更新为 " + status);
    }
}
// 具体观察者：邮件通知
class EmailObserver implements Observer {
    @Override
    public void update(String status) {
        System.out.println("Email: 订单状态更新为 " + status);
    }
}
// 业务使用
public class OrderNotificationSystem {
    public static void main(String[] args) {
        Order order = new Order();
        // 注册观察者
        order.registerObserver(new SmsObserver());
        order.registerObserver(new EmailObserver());
        // 更新订单状态（自动触发通知）
        order.setStatus("Shipped"); // 输出：SMS: 订单状态更新为 Shipped
                                 //       Email: 订单状态更新为 Shipped
    }
}

/**
 * 策略模式：促销策略
 * 业务场景：电商大促，支持满减、折扣、无优惠三种策略
 */
// 策略接口
interface PromotionStrategy {
    double calculateDiscount(double originalPrice);
}
// 具体策略：满减（满100减20）
class FullReduction implements PromotionStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice > 100 ? originalPrice - 20 : originalPrice;
    }
}
// 具体策略：折扣（85折）
class Discount implements PromotionStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice * 0.85;
    }
}
// 上下文：促销引擎
class PromotionEngine {
    private PromotionStrategy strategy;
    public void setStrategy(PromotionStrategy strategy) {
        this.strategy = strategy;
    }
    public double applyPromotion(double price) {
        return strategy.calculateDiscount(price);
    }
}
// 业务使用
public class PromotionDemo {
    public static void main(String[] args) {
        PromotionEngine engine = new PromotionEngine();
        // 设置满减策略
        engine.setStrategy(new FullReduction());
        System.out.println("FullReduction: " + engine.applyPromotion(120)); // 输出: 100.0
        // 切换为折扣策略
        engine.setStrategy(new Discount());
        System.out.println("Discount: " + engine.applyPromotion(120)); // 输出: 102.0
    }
}

/**
 * 适配器模式：支付SDK适配
 * 业务场景：接入新支付公司（如PayPal）的SDK，但原有系统使用老接口
 */
// 目标接口（系统期望的）
interface OldPaymentGateway {
    void processPayment(double amount);
}
// 适配器：将PayPalSDK适配到OldPaymentGateway
class PayPalAdapter implements OldPaymentGateway {
    private PayPalSDK payPalSDK;
    public PayPalAdapter(PayPalSDK payPalSDK) {
        this.payPalSDK = payPalSDK;
    }
    @Override
    public void processPayment(double amount) {
        // PayPalSDK的接口与OldPaymentGateway不一致
        payPalSDK.makePayment(amount);
    }
}
// 第三方SDK（无法修改）
class PayPalSDK {
    public void makePayment(double amount) {
        System.out.println("PayPal SDK: Processing payment of " + amount);
    }
}
// 业务使用（无需修改原有代码）
public class PaymentAdapterDemo {
    public static void main(String[] args) {
        OldPaymentGateway gateway = new PayPalAdapter(new PayPalSDK());
        gateway.processPayment(50.0); // 输出：PayPal SDK: Processing payment of 50.0
    }
}