工厂模式

标签：package 模式 public 操作 Operation 工厂 class

工厂模式顾名思义，工厂就是用来统一创建产品的。我们的工厂根据产品是具体产品还是工厂可以分为简单工厂模式和工厂方法模式，根据抽象程度可以分为工厂方法模式和抽象工厂模式。工厂模式的核心本质是：

实例化对象不使用new，用工厂方法替代
将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

工厂模式在我们的场景中用到的还是比较多的：

JDK中Calendar的getInstance方法

JDBC中的Connection对象的获取

Spring中IOC容器创建管理bean对象

反射中Class对象的newInstance方法

简单工厂模式（静态工厂模式）

用来生产同一等级结构中的任意产品，只需要对工厂传递需要创建对象的类型即可。这里我们以计算器为来讲解该模式：

首先是我们的运算统一接口（Operation）

package simplefactory;

//运算统一接口
public interface Operation {
    void operate();
}

加法操作：

package simplefactory;

public class AddOperation implements Operation{
    @Override
    public void operate() {
        System.out.println("进行了加法操作！");
    }
}

减法操作：

package simplefactory;

public class SubOperation implements Operation{
    @Override
    public void operate() {
        System.out.println("进行了减法操作！");
    }
}

我们定义一个简单工厂来代替我们创建对象：

package simplefactory;

public class OpetationFactory {
    public static Operation createOperate(String operate){
        Operation oper = null;
        switch (operate){
            case "加法":
                oper = new AddOperation();
                break;
            case "减法":
                oper = new SubOperation();
                break;
        }
        return oper;
    }
}

我们在客户端进行实践一下：

package simplefactory;

public class Client {
    public static void main(String[] args) {

        //第一个操作执行加法操作
        Operation operation1 = OpetationFactory.createOperate("加法");
        operation1.operate();
        //第二个操作执行减法操作
        Operation operation2 = OpetationFactory.createOperate("减法");
        operation2.operate();
    }
}

//演示结果
//进行了加法操作！
//进行了减法操作！

这样我们就不需要创建对象这个过程，只需要告诉工厂我们需要什么对象就行，省略了很多的麻烦。但是如果我们这个时候要增加一个要求怎么办呢？我们先需要实现操作统一接口，然后再在工厂里面增加我们的新操作的分支，比如我们增加一个乘法的操作的话。

实现接口：

package simplefactory;

public class MulOperation implements Operation{
    @Override
    public void operate() {
        System.out.println("进行了乘法操作！");
    }
}

在工厂里面添加分支：

package simplefactory;

public class OpetationFactory {
    public static Operation createOperate(String operate){
        Operation oper = null;
        switch (operate){
            case "加法":
                oper = new AddOperation();
                break;
            case "减法":
                oper = new SubOperation();
                break;
            case "乘法": //新加的乘法操作分支
                oper = new MulOperation();
                break;
        }
        return oper;
    }
}

很显然，这样的操作如果在工程量特别大的去修改代码是特别麻烦的，而且主要的是，这不符合我们的开闭原则（对修改关闭，对扩展开放）。

所以我们是有办法来关闭修改操作的——反射，下面代码我们对创建工厂进行重构之后（T表示只要实现了Operaton都可以当作接口，是JDK1.5之后的新特性——泛型，减少了对象之间的转换）

package simplefactory;

public class OpetationFactory {

    public static <T extends Operation> T createOperate(Class<T> c){
        Operation oper = null;
        try{
            oper = (T) Class.forName(c.getName()).newInstance();
        }catch (Exception e){
            System.out.println("没有该操作！");
        }
        return (T) oper;
    }
}

这个时候如果需要添加新的操作的时候，我们只需要创建实现类即可，然后在客户端就可以使用了，关闭了对创建工厂的修改。符合了我们的开闭原则。

package simplefactory;

public class Client {
    public static void main(String[] args) {

        //第一个操作执行加法操作
        Operation operation1 = OpetationFactory.createOperate(AddOperation.class);
        operation1.operate();
        //第二个操作执行减法操作
        Operation operation2 = OpetationFactory.createOperate(SubOperation.class);
        operation2.operate();
        //第三个操作为我们的乘法操作
        Operation operation3 = OpetationFactory.createOperate(MulOperation.class);
        operation3.operate();
    }
}

控制台结果：

进行了加法操作！
进行了减法操作！
进行了乘法操作！

Process finished with exit code 0

对简单工厂模式的优化还有其他方式，可以看看这篇博客Java简单工厂模式以及来自lambda的优化

工厂方法模式

工厂方法是对简单工厂模式进一步的修改，是在不修改已有类的前提下，通过增加新的工厂类实现扩展。可以说是对没有优化前的简单工厂模式的一种优化，贴合了开闭原则。

我们通过UML图可以清晰认识：

我们操作的接口和实现类不变，只不过我们把原来在一个工厂生产对象的的工厂变成了每一个实现类都有自己的生产工厂了。这样我们如果需要再添加新的操作的话，我们只需要添加一个实现类和一个工厂就行了，非常符合我们的开闭原则。

