创建型模式-抽象工厂模式

一、工厂方法模式存在的问题

1. 当产品增加时，对应的工厂同倍增加，导致系统越来越庞大。
2. 某些来自不同接口的产品通常固定组合使用，当组合的的类相当多时，容易导致混乱，不利于维护开发。

二、抽象工厂模式相关概念

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

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

产品族与产品等级.png

如上图：正方形、圆形，椭圆形各自为一个产品等级结构，实现一个共同的产品接口；相同颜色的一组不同形状的图形为一个产品族，被同一个工厂创建。

注意：产品等级结构不是指继承某个实际产品的产品，不是链式继承关系，而是兄弟关系，都以不同的方式实现同一个接口。

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

三、抽象工厂模式的相关角色

1. AbstractFactory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。

2. ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。

3. AbstractProduct（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。

4. ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

在抽象工厂中声明了多个工厂方法，用于创建不同类型的产品，抽象工厂可以是接口，也可以是抽象类或者具体类。

四、抽象工厂模式典型模型

• 欲设计一套软件界面皮肤，支持不同的风格(春天，夏天)，且支持扩展，但是每个风格下的按钮、文本框、复选框的风格特定，为绑定关系。

软件界面皮肤.png

五、抽象工厂模式案例

Sunny软件公司欲推出一款新的手机游戏软件，该软件能够支持Symbian、Android、Windows Mobile等多个智能手机操作系统平台，针对不同的手机操作系统，该游戏软件提供了不同的游戏操作控制(OperationController)类游戏界面控制(InterfaceController)类，并提供相应的工厂类来封装这些类的初始化过程。软件要求具有较好的扩展性以支持新的操作系统平台，为了满足上述需求，试采用抽象工厂模式对其进行设计。

/**
 * 界面控制
 * @author Liucheng
 * @date 2019/7/1 11:31
 */
public interface InterfaceController {

    public void enter();

    public void out();
}

class AndroidInterfaceController implements InterfaceController {

    @Override
    public void enter() {
        System.out.println("安卓手机进入游戏");
    }

    @Override
    public void out() {
        System.out.println("安卓手机退出游戏");
    }
}

class SymbianInterfaceController implements InterfaceController {
    @Override
    public void enter() {
        System.out.println("塞班手机进入游戏");
    }

    @Override
    public void out() {
        System.out.println("塞班手机退出游戏");
    }
}

class WindowsMobileInterfaceController implements InterfaceController {
    @Override
    public void enter() {
        System.out.println("微软手机进入游戏");
    }

    @Override
    public void out() {
        System.out.println("微软手机退出游戏");
    }
}

/**
 * 游戏操作
 * @author Liucheng
 * @date 2019/7/1 11:30
 */
public interface OperationController {

    public void up();

    public void down();

    public void left();

    public void right();

    public void attack();

}

class AndroidOperationController implements OperationController {
    @Override
    public void up() {
        System.out.println("安卓手机 -- 上");
    }

    @Override
    public void down() {
        System.out.println("安卓手机 -- 下");
    }

    @Override
    public void left() {
        System.out.println("安卓手机 -- 左");
    }

    @Override
    public void right() {
        System.out.println("安卓手机 -- 右");
    }

    @Override
    public void attack() {
        System.out.println("安卓手机 -- 攻击");
    }
}

class SymbianOperationController implements OperationController {
    @Override
    public void up() {
        System.out.println("塞班手机 -- 上");
    }

    @Override
    public void down() {
        System.out.println("塞班手机 -- 下");
    }

    @Override
    public void left() {
        System.out.println("塞班手机 -- 左");
    }

    @Override
    public void right() {
        System.out.println("塞班手机 -- 右");
    }

    @Override
    public void attack() {
        System.out.println("塞班手机 -- 攻击");
    }
}

class WindowsMobileOperationController implements OperationController {
    @Override
    public void up() {
        System.out.println("微软手机 -- 上");
    }

    @Override
    public void down() {
        System.out.println("微软手机 -- 下");
    }

    @Override
    public void left() {
        System.out.println("微软手机 -- 左");
    }

    @Override
    public void right() {
        System.out.println("微软手机 -- 右");
    }

    @Override
    public void attack() {
        System.out.println("微软手机 -- 攻击");
    }
}

/**
 * 工厂类
 * @author Liucheng
 * @date 2019/7/1 11:31
 */
public interface MobileFactory {

    public InterfaceController getInterfaceController();

    public OperationController getOperationController();
}

class AndroidMobileFactory implements MobileFactory {
    @Override
    public InterfaceController getInterfaceController() {
        return new AndroidInterfaceController();
    }

    @Override
    public OperationController getOperationController() {
        return new AndroidOperationController();
    }
}

class SymbianMobileFactory implements MobileFactory {
    @Override
    public InterfaceController getInterfaceController() {
        return new SymbianInterfaceController();
    }

    @Override
    public OperationController getOperationController() {
        return new SymbianOperationController();
    }
}

class WindowsMobileFactory implements MobileFactory {
    @Override
    public InterfaceController getInterfaceController() {
        return new WindowsMobileInterfaceController();
    }

    @Override
    public OperationController getOperationController() {
        return new WindowsMobileOperationController();
    }
}

import org.w3c.dom.Document;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.InputStream;


/**
 * 客户端以及工具类
 * @author Liucheng
 * @since 2019-07-01
 */
public class UserClient {
    public static void main(String[] args) {
        MobileFactory factory = (MobileFactory)XMLUtil.getBean();

        InterfaceController interfaceController = factory.getInterfaceController();

        OperationController operationController = factory.getOperationController();

        interfaceController.enter();
        interfaceController.out();

        operationController.attack();
    }
}

class XMLUtil {

    public static Object getBean(){

        // 创建DOM对象
        DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();

        DocumentBuilder builder = null;
        Document root = null;
        try {
            builder = dFactory.newDocumentBuilder();
            InputStream inputStream = XMLUtil.class.getClassLoader().getResourceAsStream("abstractfactorypatternconfig.xml");
            root = builder.parse(inputStream);

            String className = root
                    .getElementsByTagName("className")
                    .item(0)
                    .getFirstChild()
                    .getNodeValue();

            return Class.forName(className).newInstance();
        } catch (Exception e) {
            throw new RuntimeException("解析配置文件错误");
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<config>
    <className>abstractfactorypattern.factory.AndroidMobileFactory</className>
</config>

六、抽象工厂模式的优缺点

1). “开闭原则”的倾斜性

1. 增加新的产品族很方便，只需再实现抽象产品和抽象产品工厂即可，满足开闭原则。
2. 增加产品等级结构，比如在产品类中添加一个属性等，会导致要修改所有工厂和产品，不满足开闭原则。要求设计者在一开始目光就要放长远，为今后拓展做准备！

2). 主要优点

1. 工厂隔离了具体类的生成，方便上层实现与切换。
2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
3. 增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

3). 缺点

• 添加等级结构特别麻烦。

六、抽象工厂模式的适用场景

1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是很重要的，用户无须关心对象的创建过程，将对象的创建和使用解耦。
2. 系统中有多于一个的产品族，而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。
3. 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象，但是它们都具有一些共同的约束，如同一操作系统下的按钮和文本框，按钮与文本框之间没有直接关系，但它们都是属于某一操作系统的，此时具有一个共同的约束条件：操作系统的类型。
4. 产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。????