抽象工厂设计模式

模式动机

在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。

为了更清晰地理解工厂方法模式，需要先引入两个概念：

产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。

产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。

当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建 。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。

 抽象工厂模式示意图

 模式定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

UML图示例

具体思路简述：

1、新建抽象工厂，工厂中定义要实现的方法

2、新建不同的实现工厂，并将工厂用Spring管理，注册到指定的Map中

3、新建各工厂的抽象产品类

4、新建各个工厂抽象产类的不同实现类，并注册到不同的抽象产品Map中

5、编写测试用例，测试抽象工厂的实现

为了减少在获取不同工厂，和不同的形状和颜色实现类出现过的的If，我们分别新建抽象工厂注册类、形状注册工厂、颜色注册工厂

首先见一个枚举类

public enum AbstractFoctoryEnum {
    SHAPE("SHAPE","图形创建工厂"),
    COLOR("COLOR","颜色创建工厂"),
    SHAPE_RECTANGLE("RECTANGLE","矩形"),
    SHAPE_CIRCLE("CIRCLE","圆形"),
    SHAPE_SQUARE("SQUARE","正方形"),
    COLOR_RED("RED","红色"),
    COLOR_GREEN("GREEN","绿色"),
    COLOR_BLUE("BLUE","蓝色"),
    ;

    private String code;
    private String desc;

    AbstractFoctoryEnum(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }
}

新建一个工厂注册类，用于管理所有工厂实现类

public class AbstractRegisterFactory {
    private static Map<String, AbstractFactory> strategyMap = new ConcurrentHashMap<>();

    public static void register(String name, AbstractFactory abstractFactory) {
        strategyMap.put(name, abstractFactory);
    }


    public static AbstractFactory getInvokeStrategy(String name) {
        return strategyMap.get(name);
    }
}

新建一个形状注册类，用于管理所有形状实现类

public class ShapeRegisetrFactoty {

    private static Map<String, Shape> strategyMap = new ConcurrentHashMap<>();

    public static void register(String name, Shape shape) {
        strategyMap.put(name, shape);
    }

    public static Shape getInvokeStrategy(String name) {
        return strategyMap.get(name);
    }

}

新建一个颜色注册类，用于管理颜色实现类

public class ColorRegisetrFactoty {

    private static Map<String, Color> strategyMap = new ConcurrentHashMap<>();

    public static void register(String name, Color color) {
        strategyMap.put(name, color);
    }

    public static Color getInvokeStrategy(String name) {
        return strategyMap.get(name);
    }

}

抽象一个形状接口

public interface Shape extends InitializingBean {
    void draw();
}

创建接口实现类

Rectangle（矩形）

@Component
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }

    /**
     * 注册到Spring进行管理
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        ShapeRegisetrFactoty.register(AbstractFoctoryEnum.SHAPE_RECTANGLE.getCode(),this);
    }
}

Circle （圆形）

@Component
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }

    /**
     * 注册到Spring进行管理
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        ShapeRegisetrFactoty.register(AbstractFoctoryEnum.SHAPE_CIRCLE.getCode(),this);
    }
    
}

Square（正方形 ）

@Component
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
    
    /**
     * 注册到Spring进行管理
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        ShapeRegisetrFactoty.register(AbstractFoctoryEnum.SHAPE_SQUARE.getCode(),this);
    }
}

新建颜色实现工厂

public interface Color  extends InitializingBean {
    /**
     * 颜色填充
     */
    void fill();

}

新建颜色填充实现类

Blue （蓝色）

@Component
public class Blue  implements  Color{
    @Override
    public void fill() {
        System.out.println("Inside Blue::fill() method.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        ColorRegisetrFactoty.register(AbstractFoctoryEnum.COLOR_BLUE.getCode(), this);
    }

}

Green（绿色）

@Component
public class Green implements  Color{
    @Override
    public void fill() {
        System.out.println("Inside Green::fill() method.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        ColorRegisetrFactoty.register(AbstractFoctoryEnum.COLOR_GREEN.getCode(), this);
    }

}

Red（红色）

@Component
public class Red implements  Color{
    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        ColorRegisetrFactoty.register(AbstractFoctoryEnum.COLOR_RED.getCode(), this);
    }
    
}

新建抽象工厂

public  abstract  class AbstractFactory implements InitializingBean {
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape) ;
}

新建形状工厂

@Component
public class ShapeFactory extends AbstractFactory{

    @Override
    public Color getColor(String color) {
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        return ShapeRegisetrFactoty.getInvokeStrategy(shape);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        AbstractRegisterFactory.register(AbstractFoctoryEnum.SHAPE.getCode(),this);
    }
}

 新建颜色工厂

@Component
public class ColorFactory extends AbstractFactory  {

    @Override
    public Color getColor(String color) {
        return ColorRegisetrFactoty.getInvokeStrategy(color);
    }

    @Override
    public Shape getShape(String shape) {
        return null;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        AbstractRegisterFactory.register(AbstractFoctoryEnum.COLOR.getCode(),this);
    }
}

编写测试用例

@RunWith(SpringRunner.class)
@SpringBootTest(classes = TestApplication.class)
public class AbstractFactoryPatternDemo {

    @Test
    public void  testAbstractFactoryPattern(){
        AbstractFactory shapeFactory = AbstractRegisterFactory.getInvokeStrategy("SHAPE");
        Shape shapes=  shapeFactory.getShape("CIRCLE");
        shapes.draw();
        AbstractFactory colorFactory = AbstractRegisterFactory.getInvokeStrategy("COLOR");
        Color colors=  colorFactory.getColor("RED");
        colors.fill();
    }
}

实现结果

抽象工厂模式优缺点

抽象工厂模式的优点

抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。

当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

模式优缺点

抽象工厂模式的缺点

在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。

开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）

模式适用环境

在以下情况下可以使用抽象工厂模式：

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。

系统中有多于一个的产品族，而每次只使用其中某一产品族。

属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。

系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

模式扩展

“开闭原则”的倾斜性

“开闭原则”要求系统对扩展开放，对修改封闭，通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统，其功能增强包括两方面：
(1) 增加产品族：对于增加新的产品族，工厂方法模式很好的支持了“开闭原则”，对于新增加的产品族，只需要对应增加一个新的具体工厂即可，对已有代码无须做任何修改。

(2) 增加新的产品等级结构：对于增加新的产品等级结构，需要修改所有的工厂角色，包括抽象工厂类，在所有的工厂类中都需要增加生产新产品的方法，不能很好地支持“开闭原则”。

抽象工厂模式的这种性质称为“开闭原则”的倾斜性，抽象工厂模式以一种倾斜的方式支持增加新的产品，它为新产品族的增加提供方便，但不能为新的产品等级结构的增加提供这样的方便。

工厂模式的退化

当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式；当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式。