定义我们工厂统一接口的抽象类：

package factorymethod;

//工厂统一接口
public interface OperationFactory {
    Operation doingOperate();
}

然后是我们加法的工厂：

package factorymethod;

public class AddOperationFactory implements OperationFactory{
    @Override
    public Operation doingOperate() {
        return new AddOperation();
    }
}

减法的工厂：

package factorymethod;

public class SubOperationFactory implements OperationFactory {
    @Override
    public Operation doingOperate() {
        return new SubOperation();
    }
}

我们的客户端：

package factorymethod;

public class Client {
    public static void main(String[] args) {

        OperationFactory factoryAdd = new AddOperationFactory();
        OperationFactory factorySub = new SubOperationFactory();
        // 第一个操作为加法操作
        Operation operation1 = factoryAdd.doingOperate();
        operation1.operate();   //输出：进行了加法操作
        // 第二个操作为减法操作
        Operation operation2 = factorySub.doingOperate();
        operation2.operate();  //输出：进行了减法操作
    }
}

抽象工厂模式

抽象工厂总的来说，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。就是围绕一个超级工厂来创建其他工厂，该超级工厂又称为其他工厂的工厂。

这里我再以计算器的操作来举例有点不合适，网上最多的就是手机和电脑品牌的举例。因为可以比较清晰理解抽象工厂，我们不是增加一个产品，而是增加一个产品族。如果我们只是单一的一个手机可以使用上面的工厂方法来创建，但是如果多了一个电脑呢？可以复制一下手机工厂方法的代码，修改一下名字就可以使用，但是这很明显的就是重复代码了吧。我们是无论如何也不能忍受的，所以就有了抽象工厂模式。

首先我们先来定义一个手机的统一接口

package abstractfactory;

public interface Phone {
    void make();
}

实现华为和小米的Phone实现类：

package abstractfactory;

public class HuaWeiPhone implements Phone {
    @Override
    public void makePhone() {
        System.out.println("生产的是华为手机！");
    }
}

package abstractfactory;

public class XiaoMiPhone implements Phone{
    @Override
    public void makePhone() {
        System.out.println("生产的是小米手机！");
    }
}

定义一个电脑的统一接口

package abstractfactory;

public interface Computer {
    void makeComputer();
}

实现华为和小米的Computer实现类：

package abstractfactory;

public class HuaWeiComputer implements Computer {
    @Override
    public void makeComputer() {
        System.out.println("生产的是华为电脑！");
    }
}

package abstractfactory;

public class XiaoMiComputer implements Computer{
    @Override
    public void makeComputer() {
        System.out.println("生产的是小米电脑！");
    }
}

然后就是我们的抽象工厂了，因为我们不管是小米工厂还是华为工厂都需要生产手机和电脑，所以我们可以说这就是一个产品族。

package abstractfactory;

public interface AbstractFactory {
    Phone makePhone();
    Computer makeComputer();
}

然后我们实现抽象工厂的接口，有小米工厂和华为工厂

package abstractfactory;

public class XiaoMiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new XiaoMiPhone();
    }

    @Override
    public Computer makeComputer() {
        return new XiaoMiComputer();
    }
}

package abstractfactory;

public class HuaWeiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new HuaWeiPhone();
    }

    @Override
    public Computer makeComputer() {
        return new HuaWeiComputer();
    }
}

在我们的客户端使用：

package abstractfactory;

public class Client {
    public static void main(String[] args) {
        AbstractFactory xiaoMiFactory = new XiaoMiFactory();
        Phone xiaoMiPhone = xiaoMiFactory.makePhone();
        xiaoMiPhone.makePhone();  //输出：生产的是小米手机！
        Computer xiaoMiComputer = xiaoMiFactory.makeComputer();
        xiaoMiComputer.makeComputer(); //输出：生产的是小米电脑！

        AbstractFactory huaWeiFactory = new HuaWeiFactory();
        Phone huaWeiPhone = huaWeiFactory.makePhone();
        huaWeiPhone.makePhone(); // 输出：生产的是华为手机！
        Computer huaWeiComputer = huaWeiFactory.makeComputer();
        huaWeiComputer.makeComputer(); //输出：生产的是华为电脑！
    }
}

关于我们的抽象工厂的适用场景：

客户端不依赖产品类实例如何被创建，实现等细节
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

优点：

具体产品在应用层的代码隔离，无需关心创建的细节
将一个系列的产品统一到一起创建

缺点：

规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难（注意是产品扩展族而不是产品等级。比如我们这个时候要添加一个一加品牌，只要拥有相同的产品簇，我们只要实现产品接口有实现类然后添加一个工厂生产实例就可以实现。可以说是横向扩展，符合开闭原则。但是如果这时候要添加一个充电宝的产品，就需要修改里面的大量代码，极其复杂，所以需要在刚开始就要设计好。）
增加了系统的抽象性和理解难度