设计模式实战：遵循Java实现工厂模式、单例模式的案例分析

原创 ╰半夏微凉° 2024-12-04 07:48 3阅读 0赞

工厂模式和单例模式是软件工程中两种常见的设计模式。下面我将分别用Java实现这两种模式，并进行案例分析。

1. 工厂模式（Product Factory Pattern）

- 原理：通过一个接口创建一系列对象，但不能直接通过接口来创建新对象。

- Java实现：

```java
// 创建产品工厂接口
public interface ProductFactory {
    // 通过接口创建具体的产品对象
    Product createProduct();
}

// 实现产品工厂的具体类
class ConcreteProductA implements Product {
    // 实现产品功能
    public void doSomething() {
        System.out.println("Doing something for A");
    }
}

class ConcreteProductB implements Product {
    // 实现产品功能
    public void doSomething() {
        System.out.println("Doing something for B");
    }
}

// 创建抽象产品类
public abstract class AbstractProduct {
    // 用于获取产品工厂对象
    private ProductFactory factory;

// 构造器，通过接口获取产品工厂
    public AbstractProduct(ProductFactory factory) {
        this.factory = factory;
    }

// 通过工厂创建并返回具体产品的实例
    public Product createProduct() {
        return factory.createProduct();
    }
}

// 创建具体产品工厂类
class ProductFactoryImpl implements ProductFactory {
    @Override
    public Product createProduct() {
        if ("A".equals(System.getProperty("product")))) {
            return new ConcreteProductA();
        } else if ("B".equals(System.getProperty("product"))))) {
            return new ConcreteProductB();
        }
        // 如果产品未被指定，抛出异常
        throw new IllegalArgumentException("Invalid product specified.");
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        // 创建产品工厂对象
        ProductFactory factory = new ProductFactoryImpl();

// 通过工厂创建并使用具体的产品实例
        Product productA = factory.createProduct();
        productA.doSomething();  // 输出：Doing something for A

Product productB = factory.createProduct();
        productB.doSomething();  // 输出：Doing something for B
    }
}
```
2. 单例模式（Singleton Pattern）

- 原理：保证一个类仅有一个实例，并提供一个全局访问点。

- Java实现：

```java
// 定义Singleton类，其中包含一个私有构造函数以阻止外部创建新实例
public class Singleton {
    // 私有的静态变量来存储唯一实例
    private static Singleton instance;

// 为获取唯一实例的公共方法
    public static Singleton getInstance() {
        if (instance == null) {  // 如果实例为空，创建新的实例
            synchronized (Singleton.class) {  // 使用同步锁确保线程安全
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

private Singleton() {}  // 防止构造函数被外部调用
}
```
案例分析：

- 工厂模式：如上述代码所示，通过ProductFactory接口创建了ConcreteProductA和ConcreteProductB两个具体产品的实例。这种方式增强了抽象产品与具体产品之间的耦合度。

- 单例模式：Singleton类的getInstance()方法确保在任何情况下只有一个Singleton实例存在。这种方式非常适合那些需要全局唯一访问点的应用场景，例如配置管理、日志记录等。