设计模式之抽象工厂模式

首先我们先看一个场景，就是我们平常组装电脑，我们如果自己组装电脑，那么我们要买CPU，主板，内存条等等零件，但是因为他的可能有不同的型号，所以我们必须要买型号匹配的才可以，否则那肯定就有问题， 或者直接组装不上， 或者组装好之后会蓝屏啊死机啊什么的。当然也可以交给专业的人来组装，我们来看具体的实现：

定义CPU的接口：

public interface CPUApi {
    void calculate();
}

定义主板的接口：

public interface MainboardApi {

    void installCPC();
}

EntelCPU接口的实现：

public class IntelCPU implements CPUApi {

//针脚数
    private int pins = 0;

    public IntelCPU(int pins) {
        this.pins = pins;
    }

    @Override
    public void calculate() {
        System.out.println("Intel CPU针脚数 = " + pins);
    }
}

AMD CPU的实现：

public class AMDCPU implements CPUApi{

    private int pins = 0;

    public AMDCPU(int pins) {
        this.pins = pins;
    }

    @Override
    public void calculate() {
        System.out.println("AMD CPU 的针脚数" + pins);
    }
}

微星主板的实现：

public class MSIMainboard implements MainboardApi {

    //CPU插槽的孔数
    private int cpuHoles = 0;

    public MSIMainboard(int cpuHoles) {
        this.cpuHoles = cpuHoles;
    }

    @Override
    public void installCPC() {
        System.out.println("微星主板 CPU插槽孔数： " + cpuHoles);
    }
}

技嘉主板的实现：

public class GAMainboard implements MainboardApi {

    //CPU插槽的孔数
    private int cpuHoles = 0;

    public GAMainboard(int cpuHoles) {
        this.cpuHoles = cpuHoles;
    }

    @Override
    public void installCPC() {
        System.out.println("技嘉主板 CPU插槽孔数： " + cpuHoles);
    }
}

CPU 工厂：

public class CPUFactory {

    public static CPUApi createCPU(int type){
        CPUApi cpuApi = null;
        if(1 == type){
            cpuApi = new IntelCPU(1156);
        }else if(2 == type){
            cpuApi = new AMDCPU(936);
        }

        return cpuApi;
    }
}

主板工厂：

public class MainboardFactory {
    public static MainboardApi createMainboard(int type){
        MainboardApi api = null;
        if(1 == type){
            api = new GAMainboard(1156);
        }else if(2 == type){
            api = new MSIMainboard(936);
        }
        return api;
    }
}

组装工程师：

public class ComputerEngineer {

    private CPUApi cpu = null;
    private MainboardApi mainboard = null;

    public void makeComputer(int cpuType, int mainBoardType){
        prepareHardware(cpuType, mainBoardType);
    }

    private void prepareHardware(int cpuType, int mainBoardType) {

        cpu = CPUFactory.createCPU(cpuType);
        mainboard = MainboardFactory.createMainboard(mainBoardType);
        cpu.calculate();
        mainboard.installCPC();
    }
}

客户端：

  public static void main(String[] args) {
        ComputerEngineer engineer = new ComputerEngineer();
        engineer.makeComputer(1, 1);
    }
    
CPU针脚数 = 1156
技嘉主板 CPU插槽孔数： 1156

看上面多的代码很简单，但是这个是有问题的， 因为他没有考虑CPU和主板之间的依赖关系，如果传入的参数是1 和2 ，难么针脚数就完全对不上了，那就无法组装。针对这个问题，就是本小节的抽象工厂模式来解决

抽象工厂模式的定义： 提供一个创建系列相关或者相互依赖的对象的接口，而无需指定他们的具体实现类。
抽象工厂模式和工厂方法模式很像，如果不知道什么是抽象工厂模式，可以看上一篇博客
设计模式之工厂方法模式
抽象工厂模式针对的是一个产品族，而工厂方法模式针对的是一个产品。在抽象工厂模式里面，会定义一个抽象工厂，这个抽象工厂只是去定义一个个产品的api,并不去实现它，由的子类提供实现返回对象的产品，组成一个产品族，所以抽象工厂起到一个约束作用。
我们来看看组装电脑的抽象工厂的实现，CPU和主板的api和实现不用动：

抽象工厂：

public interface AbstractFactory {

    CPUApi createCPU();

    MainboardApi createMainBoard();
}

组装电脑的第一种实现：

public class Schema1 implements AbstractFactory {
    @Override
    public CPUApi createCPU() {
        return new IntelCPU(1156);
    }

    @Override
    public MainboardApi createMainBoard() {
        return new GAMainboard(1156);
    }
}

组装电脑的第2种实现：

public class Schema2 implements AbstractFactory {
    @Override
    public CPUApi createCPU() {
        return new AMDCPU(929);
    }

    @Override
    public MainboardApi createMainBoard() {
        return new MSIMainboard(929);
    }
}

再来看装机工程师，装机工程师里面不在需要CPU的主板的类型了，而是直接传入一个装机方案：

public class ComputerEngineer2 {

    private CPUApi cpu = null;
    private MainboardApi mainboard = null;

    public void makeComputer(AbstractFactory factory){
        prepareHardware(factory);
    }

    private void prepareHardware(AbstractFactory factory) {

        cpu = factory.createCPU();
        mainboard = factory.createMainBoard();
        cpu.calculate();
        mainboard.installCPC();
    }
}

客户端：

public class Client1 {

    public static void main(String[] args) {
       Schema1 schema1 = new Schema1();
       ComputerEngineer2 engineer2 = new ComputerEngineer2();
       engineer2.makeComputer(schema1);
    }
}

Intel CPU针脚数 = 1156
技嘉主板 CPU插槽孔数： 1156

在这种实现里面，CPU和主板是相关联的对象，抽象工厂就相当于一个装机方案，客户选择的时候，一选择就是一套，CPU和主板是确定好的，这就避免了不匹配的问题。

抽象工厂的优点是切换产品族很容易。 比如上面的scheme1代表一个产品，scheme2代表一个产品，客户远程不同的scheme就代表了不同的产品。
分离接口实现，客户端不知道具体的实现是谁，是哪个CPU还是哪个主板。

缺点也很明显，如果你要进行一个扩展的话，比如说你在加一个内存条，不仅要加内存条的api,内存条的实现，这些都不要紧，但是你必须得改抽象工厂，和每一个具体的产品，这就很尴尬了。

参考书籍： 设计模式
欢迎关注我的公众号： manong_xiaodong。 有大数据资料赠送哟，因为我最近也在学习大数据！欢迎一起学习！