Head，First设计模式之工厂模式

工厂模式是一种常用的设计模式，用于创建对象。它提供了一种创建对象的统一接口，隐藏了具体对象的创建细节，让客户端代码与具体对象的创建过程解耦。在本文中，我们将深入探讨工厂模式的工作原理、不同类型的工厂模式以及它们的使用场景。

一、工厂模式的工作原理

工厂模式的核心思想是将对象的创建过程封装在一个工厂类中，客户端通过调用工厂类的接口来获取所需的对象。工厂类根据客户端的请求，决定实例化哪个具体的对象并返回给客户端。这种方式将对象的创建过程与客户端解耦，客户端只需要知道如何使用该对象，而无需关心对象是如何创建的。

工厂模式一般包含三个角色：抽象工厂、具体工厂和产品。

1. 抽象工厂：抽象工厂是工厂的顶层接口，定义了创建产品的方法。

2. 具体工厂：具体工厂实现了抽象工厂的方法，负责实际的产品创建。

3. 产品：产品是工厂创建的具体对象。

工厂模式的类图如下所示：


客户端通过调用具体工厂的方法来获取产品，而具体工厂根据客户端的请求来决定实例化哪个产品。

二、简单工厂模式

简单工厂模式是工厂模式的最基本形式，也是最常用的一种形式。它通过一个工厂类来集中创建对象，将客户端与具体对象的创建过程解耦。

在简单工厂模式中，工厂类通常包含一个静态方法，根据客户端的请求返回具体的产品对象。客户端只需要调用工厂类的静态方法，即可获取所需的产品实例。

以下是简单工厂模式的类图和示例代码：

```java

// 抽象产品

interface Product {

void use();

}

// 具体产品A

class ProductA implements Product {

public void use() {

System.out.println("Product A");

}

}

// 具体产品B

class ProductB implements Product {

public void use() {

System.out.println("Product B");

}

}

// 简单工厂

class SimpleFactory {

public static Product createProduct(String type) {

if (type.equalsIgnoreCase("A")) {

return new ProductA();

} else if (type.equalsIgnoreCase("B")) {

return new ProductB();

}

return null;

}

}

// 客户端

public class Client {

public static void main(String[] args) {

Product productA = SimpleFactory.createProduct("A");

if (productA != null) {

productA.use();

}

Product productB = SimpleFactory.createProduct("B");

if (productB != null) {

productB.use();

}

}

}

```

在上面的示例中，抽象产品`Product`定义了产品的方法`use()`，具体产品`ProductA`和`ProductB`分别实现了抽象产品，其`use()`方法分别打印不同的内容。

简单工厂`SimpleFactory`是工厂类，它的静态方法`createProduct()`根据客户端的请求来返回具体的产品对象。

客户端`Client`通过调用简单工厂的`createProduct()`方法来获取所需的产品对象，并调用`use()`方法使用该对象。

三、工厂方法模式

工厂方法模式是将工厂抽象出来，每个产品对应一个具体的工厂类，而不是在一个工厂类中集中处理所有的产品。

在工厂方法模式中，抽象工厂由一个接口或抽象类定义，其中包含一个创建产品的抽象方法。具体工厂实现了抽象工厂，并负责实例化具体的产品。

以下是工厂方法模式的类图和示例代码：

```java

// 抽象产品

interface Product {

void use();

}

// 具体产品A

class ProductA implements Product {

public void use() {

System.out.println("Product A");

}

}

// 具体产品B

class ProductB implements Product {

public void use() {

System.out.println("Product B");

}

}

// 抽象工厂

interface Factory {

Product createProduct();

}

// 具体工厂A

class FactoryA implements Factory {

public Product createProduct() {

return new ProductA();

}

}

// 具体工厂B

class FactoryB implements Factory {

public Product createProduct() {

return new ProductB();

}

}

// 客户端

public class Client {

public static void main(String[] args) {

Factory factoryA = new FactoryA();

Product productA = factoryA.createProduct();

if (productA != null) {

productA.use();

}

Factory factoryB = new FactoryB();

Product productB = factoryB.createProduct();

if (productB != null) {

productB.use();

}

}

}

```

在上面的示例中，抽象产品`Product`和具体产品`ProductA`、`ProductB`的定义和使用方式与简单工厂模式相同。

抽象工厂`Factory`定义了创建产品的抽象方法`createProduct()`，具体工厂`FactoryA`和`FactoryB`分别实现了抽象工厂，并实现了自己的`createProduct()`方法，负责创建具体的产品对象。

客户端`Client`通过调用具体工厂的`createProduct()`方法来获取所需的产品对象，并调用`use()`方法使用该对象。

