工厂方法模式——应用最广泛的模式

● 工厂方法模式介绍

        工厂方法模式（Factory Pattern），是创建型设计模式之一。工厂方法模式是一种结构简单的模式，其在我们平时开发中应用很广泛，也许你并不知道，但是你已经使用了无数次该模式了，如Android中的Activity里的各个生命周期方法，以onCreate方法为例，它就可以看作是一个工厂方法，我们在其中可以构造我们的View，并通过setContentView返回给famework处理等，相关内容我们下面再讲，先来看看工厂方法的模式定义。

● 工厂方法模式的定义

        定义一个用于创建对象的接口，让子类决定实例化哪个类。

● 工厂方法模式的使用场景

        在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。

● 工厂方法密码的UML类图

        UML类图如下所示：

        根据上图我们可以得出如下一个工厂方法模式的通用模式代码。

        抽象产品类：

public abstract class Product {
    /**
     * 产品类的抽象方法
     * 由具体的产品类去实现
     */
    public abstract void method();
}

        具体产品类A

public class ConcreteProductA extends Product{
    @Override
    public void method() {
        System.out.println("我是具体的产品A");
    }
}

        具体的产品类B

public class ConcreteProductB extends Product{
    @Override
    public void method() {
        System.out.println("我是具体的产品B");
    }
}

        抽象工厂类

public abstract class Factory {
    /**
     * 抽象工厂方法
     * 具体生产什么有子类去实现
     * @return 具体的产品对象
     */
    public abstract Product createProduct();
}

        具体的工厂类

public class ConcreteFactory extends Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

        客户类

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct();
        p.method();
    }
}

        这里的几个角色都很简单，主要分为四大模块，一是抽象工厂，其为工厂方法模式的核心；二是具体工厂，其实现了具体的业务逻辑；三是抽象产品，是工厂方法模式所创建的产品父类；四是具体产品，为实现抽象产品的某个具体产品的对象。

        上诉的代码中我们在Client类中构建了一个工厂对象，并通过其生产了一个产品对象，这里我们得到的产品对象是ConcreteProductA的实例，如果想得到ConereteProductB的实例，更改ConcreteFactory中的逻辑即可。

public class ConcreteFactory extends Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
//        return new ConcreteProductA();
    }
}

        这种方法比较常见，需要哪一个产品就生产哪一个，有时候也可以利用反射的方式更简洁来生产具体产品对象，此时，需要在工厂方法的参数列表中传入一个Class类来决定是哪一个产品类。

public abstract class Factory {
    /**
     * 抽象工厂方法
     * 具体生产什么有子类去实现
     *
     * @param clz 产品对象类类型
     * @return 具体的产品对象
     */
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

        对于具体的工厂类，则通过反射获取累的实例即可。

public class ConcreteFactory extends Factory{
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product p = null;
        try {
            p = (Product) Class.forName(clz.getName()).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return (T)p;
    }
}

        最后再来看看Client中的实现。

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct(ConcreteProductB.class);
        p.method();
    }
}

        需要哪一个类的对象就传入哪一个类的类型即可，这种方法比较简洁、动态，如果你不喜欢这种方法，也可以尝试为每一个产品都定义一个具体的工厂，各司其职。

public class ConcreteFactoryA extends Factory {

    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB extends Factory {

    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.method();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.method();
    }
}

        像这样拥有多个工厂的方式我们称为多工厂方法模式，同样的地，回到我们最初的那个工厂方法模式，当我们的工厂只有一个的时候，我么还是为工厂提供了一个抽象类，那么，我们是否可以将其简化掉呢？如果确定你的工厂类只有一个，那么简化掉抽象类是肯定没有问题的，我们只需要将对应的工厂方法改为静态方法即可。

