抽象工厂模式

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

一、抽象工厂模式

抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。比如：同一个品牌（有不同的产品）就代表一个产品族。同一个产品（有不同的品牌制造）就代表一个产品等级。

1、抽象工厂模式的定义

抽象工厂（Abstract Factory Pattern）模式 的定义：

是一种为访问类提供一个创建一一系列相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

使用抽象工厂模式一般要满足以下条件。

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

2、抽象工厂模式的结构

（1）模式的结构

抽象工厂模式与工厂方法模式包含的的主要角色一样，只是抽象工厂角色中方法个数不同，抽象产品角色的个数也不同。传送门：工厂方法模式

抽象工厂模式的主要角色如下：

• 抽象工厂（Abstract Factory）
  是工厂方法模式的核心，与应用程序无关。提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。。
• 具体工厂（ConcreteFactory）
  实现了抽象工厂接口的具体工厂类，主要重写抽象工厂中的多个抽象方法，完成具体产品的创建。
• 抽象产品（Product）
  是所有对象的超类，定义了产品的规范，描述了产品的共同主要特性和功能，抽象工厂模式有多个抽象产品。
• 具体产品（ConcreteProduct）
  实现了抽象产品接口的具体产品列类，由专门的具体工厂来创建，具体产品和具体工厂之间往往一一对应。

（2）结构图如下：(图来自网络)

抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。

3、优缺点

主要优点：

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

主要缺点：

• 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

4、使用场景

抽象工厂模式适应于需要生产产品族的情景。抽象产品类内部提供了多个其他抽象的产品，抽象工厂类定义了产品的创建接口，通过具体工厂类就可以生产相应的产品族对象，供用户端使用。

5、在框架源码中使用也很广泛

• 在 Spring源码中的 DefaultListableBeanFactory实现了所有工厂的公共逻辑

二、模式的通用实现

代码如下：

public class AbstractFactoryPattern {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        factory1.newProduct1().show();
        factory1.newProduct2().show();

        System.out.println("================");
        AbstractFactory factory2 = new ConcreteFactory2();
        factory2.newProduct1().show();
        factory2.newProduct2().show();
    }
}

//抽象产品1
interface Product1 {
    public void show();
}
//具体产品11
class ConcreteProduct11 implements Product1 {
    @Override
    public void show() {
        System.out.println("具体产品11显示...");
    }
}
//具体产品12
class ConcreteProduct12 implements Product1 {
    @Override
    public void show() {
        System.out.println("具体产品12显示...");
    }
}

//抽象产品2
interface Product2 {
    public void show();
}
//具体产品21
class ConcreteProduct21 implements Product2 {
    @Override
    public void show() {
        System.out.println("具体产品21显示...");
    }
}
//具体产品22
class ConcreteProduct22 implements Product2 {
    @Override
    public void show() {
        System.out.println("具体产品22显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    Product1 newProduct1();
    Product2 newProduct2();
}
//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product1 newProduct1() {
        System.out.println("具体工厂1生成-->具体产品11...");
        return new ConcreteProduct11();
    }

    @Override
    public Product2 newProduct2() {
        System.out.println("具体工厂1生成-->具体产品21...");
        return new ConcreteProduct22();
    }

}
//具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public Product1 newProduct1() {
        System.out.println("具体工厂2生成-->具体产品12...");
        return new ConcreteProduct12();
    }

    @Override
    public Product2 newProduct2() {
        System.out.println("具体工厂2生成-->具体产品22...");
        return new ConcreteProduct22();
    }
}

三、模式的应用实例

在现实生活中许多工厂是综合型的工厂，能生产多个品牌（等级） 的各类产品。一个电器厂可以生产各类电器产品，比如：电视机，洗衣机和空调等。不同品牌的同一种产品，称为产品族，比如：格力空调，海尔空调。

用抽象工厂模式设计电器类。这里以格力和小米两个不同等级的品牌来生产洗衣机和空调产品为例。