工厂方法模式与简单工厂模式的区别在于，工厂方法模式将产品的创建过程抽象出来，每个产品对应一个具体的工厂类，而简单工厂模式将产品的创建集中在一个工厂类中。

四、抽象工厂模式

抽象工厂模式是工厂方法模式的扩展，它通过提供一个创建一系列产品的抽象接口，将多个相关的产品组合起来创建。

在抽象工厂模式中，抽象工厂定义了一系列创建产品的抽象方法，而具体工厂实现了抽象工厂，并负责实例化具体的产品。

以下是抽象工厂模式的类图和示例代码：

```java

// 抽象产品A

interface ProductA {

void use();

}

// 具体产品A1

class ProductA1 implements ProductA {

public void use() {

System.out.println("Product A1");

}

}

// 具体产品A2

class ProductA2 implements ProductA {

public void use() {

System.out.println("Product A2");

}

}

// 抽象产品B

interface ProductB {

void eat();

}

// 具体产品B1

class ProductB1 implements ProductB {

public void eat() {

System.out.println("Product B1");

}

}

// 具体产品B2

class ProductB2 implements ProductB {

public void eat() {

System.out.println("Product B2");

}

}

// 抽象工厂

interface AbstractFactory {

ProductA createProductA();

ProductB createProductB();

}

// 具体工厂1

class ConcreteFactory1 implements AbstractFactory {

public ProductA createProductA() {

return new ProductA1();

}

public ProductB createProductB() {

return new ProductB1();

}

}

// 具体工厂2

class ConcreteFactory2 implements AbstractFactory {

public ProductA createProductA() {

return new ProductA2();

}

public ProductB createProductB() {

return new ProductB2();

}

}

// 客户端

public class Client {

public static void main(String[] args) {

AbstractFactory factory1 = new ConcreteFactory1();

ProductA productA1 = factory1.createProductA();

if (productA1 != null) {

productA1.use();

}

ProductB productB1 = factory1.createProductB();

if (productB1 != null) {

productB1.eat();

}

AbstractFactory factory2 = new ConcreteFactory2();

ProductA productA2 = factory2.createProductA();

if (productA2 != null) {

productA2.use();

}

ProductB productB2 = factory2.createProductB();

if (productB2 != null) {

productB2.eat();

}

}

}

```

在上面的示例中，抽象产品`ProductA`和抽象产品`ProductB`定义了各自的方法`use()`和`eat()`，具体产品`ProductA1`、`ProductA2`、`ProductB1`和`ProductB2`分别实现了抽象产品，实现了自己的方法。

抽象工厂`AbstractFactory`定义了创建产品A和产品B的抽象方法`createProductA()`和`createProductB()`，具体工厂`ConcreteFactory1`和`ConcreteFactory2`实现了抽象工厂，并实现了自己的创建方法，负责创建具体的产品。

客户端`Client`通过调用具体工厂的创建方法，来创建一系列相关的产品，并使用它们。

抽象工厂模式的优点是可以创建一系列相关的产品，无需关心具体的产品是如何创建的，只需要关心如何使用这些产品。它将客户端与具体产品的创建解耦，客户端只需要与抽象工厂和抽象产品交互。但缺点是增加新的产品簇时需要修改抽象工厂接口和所有的具体工厂类。

五、工厂模式的使用场景

工厂模式适用于以下场景：

1. 当客户端需要创建复杂的对象，但不关心具体的创建过程时，可以使用工厂模式。工厂模式将对象的创建过程封装在一个工厂类中，客户端只需要关心使用对象，而无需关心具体的创建过程。

2. 当一个类不知道它所需要的对象的具体类型时，可以使用工厂模式。工厂模式提供了一个统一的接口来创建对象，客户端只需要调用工厂的接口，而无需关心具体的产品。

3. 当一个类希望通过子类来决定要创建的对象时，可以使用工厂模式。工厂方法模式将创建对象的过程交给了子类来完成，客户端只需要关心使用对象，而不关心具体的创建逻辑。

4. 当一个类希望通过配置来创建对象时，可以使用工厂模式。工厂模式可以通过读取配置文件或其他外部资源的方式来创建对象，非常灵活。

工厂模式在实际开发中得到了广泛的应用，例如在框架中使用工厂模式来创建对象、在数据库操作中使用工厂模式来创建连接等。

总结：

工厂模式是一种创建对象的常用设计模式，通过将对象的创建过程封装在工厂类中，使客户端代码与具体对象的创建过程解耦。工厂模式包括简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有自己的优缺点和适用场景，根据实际问题选择合适的工厂模式可以提高代码的灵活性和可扩展性。