工厂模式 | Warms

大家好我是mihotel，今天来总结一下设计模式中的工厂模式，在平时编程中，构建对象最常用的方式是 new 一个对象。乍一看这种做法没什么不好，而实际上这也属于一种硬编码。每 new 一个对象，相当于客户端多知道了一个类，增加了类与类之间的联系，不利于程序的松耦合。我们可以利用工厂模式封装对象的生产过程。

简单工厂模式

首先是简单工厂模式，它是通过指定一个工厂对象来创建产品实例，只需要传给工厂参数，不需要关系对象是怎样产生的.
举个例子：如果我们要录制Java和Python两门课程，我们可以先创建ICourse接口, 提供录制功能：

1
2
3

public interface ICourse {
    void record();// 录制
}

然后分别创建JavaCourse类与PythonCourse类

public class JavaCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("录制Java课程");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("录制Python课程");
    }
}

如果我们不使用工厂模式来创建对象，客户端的代码是这样的：

@Test
public void testFactory01() {
	ICourse java = new JavaCourse();
	java.record();
	ICourse python = new PythonCourse();
	python.record();
}

可以看到客户端直接依赖了JavaCourse对象和PythonCourse对象，随着业务发展耦合度会很高。

下面我们通过简单工厂模式解耦，创建简单工厂模式类：

public class SympleFactory {
    public <T> T getCourse(Class<T> clazz) {
        try {
            return clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

利用简单工厂模式我们再来看看客户端实现，代码如下:

@Test
public void testFactory02() {
    SympleFactory sympleFactory = new SympleFactory();
    JavaCourse java = sympleFactory.getCourse(JavaCourse.class);
    java.record();
    PythonCourse python = sympleFactory.getCourse(PythonCourse.class);
    python.record();
}

可以看到现在客户端只与sympleFactory产生依赖，因此达到了解耦的作用。还需注意到，在SympleFactory中我们使用了反射来创建对象，避免了过多的 if else 语句。

总结一下：

简单工厂模式:

概念：指定一个工厂对象来创建产品实例，只需要传给工厂参数，不需要关系对象是怎样产生的.
好处：如果业务扩展客户端会依赖 “一坨”对象，耦合度高，通过简单工厂模式改造后只依赖工厂类，耦合度降低
缺点：不符合开闭原则，如果增加新的参数则需要修改创建对象的代码

工厂方法模式

可以看到简单工厂模式只适合生产少量的对象，如果生产的对象总类过多，既不符合单一职责原则，也会导致工厂类十分臃肿。工厂方法模式就解决了该问题，通过指定一个创建对象的接口，让实现这个接口的类来决定实例化哪一个类，实例化推迟到子类中进行。

举个例子，要开设多门编程语言课程比如java、python，下面我们用工厂方法模式来生产这些对象，首先定义一个ICourseFactory接口：

1
2
3

public interface ICourseFactory {
    ICourse create();
}

创建java工厂和python工厂：

public class JavaCourseFactory implements ICourseFactory{
    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}

public class PythonFactory implements ICourseFactory {
    @Override
    public ICourse create() {
        return new PythonCourse();
    }
}

再来创建客户端测试类：

@Test
public void testFactory03() {
    ICourseFactory javaCourseFactory = new JavaCourseFactory();
    ICourse java = javaCourseFactory.create();
    java.record();
    ICourseFactory pythonFactory = new PythonFactory();
    ICourse python = pythonFactory.create();
    python.record();
}

可以发现工厂方法模式符合单一职责原则，一个工厂的具体实现类只生产一种产品，并且符合开闭原则，当需要生产新的产品时不需要修改代码，只需要新增一个实现类即可。

总结一下:

工厂方法模式:

概念：指定一个创建对象的接口，让实现这个接口的类来决定实例化哪一个类，实例化推迟到子类中进行。
好处：用户只需要关心生产产品对应的工厂，不需要关系生产产品的细节，符合开闭原则
适用场景：
1. 创建对象需要大量重复代码
2. 客户端（应用层）不依赖产品实例如何被创建、如何被实现等细节
3. 一个类通过其子类来指定创建哪个对象

抽象工厂模式

可以看到工厂方法模式生产是某个产品的专属工厂，而实际情况下我们往往需要生产一个产品类簇，比如空调和空调遥控器就属于一个产品类簇。下面还是举个例子，我们如果要开设编程课程，每门课程不止会有视频，还会有笔记，java课程有对应的视频和笔记，同理python课程也有。下面我们使用抽象工厂模式来生产“视频”和“笔记”这一个类簇的对象。首先创建视频接口和笔记接口：

public interface IVideo {
    void record();// 录制
}
public interface INote {
    void edit();// 编辑
}

然后创建对应的实现类:

public class JavaNote implements INote{
    @Override
    public void edit() {
        System.out.println("java课程笔记");
    }
}
public class JavaVideo implements IVideo{
    @Override
    public void record() {
        System.out.println("录制Java视频");
    }
}

然后我们创建CourseFactory接口作为顶层设计，用来生产”视频“和”笔记“这个产品类簇

public interface CourseFactory {
    INote createNote();
    IVideo createVideo();
}

接下来就是它的实现类：

public class JavaCourseFactory implements CourseFactory{
    @Override
    public INote createNote() {
        return new JavaNote();
    }

    @Override
    public IVideo createVideo() {
        return new JavaVideo();
    }
}

我们来看一下客户端调用：

public void testFactory04() {
    CourseFactory javaCourseFactory = new JavaCourseFactory();
    IVideo javaVideo = javaCourseFactory.createVideo();
    javaVideo.record();
    INote javaNote = javaCourseFactory.createNote();
    javaNote.edit();
}