简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建哪一种产品类的实例，但它不属于GOF的23种设计模式。简单工厂模式适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象则不需要关心。
 以课程学习为例，现在我们手上有JAVA，大数据，AI等课程需要学习，首先定义一个课程标准接口：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 21:36 2020/4/9
 */
public interface ICourse {

    void study();

}

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

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 21:57 2020/4/9
 */
public class JavaCourse implements ICourse {
    public void study() {
        System.out.println("我正在学习Java课程，我可真棒！");
    }
}

以传统方式调用一下

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

 在上述代码中，接口ICourse指向实现类JavaCourse的引用，应用层代码需要依赖JavaCourse。如果业务扩展，继续增加PythonCourse等更多课程，那么客户端的依赖将会越来越臃肿。因此，我们要想办法减弱这种依赖，把创建细节隐藏起来。虽然在目前的代码中，创建过程并不复杂，但从代码设计的角度上来讲不容易被扩展。
 现在我们使用简单工厂模式对代码进行优化，先增加课程类PythonCourse：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 23:52 2020/4/9
 */
public class PythonCourse implements  ICourse {
    public void study() {
        System.out.println("我正在学习Python课程，我可真棒！");
    }
}

创建工厂类CourseFactory：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 23:54 2020/4/9
 */
public class CourseFactory {

    public ICourse create(String name) throws Exception {
        if("Java".equals(name)) {
            return new JavaCourse();
        } else if("Python".equals(name)) {
            return new PythonCourse();
        } else {
            throw new Exception("不存在该课程名");
        }
    }
}

修改调用代码如下

    public static void main(String[] args) throws Exception {
        CourseFactory factory = new CourseFactory();
        ICourse course = factory.create("Java");
                course.study();
    }

 至此，调用代码变简单了，但如果我们的业务逻辑继续扩展，例如加入AI课程，那么工厂中的create（）方法每次都要根据产品的增加修改代码逻辑，不符合开闭原则。因此，我们还可以使用Java的反射技术对简单工厂的模式继续优化：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 23:54 2020/4/9
 */
public class CourseFactory {
    public ICourse create(Class<? extends ICourse> clazz) {

        if(null != clazz) {
            try {
                return clazz.newInstance();
            } catch(InstantiationException e) {
                e.printStackTrace();
            } catch(IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

优化调用代码：

    public static void main(String[] args) throws Exception {
        CourseFactory factory = new CourseFactory();
        ICourse iCourse = factory.create(JavaCourse.class);
        iCourse.study();
    }

 优化之后，课程的不断丰富不用再去修改CourseFactory的代码，并且参数由之前的字符串变成了class对象，避免了因为字符串的输入问题造成BUG，提升了可控性，同时使用了泛型锁定了该工厂类只创建ICourse的子类对象，符合单一职责原则。

总结

 简单工厂模式很好的隐藏了对象的创建细节，使调用者只需要考虑使用而不用考虑创建问题。但在这种设计模式下，工厂类的职责相对过重，不易于扩展过于复杂的产品结构。

ps：GOF是设计模式的经典名著Design Patterns: Elements of Reusable Object-Oriented Software（中译本名为《设计模式——可复用面向对象软件的基础》）的四位作者，他们分为是：Elich Gamma、Richard Helm、Ralph Johnson、以及John Vlissides。这四个人常被称为Gang of Four， 即四人组，简称GOF。

文章参考

《Spring5核心原理》〔中〕谭勇德（Tom）