public class ConcreteFactory extends Factory{
    @Override
    public static Product createProduct() {
        return new ConcreteProductB();
//        return new ConcreteProductA();
    }
}

        像这样方式有称为简单工厂模式或静态工厂模式，它是工厂模式的一个弱化版本。

        其实到这里大家应该可以发现，工厂方法模式是完全符合设计原则的，其降低了对象之间的耦合度，而且，工厂方法模式依赖于抽象的框架，其将实例化的任务交由子类去完成，有非常好的扩展性。

● 工厂方法模式的简单实现

        工厂方法模式对于大家来说是非常好理解的一个模式，即便是第一次听说，只要读者懂点Java知识，理解这个模式绝对不难，隐藏，对于模式的简单实现不再过得赘述，这里以一个生活中的小例子来说明。张三是一家汽车厂的厂长，对他来说，组装汽车没什么好神秘的，无非就是将一些进口的核心部件，比如发动机和一些国内的零部件组装起来，张三的汽车厂主要就是组装模块SUV车型，比如Q3、Q5、Q7对于这类车型来说，内部结构差异不是很大，因此，对张三来说，一条生产线足以应对这3种车型，对于该生产线张三提供了一个抽象类定义。

public abstract class AundiFactory {
    /**
     * 某车型的工厂方法
     *
     * @param clz 具体的SUV类型型号类型
     * @param <T>
     * @return 具体型号的SUV车对象
     */
    public abstract <T extends AudiCar> T createAudCar(Class<T> clz);

}

        那么有没有必要为每种车型都提供一条生产线呢？在这里，张三厂里所生产的3种SUV车型可能在主结构上并没有什么差异，因此，对于张三来说没有必要为每一种车型提供一条不同的生产线，一条生产线即可。

public class AudiCarFactory extends AundiFactory {
    @Override
    public <T extends AudiCar> T createAudCar(Class<T> clz) {
        AudiCar car = null;
        try {
            car = (AudiCar) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) car;
    }
}

        对于这3种车型，除了一些车都有的基本共性外，还提供了自动巡航功能，类似于无人驾驶，这些功能张三都使用一个抽象的基类来声明。

public abstract class AudiCar {
    /**
     * 汽车的抽象产品类
     * <p>
     * 定义汽车的一个行为方法 车可以启动开走
     */
    public abstract void drive();

    /**
     * 汽车的抽象类
     * <p>
     * 定义汽车的一个行为方法 车可以自动巡航
     */
    public abstract void selfNavigation();
}

        接下来就是生产每一种具体的车型了。

public class AudiQ3 extends AudiCar {
    @Override
    public void drive() {
        System.out.println("Q3启动啦！");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q3开始自动巡航啦！");
    }
}

public class AudiQ5 extends AudiCar {
    @Override
    public void drive() {
        System.out.println("Q5启动啦！");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q5开始自动巡航啦！");
    }
}

public class AudiQ7 extends AudiCar {
    @Override
    public void drive() {
        System.out.println("Q7启动啦！");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q7开始自动巡航啦！");
    }
}

        最后我们将各个类组装起来形成一条完整的流水线。

public class Client {
    public static void main(String[] args) {
        //构造一个制造汽车的工厂对象
        AudiFactory audiFactory = new AudiCarFactory();

        //生产Q3并启动
        AudiQ3 audiQ3 = audiFactory.createAudCar(AudiQ3.class);
        audiQ3.drive();
        audiQ3.selfNavigation();

        //生产Q5并启动
        AudiQ5 audiQ5 = audiFactory.createAudCar(AudiQ5.class);
        audiQ5.drive();
        audiQ5.selfNavigation();

        //生产Q7并启动
        AudiQ7 audiQ7 = audiFactory.createAudCar(AudiQ7.class);
        audiQ7.drive();
        audiQ7.selfNavigation();
    }
}

        输入结果如下：

Q3启动啦！
Q3开始自动巡航啦！
Q5启动啦！
Q5开始自动巡航啦！
Q7启动啦！
Q7开始自动巡航啦！

        从上诉大家可以看到，工厂方法模式的结构很简单，逻辑也基本类似，所以，上面例子于我们类图中所述的结构是很类似的。