当前位置：首页 > article >正文

项目里用到了哪些设计模式是怎么使用的?

article 2024/12/25 16:55:20

在软件开发项目中，设计模式是解决特定问题的通用模板或最佳实践。它们提供了一种经过验证的方式来组织代码，使其更易于理解、维护和扩展。下面我将详细介绍一些常见的设计模式及其在项目中的应用方式。

1. 单例模式（Singleton Pattern）

应用场景：确保一个类只有一个实例，并提供全局访问点。

实现方式：通过私有化构造函数防止外部直接创建对象，使用静态方法返回唯一实例。
项目应用：例如配置管理器、日志记录器等需要保证在整个应用程序生命周期内只存在单个实例的服务组件。

public class ConfigManager {
    private static final ConfigManager instance = new ConfigManager();
    
    // 私有化构造函数
    private ConfigManager() {}
    
    public static ConfigManager getInstance() {
        return instance;
    }
}

2. 工厂方法模式（Factory Method Pattern）

应用场景：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

实现方式：定义一个工厂接口或抽象类，其中包含创建产品的方法；具体工厂负责实现该方法以生成相应的产品。
项目应用：用于处理不同类型的对象创建逻辑，如数据库连接池可以根据配置选择不同的驱动程序。

// 抽象工厂
public abstract class DatabaseFactory {
    public abstract Connection createConnection();
}

// 具体工厂
public class MySQLFactory extends DatabaseFactory {
    @Override
    public Connection createConnection() {
        return DriverManager.getConnection("jdbc:mysql://localhost:3306/db", "user", "password");
    }
}

3. 抽象工厂模式（Abstract Factory Pattern）

应用场景：当一组相关联的对象需要一起使用时，可以提供一个接口来创建这些对象。

实现方式：定义一个抽象工厂接口，包含多个创建不同类型产品的抽象方法；具体工厂则实现了这些方法来创建一系列相关的具体产品。
项目应用：适用于构建复杂的系统，比如图形用户界面库可能需要根据不同操作系统创建相应的窗口、按钮等控件。

// 抽象工厂接口
public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 具体工厂 - Windows风格
public class WinFactory implements GUIFactory {
    @Override
    public Button createButton() { /* ... */ }
    @Override
    public Checkbox createCheckbox() { /* ... */ }
}

// 客户端代码
GUIFactory factory = new WinFactory();
Button button = factory.createButton();
Checkbox checkbox = factory.createCheckbox();

4. 原型模式（Prototype Pattern）

应用场景：当需要频繁创建大量相似的对象时，可以通过复制已有对象来节省资源。

实现方式：定义一个原型接口，要求所有可克隆的对象都实现此接口并提供clone()方法。
项目应用：游戏开发中经常用到原型模式快速生成敌人或其他重复性高的实体。

public interface Prototype {
    Prototype clone();
}

public class Enemy implements Prototype {
    private String type;
    
    public Enemy(String type) {
        this.type = type;
    }
    
    @Override
    public Prototype clone() {
        try {
            return (Enemy) super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }
}

5. 建造者模式（Builder Pattern）

应用场景：构建复杂对象时避免过多参数化的构造函数。

实现方式：分离对象的构建过程与表示形式，允许同一构建过程创建不同表示的对象。
项目应用：适合于需要逐步设置多个属性才能完成初始化的对象，如HTML文档生成器。

public class HtmlDocument {
    private String title;
    private List<String> paragraphs;

    public static class Builder {
        private final String title;
        private final List<String> paragraphs = new ArrayList<>();

        public Builder(String title) {
            this.title = title;
        }

        public Builder addParagraph(String text) {
            paragraphs.add(text);
            return this;
        }

        public HtmlDocument build() {
            return new HtmlDocument(this);
        }
    }

    private HtmlDocument(Builder builder) {
        this.title = builder.title;
        this.paragraphs = builder.paragraphs;
    }
}

// 使用建造者模式创建对象
HtmlDocument doc = new HtmlDocument.Builder("My Document")
                                  .addParagraph("First paragraph.")
                                  .addParagraph("Second paragraph.")
                                  .build();

6. 观察者模式（Observer Pattern）

应用场景：建立一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知并自动更新。

实现方式：定义观察者接口，主体对象维护一个观察者列表，每当状态发生变化时就遍历列表调用每个观察者的更新方法。
项目应用：UI框架中广泛使用的事件监听机制就是一个典型的例子。

public interface Observer {
    void update(float temperature, float humidity, float pressure);
}

public class WeatherData {
    private List<Observer> observers = new ArrayList<>();
    private float temperature;
    private float humidity;
    private float pressure;

    public void registerObserver(Observer o) {
        observers.add(o);
    }

    public void measurementsChanged() {
        notifyObservers();
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }
}

7. 策略模式（Strategy Pattern）

应用场景：定义一系列算法，并将每个算法封装起来，使它们可以互换。

实现方式：定义一个策略接口，具体策略类实现该接口的不同行为；上下文对象持有对策略对象的引用，在运行时根据需求动态切换策略。
项目应用：支付网关可以选择不同的支付方式（信用卡、PayPal等），或者排序算法可以根据数据集大小选择最合适的排序方法。

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

// 具体策略 - 信用卡支付
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using credit card.");
    }
}

// 上下文对象
public class ShoppingCart {
    private PaymentStrategy paymentStrategy;

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

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

// 使用策略模式进行支付
ShoppingCart cart = new ShoppingCart();
cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(100.0);