设计模式-工厂模式

1、简单工厂

1.1 定义

        简单工厂其实并不属于23种GOF设计模式之一，该模式是工厂方法模式的弱化（或者说是工厂方法模式的一种特例），因为简单，所以称为简单工厂模式（Simple Factory Pattern），也叫做静态工厂模式。虽然不是"标准"的设计模式（更像是一种编程习惯），但在实际项目中，采用该方法的案例还是比较多的。

1.2 描述

        提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的类

1.3 关键点

• 具体的工厂类

• 创建产品的工厂方法
  （1）静态方法（静态工厂名字的由来）
  （2）通常会有一个"类型"参数（还有一种是可以提供多个静态工厂方法并通过不同方法名区别要创建的产品）
  （3）根据参数，利用if或者switch创建产品并返回

1.4 实现

抽象产品类（接口或抽象类）

public interface Product {
    void doSomething();
    void doAnything();
}

具体产品类

public class ProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductA doSomething");

    }

    @Override
    public void doAnything() {
        System.out.println("ProductA doAnything");
    }
}

public class ProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductB doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ProductB doAnything");
    }
}

工厂类

public class Creator {
    public static Product createProduct(String type) {
        Product product = null;
        switch (type) {
            case "A":
                product = new ProductA();
                break;
            case "B":
                product = new ProductB();
                break;
        }
        return product;
    }
}

测试代码

public class Test {

    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("A");
        productA.doSomething();
        productA.doAnything();

        Product productB = ProductFactory.createProduct("B");
        productB.doSomething();
        productB.doAnything();
    }
}

1.5 优点

• 简单
• 解耦

（1）客户端不需要依赖具体的产品类，只依赖工厂类，传入不同的参数就可以得到不同的对象；
（2）工厂方法可以根据用户条件返回同一类型的不同子类；
（3）工厂方法中可以增加额外创建对象的细节，并且对客户端屏蔽这些细节。

1.6 缺点

        工厂类的扩展比较困难，每增加一个产品，就要在工厂中添加相应的分支，对扩展开放的同时对修改也开放了，不符合开闭原则。如果有很多产品，那么工厂方法会显得特别"臃肿"，降低可读性且不易维护。

1.7 使用场景

• new的替代品，需要用new创建对象的地方都可以考虑简单工厂；
• 产品种类较少，并且基本可以预见不需要太多扩展的情况（产品需求基本已经确定，例如计算器，已知的运算类型大概就那么多种）

2、工厂方法

2.1 定义

        定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

2.2 实现

抽象产品类

public interface Product {
    void doSomething();
    void doAnything();
}

具体产品类

public class ProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductA doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ProductA doAnything");
    }
}

public class ProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductB doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ProductB doAnything");
    }
}

抽象工厂类

public interface ProductFactory {
    Product createProduct();
}

具体工厂类

public class ProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class ProductBFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

测试代码

public static void main(String[] args) {
    ProductFactory productAFactory = new ProductAFactory();
    Product productA = productAFactory.createProduct();
    productA.doSomething();
    productA.doAnything();

    ProductFactory productBFactory = new ProductBFactory();
    Product productB = productBFactory.createProduct();
    productB.doSomething();
    productB.doAnything();
}

2.3 优点

• 良好的封装性，代码结构清晰
  一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。
• 工厂方法模式的扩展性非常优秀
  在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。
• 工厂方法模式是典型的解耦框架
• 高层模块值需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换产品父类。

2.3 缺点

        每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

2.4 扩展

        利用反射机制来解决"每增加一个产品类，就需要增加一个对应的工厂类"的问题

抽象工厂类

public interface ProductFactory {
    <T extends Product> T createProduct(Class<T> clazz);
}

具体工厂类

