创建型设计模式05-抽象工厂模式

1、抽象工厂模式介绍

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，围绕一个超级工厂创建其他工厂，也称作为工厂的工厂（大工厂里的小工厂）。在抽象工厂模式中，接口负责创建一组相关对象的工厂，而不需要显式指定它们的类。这种设计模式能够将客户端与具体的实现分离，从而使得客户端可以在不必知道具体产品的情况下创建多个相关的产品对象。

1.1 抽象工厂的结构图

抽象工厂模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

AbstractFactory：抽象工厂类，定义了一组用于创建产品（ProductA和ProductB）的抽象方法，具体的工厂类将实现这些抽象方法。

ConcreteFactory1和ConcreteFactory2：具体工厂类，实现了AbstractFactory中定义的创建产品的抽象方法。在本例中，ConcreteFactory1用于创建ProductA1和ProductB1的实例，而ConcreteFactory2用于创建ProductA2和ProductB2的实例。

AbstractProductA和AbstractProductB：抽象产品类，定义了产品的通用接口。具体产品类将实现这些接口。

ProductA1、ProductA2、ProductB1和ProductB2：具体产品类，实现了AbstractProductA和AbstractProductB中定义的接口。

当客户端需要创建产品时，它会先创建一个具体的工厂类，然后使用该工厂类创建所需的产品实例。由于抽象工厂提供了一组相关的产品接口，因此这些产品之间具有共同点，可以很方便地进行组合、配对或者交换。而具体工厂则根据客户端的需求，在运行时动态创建产品实例，从而实现了客户端与具体实现之间的解耦。

那下面来看看这个具体的实现吧

1.2 抽象工厂模板实现

抽象产品类：

// 抽象产品类 A
interface AbstractProductA {
  void operationA();
}

// 抽象产品类 B
interface AbstractProductB {
  void operationB();
}

实现不同的抽象产品，产出具体不同的产品：

扫描二维码关注公众号，回复： 17126616 查看本文章

// 具体产品类 A1
class ProductA1 implements AbstractProductA {
  @Override
  public void operationA() {
    System.out.println("具体产品类 A1 实现抽象产品 A");
  }
}

// 具体产品类 A2
class ProductA2 implements AbstractProductA {
  @Override
  public void operationA() {
    System.out.println("具体产品类 A2 实现抽象产品 A");
  }
}

// 具体产品类 B1
class ProductB1 implements AbstractProductB {
  @Override
  public void operationB() {
    System.out.println("具体产品类 B1 实现抽象产品 B");
  }
}

// 具体产品类 B2
class ProductB2 implements AbstractProductB {
  @Override
  public void operationB() {
    System.out.println("具体产品类 B2 实现抽象产品 B");
  }
}

抽象工厂类：创建产品的类

相当于一个大工厂，里面可以产出很多产品，但是每个产品都属于大工厂里面的一个小工厂，也就是大工厂里面有小工厂，在小工厂里面实现具体的产品

// 抽象工厂类
interface AbstractFactory {
  AbstractProductA createProductA();
  AbstractProductB createProductB();
}

具体的小工厂：

// 具体工厂类 1
class ConcreteFactory1 implements AbstractFactory {
  @Override
  public AbstractProductA createProductA() {
    return new ProductA1();
  }

  @Override
  public AbstractProductB createProductB() {
    return new ProductB1();
  }
}

// 具体工厂类 2
class ConcreteFactory2 implements AbstractFactory {
  @Override
  public AbstractProductA createProductA() {
    return new ProductA2();
  }

  @Override
  public AbstractProductB createProductB() {
    return new ProductB2();
  }
}

客户端实现：

// 客户端
public class Client {
  public static void main(String[] args) {
    // 创建具体工厂类 1
    AbstractFactory factory1 = new ConcreteFactory1();

    // 使用工厂类 1 创建产品 A 和 B
    AbstractProductA productA1 = factory1.createProductA();
    AbstractProductB productB1 = factory1.createProductB();

    // 调用产品 A 和 B 的方法
    productA1.operationA();
    productB1.operationB();

    // 创建具体工厂类 2
    AbstractFactory factory2 = new ConcreteFactory2();

    // 使用工厂类 2 创建产品 A 和 B
    AbstractProductA productA2 = factory2.createProductA();
    AbstractProductB productB2 = factory2.createProductB();

    // 调用产品 A 和 B 的方法
    productA2.operationA();
    productB2.operationB();
  }
}

2、具体例子实现

假设你是一位室内设计师，你需要为客户的房间设计家具。不同的客户有不同的风格和预算，因此你需要选择不同的家具制造商来满足客户的需求。在这种情况下，你可以将抽象工厂模式应用于家具制造业。

