之前的简单工厂模式并不属于23种GOF设计模式之一，今天我们将介绍真正的工厂设计模式，工厂方法模式。
0.抛出问题
在学习设计模式的时候，我们首先要明白该设计模式能解决什么问题，在什么应用场景下是最优的，这样我们才会学以致用，避免出现为了设计而设计的情况。所以我也就啰嗦一下，一步一步的用简单工厂模式去抛出问题，更好的让大家明白为什么要使用工厂方法模式。
今天我们举一个文件分割器的例子
业务需求：分割图片、文本等格式的文件的工具
我们先用简单工厂模式写
//定义分割器的接口
public interface Splitter {
public void splitter(File file);
}
//图片分割
public class PicSplitter implements Splitter {
@Override
public void splitter(File file) {
System.out.println("分割图片");
}
}
//文本分割
public class TxtSplitter implements Splitter {
@Override
public void splitter(File file) {
System.out.println("分割文本文件");
}
}
//分割器工厂
public class SplitterFactory {
public static Splitter createSplitter(String param) throws Exception
{
switch (param)
{
case "picture":
return new PicSplitter();
case "text":
return new TxtSplitter();
default:
throw new Exception("没有这个文件分割器");
}
}
}
//主函数
public class Main {
public static void main(String[] args)
{
try {
Splitter picSplitter = SplitterFactory.createSplitter("picture");
File picFile = new File("");
picSplitter.splitter(picFile);
Splitter txtSplitter = SplitterFactory.createSplitter("text");
File textFile = new File("");
txtSplitter.splitter(textFile);
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果如下
分割图片
分割文本文件
Process finished with exit code 0
完工！
现在客户新需求来了：增加视频分割器（心中一万头草泥马奔过）
继续搬砖，具体代码如下
public class VideoSplitter implements Splitter {
@Override
public void splitter(File file) {
System.out.println("分割视频");
}
}
public class SplitterFactory {
public static Splitter createSplitter(String param) throws Exception
{
switch (param)
{
case "picture":
return new PicSplitter();
case "text":
return new TxtSplitter();
case "video"://新增视频switch分支
return new VideoSplitter();
default:
throw new Exception("没有这个文件分割器");
}
}
}
大功告成！不过似乎嗅到了bad small，没错，违背了开放闭合原则，在增添新功能的时候修改了源码。
我们来分析一下问题是怎么产生的？
在简单工厂模式中，工厂类通过new的方式创建具体产品角色（也就是各种分割器），这样工厂类依赖具体产品角色。也就是说，抽象类依赖具体类，也就违背了依赖倒置原则。造成了具体产品角色和工厂之间的过耦合，在增添新功能的时候也不可避免的修改源码。
那在这种场景下，使用简单工厂模式会带来什么缺陷呢？
1.在增加新功能的时候修改源码，会有非法操作的危险
2.降低了代码的复用性
在这里解释一下第二点，我们在初学编程接触函数的时候，最早有了代码复用性的概念，把一些重复的代码抽取出来，写成函数，提高复用性，减少代码量。不过在面向对象的世界里，代码复用性更多的是指编译文件层面，如果我们按照上述代码去设计，在增加视频分割器以后我们需要修改原有的工厂类代码，这样的话工厂类就需要被重新编译，也就不存在什么复用性了。
1.工厂方法模式
既然在上面提到了在工厂类（SplitterFactory）里违背了依赖倒置原则，我们可以很自然的想到，把各种分割器都抽象成一个接口，让工厂类去依赖接口。也就是具体依赖抽象，这样不就ok。
动手动手
\\定义一个工厂接口
public interface SplitterFactory {
Splitter createSplitter();
}
\\图片分割器工厂
public class PicSplitterFactory implements SplitterFactory {
@Override
public Splitter createSplitter() {
return new PicSplitter();
}
}
\\文本分割器工厂
public class TextSplitterFactory implements SplitterFactory {
@Override
public Splitter createSplitter() {
return new TxtSplitter();
}
}
public class Main {
public static void main(String[] args) {
//创建各种分割器工厂，用具体工厂类去创建分割器
SplitterFactory picSplitterFactory = new PicSplitterFactory();
SplitterFactory txtSplitterFactory = new TextSplitterFactory();
Splitter picSplitter = picSplitterFactory.createSplitter();
File picFile = new File("");
picSplitter.splitter(picFile);
Splitter txtSplitter = txtSplitterFactory.createSplitter();
File textFile = new File("");
txtSplitter.splitter(textFile);
}
}
运行结果
分割图片
分割文本文件
Process finished with exit code 0
如果需要加一个视频分割类呢，简单
public class VideoSpitterFactory implements SplitterFactory {
@Override
public Splitter createSplitter() {
return new VideoSplitter();
}
}
public class VideoSplitter implements Splitter {
@Override
public void splitter(File file) {
System.out.println("分割视频");
}
}
只需要添加上面的代码，源文件无需修改，也就不存在误操作风险和重新编译的麻烦，在增添新功能后可以直接在客户端（主函数使用）
public class Main {
public static void main(String[] args) {
SplitterFactory picSplitterFactory = new PicSplitterFactory();
SplitterFactory txtSplitterFactory = new TextSplitterFactory();
SplitterFactory videoSplitterFactory = new VideoSpitterFactory();//新功能
Splitter picSplitter = picSplitterFactory.createSplitter();
File picFile = new File("");
picSplitter.splitter(picFile);
Splitter txtSplitter = txtSplitterFactory.createSplitter();
File textFile = new File("");
txtSplitter.splitter(textFile);
File videoFile = new File("");
Splitter videoSplitter = videoSplitterFactory.createSplitter();//新功能
videoSplitter.splitter(videoFile);
}
}
模式定义
工厂方法模式（FACTORY METHOD）是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂（其实我认为应该叫工厂基类，避免和后面的抽象工厂方法混淆）；具体工厂；抽象产品；具体产品
| 组成（角色） | 关系 | 作用 |
|---|---|---|
| 抽象产品（Product） | 具体产品的父类 | 描述具体产品的公共接口 |
| 具体产品（Concrete Product） | 抽象产品的子类；工厂类创建的目标类 | 描述生产的具体产品 |
| 抽象工厂（Creator） | 具体工厂的父类 | 描述具体工厂的公共接口 |
| 具体工厂（Concrete Creator） | 抽象工厂的子类；被外界调用 | 描述具体工厂；实现FactoryMethod工厂方法创建产品的实例 |
个人总结
想要成为一个优秀的程序员，我们就不能静态的去看待问题。在平时练习的时候要站在一个领导者的角度思考，如果这个项目分给几个人做，应该如何去设计类与类的关系；还得有一个时间轴的概念，如果业务需求在未来发生变化，我应该在最初的时候如何设计才可以尽量增加大的扩展性。只有经常去思考这些问题，设计模式才可以慢慢融入到工作中，信手拈来。
