工厂模式(简单工厂模式、工厂方法模式和抽象工厂模式)

自己简单总结一下，加强下记忆。

简单工厂模式

就一个工厂类，里面通过if-else判断逻辑来决定生产哪个产品。比如：

class SimpleFactory {
    
  public Product createdProduct(String type){
             if("1".equels(type)){
                //创建产品A
              } else if("2".equels(type)){
                //创建产品B
        }
  } 
}

简单工厂可以满足简单业务场景下的需求，但是如果type类型很多，这里的if-else岂不是要一大堆。并且随着业务的发展，type可以继续增加，每次增加都需要修改工厂的判断逻辑，不满足开闭原则。

工厂方法模式

上面简单工厂的缺点：不能适应type的拓展，不满足开闭原则。

为了消除if-else，我们需要调用者自己决定生产哪些产品。问题来了，如果让调用方直接new 不同的产品，那还需要设计模式干嘛。所以，这里我们让调用者决定生产产品，不是直接new产品，而是直接调用产品工厂。

所以，我们可知工厂方法模式需要创建多个工厂类，来给调用方使用。每个工厂类，只负责自己的产品生产。这样的话，调用方只需要new产品工厂即可。

服务端代码如下：

public interface IMaskFactory {
    IMask createMask();
}

public class HighEndFactory implements IMaskFactory{

    @Override
    public IMask createMask() {
        IMask mask =  new HighEndMask();
        // .....
        // HighEndMask的100行初始化代码
        return mask;
    }
}

public class LowEndFactory implements IMaskFactory{

    @Override
    public IMask createMask() {
        IMask mask =  new LowEndMask();
        // .....
        //  LowEndMask的100行初始化代码
        return mask;
    }
}

客户端代码如下：

public class Test {

    public static void main(String[] args) {
        IMaskFactory factoryA = new LowEndFactory();
        IMaskFactory factoryB = new HighEndFactory();
        IMask maskA = factoryA.createMask();
        IMask maskB = factoryB.createMask();
        maskA.show();
        maskB.show();
    }
}

你可能会觉得new工厂类，和new 产品类，有啥不一样。客户端代码，一行也没少写，想要修改客户端需求，还是得改客户端代码。
我们可以从另外一个角度看：new工厂类，不new 产品类，相当于把产品和客户端解耦了，用工厂类这个中间人来黏和。这样的话，我们想改产品类，只要改对应的工厂类即可。达到解耦的效果，是不是有点spring ioc的味道了。

这种模式也有缺点：每个产品都需要对应一个工厂类，每增加一个产品，都必须相应增加工厂类，导致类数量爆炸式增长。

克服这种缺点，我们就必须再抽象一个层次。比如：提取各个产品的共性，根据共性创建抽象工厂。

举个例子：口罩和防护服两个产品，我们现在要添加一个高端和低端两个质量，用工厂方法的话，就需要 2 * 2 = 4个工厂类(高端口罩、低端口罩、高端防护服和低端防护服)。如果产品不止两个呢，比如20个产品都需要高端和低端，那么工厂方法模板就需要40个工厂类。这种增加速度太快了，无法接受。

所以抽象工厂模式应运而生，对产品提取共性：高端和低端。那么就创建两个抽象工厂类：高端工厂类和低端工厂类。这两个抽象类，其实并不能生产具体产品。只能知道，高端工厂类能生成高端的产品，至于产品是谁并不知道。所以，这种方法简单的解决方法就是通过抽象工厂类的方法来解决。

每个抽象类里面，有不同产品的创建方法。这些方法都只会创建高端产品或低端产品。
如下：

public interface IFactory {
    //创建口罩
    IMask createMask();
    //创建防护服
    IProtectiveSuit createSuit();
}

public class LowEndFactory implements IFactory {
    @Override
    public IMask createMask() {
        IMask mask =  new LowEndMask();
        // .....
        //  LowEndMask的100行初始化代码
        return mask;
    }

    @Override
    public IProtectiveSuit createSuit() {
        IProtectiveSuit suit =  new LowEndProtectiveSuit();
        // .....
        //  LowEndProtectiveSuit的100行初始化代码
        return suit;
    }
}

public class HighEndFactory implements IFactory {
    @Override
    public IMask createMask() {
        IMask mask =  new HighEndMask();
        // .....
        // HighEndMask的100行初始化代码
        return mask;
    }

    @Override
    public IProtectiveSuit createSuit() {
        IProtectiveSuit suit =  new HighEndProtectiveSuit();
        // .....
        //  HighEndProtectiveSuit的100行初始化代码
        return suit;
    }
}

createMask和createSuit是创建产品的接口方法，每个具体工厂类只会生产高端或低端产品。
这样的话，就只需要两个工厂类，而非40个工厂类。

但是接口方法会有40个产品方法，这个是没法省的。

但是它也有缺点：
客户端再使用的时候，只需要高端口罩。但是拿到的是高端工厂，可以生产所有高端产品包括：高端口罩，高端防护服和高端其他产品。这样也很危险，看到了不需要的功能，违背了最小原则。