public class ProductFactoryImpl implements ProductFactory {
    @Override
    public <T extends Product> T createProduct(Class<T> clazz) {
        Product product= null;
        try {
            product = (Product) Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

测试代码

public class Test {
    public static void main(String[] args) {
        ProductFactory productFactoty = new ProductFactoryImpl();

        Product productA = productFactoty.createProduct(ProductA.class);
        productA.doSomething();
        productA.doAnything();

        Product productB = productFactoty.createProduct(ProductB.class);
        productB.doSomething();
        productB.doAnything();
    }
}

2.5 工厂方法 VS 简单工厂

工厂方法模式是对简单工厂的进一步抽象和解耦。和简单工厂比：

• 工厂方法模式多了一个抽象工厂类
• 每个产品都对应一个具体的工厂类
• 工厂方法模式把简单工厂的内部逻辑判断转移到了客户端代码来进行。各个实例对象的创建代码，没有耦合在同一个工厂类里。
• 工厂方法模式更易于扩展，克服了简单工厂会违背开闭原则的缺点，又保持了封装对象创建过程的优点。

3、抽象工厂

3.1 定义

        为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。

3.2 实现

抽象产品类

产品A家族

public interface ProductA {
    void doSomething();
    void doAnything();
}

产品B家族

public interface ProductB {
    void doSomething();
    void doAnything();
}

具体产品类

产品A家族，产品等级1

public class ProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ProductA1 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ProductA1 doAnything");
    }
}

产品A家族，产品等级2

public class ProductA2 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ProductA2 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ProductA2 doAnything");
    }
}

产品B家族，产品等级1

public class ProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ProductB1 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ProductB1 doAnything");
    }
}

产品B家族，产品等级2

public class ProductB2 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ProductB2 doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ProductB2 doAnything");
    }
}

抽象工厂类

public interface ProductFactory {
    /**
     * 创建A产品家族
     * @return
     */
    ProductA createProductA();

    /**
     * 创建B产品家族
     * @return
     */
    ProductB createProductB();

    // ...
    // 有N个产品族，在抽象工厂类中就应该有N个创建方法
}

有N个产品族，在抽象工厂类中就应该有N个创建方法

具体工厂类

public class ProductLevel1Factory implements ProductFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ProductLevel2Factory implements ProductFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

有M个产品等级，就应该有M个具体工厂实现

测试代码

public class Test {
    public static void main(String[] args) {
        ProductFactory productLevel1Factory = new ProductLevel1Factory();
 
        ProductA productA1 = productLevel1Factory.createProductA();
        productA1.doSomething();
        productA1.doAnything();
 
        ProductB productB1 = productLevel1Factory.createProductB();
        productB1.doSomething();
        productB1.doAnything();
 
        ProductFactory productLevel2Factory = new ProductLevel2Factory();
 
        ProductA productA2 = productLevel2Factory.createProductA();
        productA2.doSomething();
        productA2.doAnything();
 
        ProductB productB2 = productLevel2Factory.createProductB();
        productB2.doSomething();
        productB2.doAnything();
    }
}

3.3 优点

• 封装性，高层模块不需要关心每个产品的实现类，不关心对象是如何创建出来的，只要知道工厂类是谁，就能创建出一个需要的对象
• 一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象，并且很容易交换产品系列
• 可以定义产品族内的约束，并且这样的约束对高层模块来说是透明的

3.4 缺点

        抽象工厂模式的最大缺点就是产品族扩展非常困难，以上面的通用代码为例，如果要增加一个产品C，也就是说产品家族由原来的2个增加到3个，抽象工厂类Creator要增加一个方法createProductC()，然后每个实现类都要修改，违反了开闭原则。

        注意是产品族扩展困难，而不是产品等级，如果新增一个产品等级，只需增加一个具体工厂类的实现即可完成扩展

3.5 抽象工厂 VS 工厂方法

        抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

        工厂方法模式生产一个产品，抽象工厂模式生产多个产品（一系列产品）；在编程中，通常表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

4、总结

        简单工厂、工厂方法、抽象工厂这三种模式是逐步抽象的，后者适用于更为一般的场景，而前者是后者的特例。但它们的目标是殊途同归的，目的都是灵活地创建所需的对象并且对客户端隐藏对象创建细节，三者的扩展性和开发量有所不同，可以根据实际情况选择合适的模式来代替以new的方式创建对象的过程：

• 简单工厂适用于产品种类较少，且不需要太多扩展的场景
• 工厂方法模式作为简单工厂的进一步抽象和补充，更加适用于有很多扩展需求的场景
• 如果一个产品族都有相同的约束（在有多个业务品种、业务分类时，即：具有产品族&产品等级结构的概念），则可以使用抽象工厂模式