首先，你需要定义一个家具抽象工厂接口，它有两个方法：createChair() 和 createSofa()，分别用于创建椅子和沙发。然后，你可以创建多个具体的家具工厂类（例如，现代家具工厂、传统家具工厂等），它们分别实现了家具抽象工厂接口并负责创建不同类型的家具。

最后，你可以根据客户的需求选择相应的家具工厂来创建家具。例如，如果客户需要现代家具，你可以使用现代家具工厂来创建现代风格的椅子和沙发；如果客户需要传统家具，你可以使用传统家具工厂来创建传统风格的椅子和沙发。

这样，抽象工厂模式帮助你解耦了客户和具体的家具制造商，使得你可以更容易地切换不同的制造商，同时也为客户提供了更多的选择。

2.1 不使用抽象工厂模式实现

家具类：

/**
 * @author Shier
 * 家具类
 */
public class Furniture {
    private String type;
    private String style;
    private double price;

    public Furniture(String type, String style, double price) {
        this.type = type;
        this.style = style;
        this.price = price;
    }
    
    public void printInfo() {
        System.out.println("Type: " + type);
        System.out.println("Style: " + style);
        System.out.println("Price: " + price);
    }
}

现代风格类：

/**
 * @author Shier
 * 现代风格家具制造商
 */
public class ModernFurnitureMaker {
    public Furniture createChair() {
        return new Furniture("椅子", "现代风格", 150.0);
    }

    public Furniture createSofa() {
        return new Furniture("沙发", "现代风格", 500.0);
    }
}

传统风格类：

/**
 * @author Shier
 * 传统风格家具制造商
 */
public class TraditionalFurnitureMaker {
    public Furniture createChair() {
        return new Furniture("椅子", "传统风格", 100.0);
    }

    public Furniture createSofa() {
        return new Furniture("沙发", "传统风格", 600.0);
    }
}

客户端类：

/**
 * @author Shier
 * 客户端类
 */
public class Client {
    public static void main(String[] args) {
        // 创建现代风格家具
        ModernFurnitureMaker modernMaker = new ModernFurnitureMaker();
        Furniture modernChair = modernMaker.createChair();
        Furniture modernSofa = modernMaker.createSofa();

        // 打印信息
        modernChair.printInfo();
        modernSofa.printInfo();

        // 创建传统风格家具
        TraditionalFurnitureMaker traditionalMaker = new TraditionalFurnitureMaker();
        Furniture traditionalChair = traditionalMaker.createChair();
        Furniture traditionalSofa = traditionalMaker.createSofa();

        // 打印信息
        traditionalChair.printInfo();
        traditionalSofa.printInfo();
    }
}

这个示例中，我们创建了两个类来分别表示现代风格和传统风格的家具制造商。每个家具制造商都有自己的 createChair() 和 createSofa() 方法来创建相应类型的家具对象。

在客户端代码中，我们创建了具体的家具制造商对象（即 ModernFurnitureMaker 和 TraditionalFurnitureMaker），并使用它们来创建家具对象。然后我们打印了每个家具对象的信息。

虽然这个示例没有使用抽象工厂模式，但是它依然可以满足基本的需求。但是当需要制作的家里越多时，就会出现越来越多重复的代码。

不使用抽象工厂模式的不好之处可能包括：

不易于扩展：如果要添加新的产品类型，就需要修改所有创建产品的代码。这种修改可能会涉及多个类，不容易维护。

与具体产品实现绑定：客户端直接依赖具体的产品实现，而不是一个接口或抽象类。这使得客户端代码和具体产品实现紧密绑定在一起，难以进行替换或测试。（耦合度高）

可能导致代码重复：如果多个客户端需要创建相同类型的产品，就需要在每个客户端中复制相同的创建代码。这种代码重复可能会增加维护成本，并且容易出现错误。

2.2 使用抽象工厂模式实现

抽象产品类：

/**
 * 抽象产品类-椅子
 */
public interface Chair {
    void printInfo();
}
/**
 * 抽象产品类-沙发
 */
public interface Sofa {
  void printInfo();
}

具体产品类：

/**
 * @author Shier
 * 具体产品类-现代椅子
 */
public class ModernChair implements Chair {
    public void printInfo() {
        System.out.println("类型: 椅子, 风格: 现代, 价格: 150.0");
    }
}
/**
 * @author Shier
 * 具体产品类-现代沙发
 */
public class ModernSofa implements Sofa {
  public void printInfo() {
    System.out.println("类型: 沙发, 风格: 现代, 价格: 500.0");
  }
}
/**
 * @author Shier
 * 具体产品类-传统椅子
 */
