之前的简单工厂模式并不属于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工厂方法创建产品的实例

个人总结

想要成为一个优秀的程序员，我们就不能静态的去看待问题。在平时练习的时候要站在一个领导者的角度思考，如果这个项目分给几个人做，应该如何去设计类与类的关系；还得有一个时间轴的概念，如果业务需求在未来发生变化，我应该在最初的时候如何设计才可以尽量增加大的扩展性。只有经常去思考这些问题，设计模式才可以慢慢融入到工作中，信手拈来。