设计模式-工厂模式

Spring 中用到的设计模式
Spring IOC 工厂、单例、装饰器
Spring AOP 代理、观察者
Spring MVC 委派、适配器
Spring JDBC 模板方法

工厂模式的历史由来
在现实生活中我们都知道，原始社会自给自足（没有工厂）、农耕社会小作坊（简单工厂，民间酒坊）、工业革命流水线(工厂方法，自产自销)、现代产业链代工厂(抽象工厂，富士康)

简单工厂模式
简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于 GOF中的23 种设计模式（参考资料：http://en.wikipedia.org/wiki/Design_Patterns#Patterns_by_Type）。简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。
接下来以课程为例。学校目前开设有 Java 架构、大数据、人工智能等课程。我们可以定义一个课程标准 ICourse 接口

public interface ICourse {
/** 录制课程视频 */
public void record();
}

创建一个 Java 课程的实现类JavaCourse ：

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

客户端调用代码：

public static void main(String[] args) {
    ICourse course = new JavaCourse();
    course.record();
}

这种写法是不使用工厂模式的写法。自己编写创建实例代码，创建过程复杂时 代码冗余多，不易统一维护，可以考虑使用简单工厂模式优化：
增加课程 PythonCourse 类

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

创建 CourseFactory 工厂类

public class CourseFactory {
    public ICourse create(String name){
       if("java".equals(name)){
           return new JavaCourse();
        }else if("python".equals(name)){
           return new PythonCourse();
        }else {
          return null;
       }
    }
 }

客户端调用代码：

public class SimpleFactoryTest {
    public static void main(String[] args) {
        CourseFactory factory = new CourseFactory();
        factory.create("java");
    }
}

将 factory 的 create()改为静态方法,调用会更加方便
这种方式使客户端调用更加简单，但是使用条件判断每次增加课程都需要 修改工厂中的判断逻辑，不符合开闭原则。可以使用反射优化如下：

public class CourseFactory {
    public ICourse create(Class<? extends ICourse> clazz){
    try {
        if (null != clazz) {
            return clazz.newInstance();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
    return null;
}

客户端调用代码变为：

public class SimpleFactoryTest {
    public static void main(String[] args) {
        CourseFactory factory = new CourseFactory();
        ICourse course = factory.create(JavaCourse.class);
        course.record();
    }
}

简单工厂模式在 JDK 源码也是无处不在，例如 Calendar 类。还有 常用的 LoggerFactory

工厂方法模式
工厂方法模式（Fatory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个产品类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且有新的产品加入时符合开闭原则。
工厂方法模式主要解决产品扩展的问题，在简单工厂中，随着产品链的丰富，如果每个课程的创建逻辑有区别的话，工厂的职责会变得越来越重，有点像万能工厂，且不便于维护。根据单一职责原则我们将职能继续拆分，专人干专事。Java 课程由 Java 工厂创建，Python 课程由 Python 工厂创建，通用逻辑可以通过抽象方法实现，各自实现自己的专有逻辑。
创建ICourseFactory 接口

public interface ICourseFactory {
    ICourse create();
}

创建子工厂JavaCourseFactory 类

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

创建子工厂PythonCourseFactory 类

public class PythonCourseFactory implements ICourseFactory {
    public ICourse create() {
        return new PythonCourse();
    }
}

客户端调用代码：

public static void main(String[] args) {
    ICourseFactory factory = new PythonCourseFactory();
    ICourse course = factory.create();
    course.record();
    factory = new JavaCourseFactory();
    course = factory.create();
    course.record();
}

类图如下：

工厂方法适用于以下场景：
1、创建对象需要大量重复的代码。
2、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
3、一个类通过其子类来指定创建哪个对象。
工厂方法也有缺点：
1、类的个数容易过多，增加复杂度。
2、增加了系统的抽象性和理解难度

抽象工厂模式

抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。 个人理解： 在工厂方法的基础上，一个工厂不止生产一种产品而是一组相关联的几种产品。比如上边示例中 的课程，一般除了会 录制,还要有笔记和代码。

IVideo 接口：

public interface IVideo {
    void record();
}

INote 接口

public interface INote {
    void edit();
}

创建一个抽象工厂 CourseFactory 类

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

接下来，创建Java 视频 JavaVideo 类:

public class JavaVideo implements IVideo {
    public void record() {
        System.out.println("录制 Java 视频");
    }
}

Java 课堂笔记 JavaNote 类：

public class JavaNote implements INote {
    public void edit() {
        System.out.println("编写 Java 笔记");
    }
}

创建 Java 的具体工厂 JavaCourseFactory

public class JavaCourseFactory implements CourseFactory {
    public INote createNote() {
        return new JavaNote();
    }
    public IVideo createVideo() {
        return new JavaVideo();
    }
}

然后创建 Python 视频 PythonVideo 类：

public class PythonVideo implements IVideo {
    public void record() {
       System.out.println("录制 Python 视频");
    }
}

Python 课堂笔记 PythonNote 类

public class PythonNote implements INote {
    public void edit() {
       System.out.println("编写 Python 笔记");
    }
}

Python工厂 PythonCourseFactory

public class PythonCourseFactory implements CourseFactory {
    public INote createNote() {
        return new PythonNote();
    }
    public IVideo createVideo() {
        return new PythonVideo();
    }
}

客户端调用：

public static void main(String[] args) {
    factory = new JavaCourseFactory();
    factory.createNote().edit();
    factory.createVideo().record();
}

上边代码展示了抽象工厂模式。有个问题如果我们再继续增加一个产品比如课程源码 Source也加入到课程中，那么我们的代码从抽象工厂，到具体工厂要全部调整，很显然不符合开闭原则。因此抽象工厂也是有缺点的：
1、规定了所有可能被创建的产品，新增产品困难，需要修改抽象工厂的接口和所有工厂实现类。
2、增加了系统的抽象性和理解难度。

但在实际应用中，我们千万不能犯强迫症甚至有洁癖。在实际需求中产品结构升级是非常正常的一件事情。我们可以根据实际情况，只要不是频繁升级，可以不遵循开闭原则。

个人理解：实际上简单工厂模式、工厂方法模式、抽象工厂模式适用场景 分别是在生产单个简单对象、生产多个种类单个简单对象、生产多个种类的相关的多个对象。有点想点线面，时机工作中根据业务场景的复杂程度以及扩展方向进行选择即可。