public class TraditionalChair implements Chair {
    public void printInfo() {
        System.out.println("类型: 椅子, 风格: 传统, 价格: 100.0");

    }
}
/**
 * @author Shier
 * 具体产品类-传统沙发
 */
public class TraditionalSofa implements Sofa {
  public void printInfo() {
    System.out.println("类型: 沙发, 风格: 传统, 价格: 600.0");
  }
}

具体产品工厂类：

/**
 * @author Shier
 * 具体工厂类-现代风格家具
 */
public class ModernFurnitureFactory implements FurnitureMaker {
    public Chair createChair() {
        return new ModernChair();
    }

    public Sofa createSofa() {
        return new ModernSofa();
    }
}
/**
 * @author Shier
 * 具体工厂类-传统风格家具
 */
public class TraditionalFurnitureFactory implements FurnitureMaker {
  public Chair createChair() {
    return new TraditionalChair();
  }

  public Sofa createSofa() {
    return new TraditionalSofa();
  }
}

客户端类：

/**
 * @author Shier
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 创建现代风格家具工厂
        FurnitureMaker modernFactory = new ModernFurnitureFactory();
        Chair modernChair = modernFactory.createChair();
        Sofa modernSofa = modernFactory.createSofa();
        // 打印信息
        modernChair.printInfo();
        modernSofa.printInfo();
        // 创建传统风格家具工厂
        FurnitureMaker traditionalFactory = new TraditionalFurnitureFactory();
        Chair traditionalChair = traditionalFactory.createChair();
        Sofa traditionalSofa = traditionalFactory.createSofa();
        // 打印信息
        traditionalChair.printInfo();
        traditionalSofa.printInfo();
    }
}

我们首先创建了 Chair 和 Sofa 两个抽象产品类，代表不同类型的家具。然后，我们创建了每个具体产品类来实现相应的产品。

接下来，我们创建了 FurnitureMaker 抽象工厂类，其中包含了 createChair() 和 createSofa() 两个抽象方法。每个具体工厂类都需要实现这些方法来创建相应类型的家具对象。

在客户端代码中，我们创建了具体的家具制造商对象（即 ModernFurnitureFactory 和 TraditionalFurnitureFactory），并使用它们来创建家具对象。然后我们打印了每个家具对象的信息。

虽然看上去比不使用抽象工厂方法创建了更多的类，但是通过使用抽象工厂模式，我们可以将产品的创建与具体产品实现分离，并且可以方便地添加新的产品类型或修改现有的产品实现，而无需修改客户端代码。

3、抽象工厂模式总结

抽象工厂模式的优点：

可以确保客户端使用的是同一类产品对象，从而避免了不同的产品之间的兼容性问题。

在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。

隐藏了具体产品的实现，从而使客户端代码与具体产品实现分离，增强了可扩展性和灵活性。让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。

系统更易于扩展，因为增加新的具体工厂和产品族很容易，无需修改原有代码。

抽象工厂模式的缺点：

当需要添加新的产品族时，需要修改抽象工厂的接口，这将导致所有具体工厂都需要进行修改，系统变得不稳定。

当需要添加新的产品对象时，除了添加新的具体产品类外，还需要修改抽象工厂接口和所有具体工厂类，这将导致系统的维护成本增加。

在增加抽象层的同时，也增加了系统的复杂度和理解难度。

抽象工厂模式适用于以下情况：

系统需要一组相关或相互依赖的对象，而这些对象通常具有共同的接口。

系统不关心具体产品如何创建、实现等细节，只关心产品的规格和功能。

系统中有多个产品族，每个产品族都有一些共同的约束条件，这些约束条件不是通过类的继承关系来实现的。

常见的应用场景包括：

用户界面工具包：例如需要创建不同风格（如 Windows、Mac OS、Linux 等）下的按钮、文本框等界面组件，可以使用抽象工厂模式来为每个风格创建一个工厂，工厂可以创建所需的所有组件。

数据访问库：例如需要为 Oracle、MySQL、SQL Server 等不同数据库提供数据访问对象，可以使用抽象工厂模式为每个数据库创建一个工厂，工厂可以创建所需的连接、命令等对象。（在《大话设计模式》就是拿这个例子来说明抽象工厂模式的）

医疗设备控制系统：例如需要控制不同型号的医疗器械（如心电图仪、血压计、药品泵等），每个型号的设备都有自己的控制协议，可以使用抽象工厂模式为每个设备型号创建一个工厂，工厂可以创建控制该型号设备的对象。

系统不关心具体产品如何创建、实现等细节，只关心产品的规格和功能。

系统中有多个产品族，每个产品族都有一些共同的约束条件，这些约束条件不是通过类的继承关系来实现的。

常见的应用场景包括：

本文由博客一文多发平台 OpenWrite 发布！