“工厂”这种设计模式可能是最广为人知的模式之一了。其看起来最为简单，读起来也是郎朗上口。每次面试，让应聘者讲几种设计模式，往往都是“工厂模式，单例模式，代理模式...”，可真正能讲清楚“工厂”模式的人却少之又少。本篇文章，同样结合网络和自己理解，试着阐述我眼中的“工厂”。
通常所说的“工厂模式”大部分人最直接的理解可能是有个工厂类负责创建各个不同的实例。而实际上，这可能是最简单的工厂了，学名其实就叫“简单工厂”，除此以外，还有看起来更为牛x的“工厂方法”以及“抽象工厂”。下面一一讲开。
- 简单工厂
假设我们需要做一个简单的计算器，我们定义计算抽象类Operation，它有两个参数，numA和numB，有一个抽象方法getResult，返回计算的结果。另外有它的具体实现类，加法OperationAdd和减法OperationSub。工厂类OperationFactory根据入参返回具体的Operation。客户端类Client调用工厂类获取具体的运算方法进行计算，最终得到计算结果。
下面上代码：
/**
* 功能简述: 运算符抽象类，输入两个整数，返回结果
*
* @author
*/
public abstract class Operation {
protected int numA;
protected int numB;
public abstract int getResult();
}
/**
* 功能简述: 加法实现类
*
* @author
*/
public class OperationAdd extends Operation {
@Override
public int getResult() {
return numA + numB;
}
}
/**
* 功能简述: 减法实现类
*
* @author
*/
public class OperationSub extends Operation {
@Override
public int getResult() {
return numA - numB;
}
}
/**
* 功能简述: 简单工厂类
*
* @author
*/
public class OperationFactory {
public static Operation createOperate(String operate) {
Operation oper = null;
switch (operate) {
case "+":
oper = new OperationAdd();
break;
case "-":
oper = new OperationSub();
break;
}
return oper;
}
}
/**
* 功能简述: 客户端调用
*
* @author
*/
public class Client {
public static void main(String[] args) {
//输出3
Operation oper = OperationFactory.createOperate("+");
if (null != oper) {
oper.numA = 1;
oper.numB = 2;
System.out.println(oper.getResult());
}
//-----------------------------------------------------------------------
//输出-1
oper = OperationFactory.createOperate("-");
if (null != oper) {
oper.numA = 1;
oper.numB = 2;
System.out.println(oper.getResult());
}
}
}
上面的代码运行无问题。也正是简单工厂的实现方法。我在第一篇提到简单工厂的问题，关于“开闭原则”（移步设计模式之开篇）。这里把相同的问题同样记下来，省掉你移步的麻烦。
现在我们需要增加乘法的实现类，我们需要怎么做？首先，需要写一个OperationMul继承Operation，实现父类中的getResult方法，返回乘积；其次，需要在工厂类OperationFactory中新增一段case语句，当case"*"号时返回OperationMul实现；最后，在client方法中测试实现。
/**
* 功能简述: 乘法实现类
*
* @author
*/
public class OperationMul extends Operation {
@Override
public int getResult() {
return numA * numB;
}
}
/**
* 功能简述: 简单工厂类，改造，新增了对*的处理
*
* @author
*/
public class OperationFactory {
public static Operation createOperate(String operate) {
Operation oper = null;
switch (operate) {
case "+":
oper = new OperationAdd();
break;
case "-":
oper = new OperationSub();
break;
case "*":
oper = new OperationMul();
break;
}
return oper;
}
}
/**
* 功能简述: 客户端调用
*
* @author
*/
public class Client {
public static void main(String[] args) {
//输出3
Operation oper = OperationFactory.createOperate("+");
if (null != oper) {
oper.numA = 1;
oper.numB = 2;
System.out.println(oper.getResult());
}
//-----------------------------------------------------------------------
//输出-1
oper = OperationFactory.createOperate("-");
if (null != oper) {
oper.numA = 1;
oper.numB = 2;
System.out.println(oper.getResult());
}
//-----------------------------------------------------------------------
//输出2
oper = OperationFactory.createOperate("*");
if (null != oper) {
oper.numA = 1;
oper.numB = 2;
System.out.println(oper.getResult());
}
}
}
到目前为止，上面的代码运行无问题，大部分人也是这么做的。好，假设又来需求了，我们需要增加除法的实现类？需要怎么做？我们不仅需要增加除法的具体实现类，同样需要修改工厂类。这里有什么问题？我们不断的在新增类，同时又修改类！要求做单元测试的同学们可能会有感触了，测试同学同样会有感触吧？因为修改了一个类，这个类的UT覆盖率下降，同时有没有引入其他问题？测试同学会想，你修改了原来类的代码，我是不是需要回归全部场景？上面的实例代码是非常简单的，如在实际开发中可能业务会复杂的多，修改一个类你得小心再小心。在设计模式中，这叫违背了“开闭原则”！那么我们要怎么办，“工厂方法”可以解决我们的烦恼。
- 工厂方法
工厂方法模式去掉了简单工厂中工厂方法的静态属性，并且抽象了工厂，也就是具体为加法还是减法工厂的压力由工厂子类来分担，没有一个无敌的工厂类负责创建各类具体实现，也就避免了业务调整时需要调整这个无敌类。工厂方法的类图：
下面上具体代码：
/**
* 功能简述: 运算符抽象类，输入两个整数，返回结果
*
* @author
*/
public abstract class Operation {
protected int numA;
protected int numB;
public abstract int getResult();
}
/**
* 功能简述: 加法实现类
*
* @author
*/
public class OperationAdd extends Operation {
@Override
public int getResult() {
return numA + numB;
}
}
这一部分没有变化，抽象计算方法，具体计算方法。变化在下面这个部分：
/**
* 功能简述: 抽象工厂类，此类只定义接口，不定义实现，此为和简单工厂的区别之一
*
* @author
*/
public interface OperationFactory {
Operation createOperate();
}
/**
* 功能简述: 加法工厂类
*
* @author
*/
public class OperationAddFactory implements OperationFactory {
@Override
public Operation createOperate() {
return new OperationAdd();
}
}
/**
* 功能简述: 客户端调用
*
* @author
*/
public class Client {
public static void main(String[] args) {
OperationAddFactory addFactory = new OperationAddFactory();
Operation oper = addFactory.createOperate();
oper.numA = 1;
oper.numB = 2;
//输出3
System.out.println(oper.getResult());
}
}
为了避免过多展示不需要的代码，在这个例子中稍微简化了下，移除了减法的实现。下面我们需要新增减法的实现，我们要怎么做？
我们新增了运算具体实现类OperationSub，新增了减法工厂OperationSubFactory，然后就可以进行测试验证了。在这种实现中，我们只是新增代码，没有修改代码！
/**
* 功能简述: 减法实现类
*
* @author
*/
public class OperationSub extends Operation {
@Override
public int getResult() {
return numA - numB;
}
}
/**
* 功能简述:减法工厂类
*
* @author
*/
public class OperationSubFactory implements OperationFactory {
@Override
public Operation createOperate() {
return new OperationSub();
}
}
/**
* 功能简述: 测试实现
*
* @author
*/
public class Client {
/**
* 功能描述: <br>
*
* @param args
*/
public static void main(String[] args) {
OperationAddFactory addFactory = new OperationAddFactory();
Operation oper = addFactory.createOperate();
oper.numA = 1;
oper.numB = 2;
//输出3
System.out.println(oper.getResult());
OperationSubFactory subFactory = new OperationSubFactory();
oper = subFactory.createOperate();
oper.numA = 1;
oper.numB = 2;
//输出-1
System.out.println(oper.getResult());
}
}
看到这里，可能你已经有一些感觉了。
- 抽象工厂
抽象工厂模式是工厂方法模式的升级版本，它用来创建一组相关或者相互依赖的对象。
抽象工厂比较难以理解，主要是不知道解决哪一类问题，而且看起来和工厂方法非常类似，工厂子类不仅创建一个具体产品实现，更可能会创建多个。想要清楚的理解抽象工厂就需要从它的起源说起。
抽象工厂模式的起源或者最早的应用，是用于创建分属于不同操作系统的视窗构建。比如：命令按键（Button）与文字框（Text)都是视窗构建，在UNIX操作系统的视窗环境和Windows操作系统的视窗环境中，这两个构建有不同的本地实现，它们的细节有所不同。
在每一个操作系统中，都有一个视窗构建组成的构建家族。在这里就是Button和Text组成的产品族。而每一个视窗构件都构成自己的等级结构，由一个抽象角色给出抽象的功能描述，而由具体子类给出不同操作系统下的具体实现。
可以发现在上面的产品类图中，有两个产品的等级结构，分别是Button等级结构和Text等级结构。同时有两个产品族，也就是UNIX产品族和Windows产品族。UNIX产品族由UNIX Button和UNIX Text产品构成；而Windows产品族由Windows Button和Windows Text产品构成。
显然，一个系统只能够在某一个操作系统的视窗环境下运行，而不能同时在不同的操作系统上运行。所以，系统实际上只能消费属于同一个产品族的产品。
用上面的例子实现的类图及代码如下：
/**
* 功能简述: 按钮接口<br>
*
*/
public interface Button {
}
/**
* 功能简述: unix系统按钮实现类<br>
*
*/
public class UnixButton implements Button {
public UnixButton() {
System.out.println("I am unix button！");
}
}
/**
* 功能简述: windows系统按钮实现类<br>
*
*/
public class WindowsButton implements Button {
public WindowsButton() {
System.out.println("I am windows button！");
}
}
/**
* 功能简述: 文本框接口<br>
*
*/
public interface Text {
}
/**
* 功能简述: unix系统文本框实现类<br>
*
*/
public class UnixText implements Text {
public UnixText() {
System.out.println("I am unix text！");
}
}
/**
* 功能简述: windows系统文本框实现类<br>
*
*/
public class WindowsText implements Text {
public WindowsText() {
System.out.println("I am windows text！");
}
}
上面定义了两个接口，分别为Button和Text，表示两类抽象产品，另外还有每个接口对应Unix和Windows的两个实现。
/**
* 功能简述: 抽象工厂接口<br>
*
*/
public interface AbstractFactory {
/**
*
* 功能描述: 创建按钮工厂<br>
*
* @return
*/
public Button createButton();
/**
*
* 功能描述: 创建文本工厂<br>
*
* @return
*/
public Text createText();
}
抽象工厂类和简单工厂不一致的地方在于其定义了两个方法，返回同一产品族的Button和Text。下面定义Unix和Windows不同的实现：
/**
* 功能简述: unix系统实现<br>
*
*/
public class UnixSystem implements AbstractFactory {
@Override
public Button createButton() {
return new UnixButton();
}
@Override
public Text createText() {
return new UnixText();
}
}
/**
* 功能简述: windows系统实现<br>
*
*/
public class WindowsSystem implements AbstractFactory {
@Override
public Button createButton() {
return new WindowsButton();
}
@Override
public Text createText() {
return new WindowsText();
}
}
可以看到，Unix实现类返回Unix的UnixButton和UnixText，Windows实现类返回Windows的WindowsButton和WindowsText。每类工厂都有两个以上的具体产品，形成一个产品族。
/**
* 功能简述: 测试类<br>
*
*/
public class Client {
/**
* 功能描述: 测试方法<br>
*
* @param args
*/
public static void main(String[] args) {
UnixSystem unixSys = new UnixSystem();
unixSys.createButton();
unixSys.createText();
WindowsSystem winSys = new WindowsSystem();
winSys.createButton();
winSys.createText();
}
// 运行结果
// I am unix button！
// I am unix text！
// I am windows button！
// I am windows text！
}
通过以上的几个例子，已经讲完了“工厂”设计模式。
当然实际开发中，总有不同的实现，你能看出是“工厂”模式的影子，但仔细对比发现却又不是“工厂”的样子。我觉得，设计模式只是提供的一个标准的模板，是一个标杆，每个不同的实现围绕标杆即可。设计模式的最终目的是为了解耦，便于软件的维护。在实际开发中使用设计模式固然是好事，但也不能为了设计模式而设计，我们应当多尝试，时间久了就会自然而然的在软件设计中使用模式，使得软件质量提高。希望大家不断进步。