1、抽象产品

（1）抽象产品1：洗衣机
（2）抽象产品2：空调

public interface IWasherProduct {
    void show();
}

public interface IRefrigeratorProduct {
    void show();
}

2、具体产品

（1）具体产品1：洗衣机

public class GreeWasher implements IWasherProduct {
    @Override
    public void show() {
        System.out.println("格力洗衣机");
    }
}

public class MiuiWasher implements IWasherProduct {
    @Override
    public void show() {
        System.out.println("小米洗衣机");
    }
}

（2）具体产品2：空调

public class GreeRefrigerator implements IRefrigeratorProduct {
    @Override
    public void show() {
        System.out.println("格力冰箱");
    }
}

public class MiuiRefrigerator implements IRefrigeratorProduct {
    @Override
    public void show() {
        System.out.println("小米冰箱");
    }
}

3、抽象工厂

创建洗衣机和空调。

public interface IElectricalFactory {
    IWasherProduct newWasherProduct();
    IRefrigeratorProduct newRefrigeratorProduct();
}

4、具体工厂

（1）具体工厂1：格力工厂

public class GreeFactory implements IElectricalFactory {
    @Override
    public IWasherProduct newWasherProduct() {
        System.out.println("制造商：格力工厂");
        return new GreeWasher();
    }

    @Override
    public IRefrigeratorProduct newRefrigeratorProduct() {
        System.out.println("制造商：格力工厂");
        return new GreeRefrigerator();
    }
}

（2）具体工厂2：小米工厂

public class MiuiFactory implements IElectricalFactory {
    @Override
    public IWasherProduct newWasherProduct() {
        System.out.println("制造商：小米工厂");
        return new MiuiWasher();
    }

    @Override
    public IRefrigeratorProduct newRefrigeratorProduct() {
        System.out.println("制造商：小米工厂");
        return new MiuiRefrigerator();
    }
}

5、测试

    public static void main(String[] args) {
        IElectricalFactory greeFactory = new GreeFactory();
        greeFactory.newWasherProduct().show();
        greeFactory.newRefrigeratorProduct().show();

        System.out.println("=================");
        IElectricalFactory miuiFactory = new MiuiFactory();
        miuiFactory.newWasherProduct().show();
        miuiFactory.newRefrigeratorProduct().show();
    }

可以通过缓存、配置文件、反射和泛型等技术了优化工厂模式的使用。可参考简单工厂模式中的优化使用。传送门：简单工厂模式

四、三个工厂模式的区别

三个工厂模式都认识了，这里总结一下它们的区别：

相同点：

• 用来创建对象的，即将产品对象的实际创建工作推迟到具体子工厂类当中。
• 都属于创建型设计模式，这满足创建型模式中所要求的“创建与使用相分离”的特点。

不同点：

（1）简单工厂模式：

• 简单工厂模式不在 GoF 23 种设计模式之列。
• 客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，逻辑中if条件太多，导致其代码臃肿。
• 不满足开闭原则。

（2）工厂方法模式

• 工厂方法模式是对简单工厂模式的进一步抽象，解决了简单工厂生产太多产品导致其内容代码臃肿（if条件太多）的问题。
• 满足开闭原则。
• 客户端不关心创建产品的细节，只关心创建产品的工厂名，产品实例化被推迟到具体的子工厂中。
  工厂方法模式只生产一个等级的产品。

（3）抽象工厂模式

• 抽象工厂模式是工厂方法模式的升级版本，可生产多个等级的产品。
• 当系统中只存在一个等级结构的产品时，抽象工厂模式将退化到工厂方法模式。
• 抽象工厂模式的开闭原则有一定的倾斜性：
  • 当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。
  • 当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。

参考文章：

• 设计模式：http://c.biancheng.net/view/1351.html

—— Stay Hungry. Stay Foolish. 求知若饥，虚心若愚。