工厂模式的由来：
在现实生活中我们都知道，原始社会自给自足（没有工厂）、农耕社会有了小作坊（简单工厂）、工业革命后有了流水线（工厂方法）、现代产业链有代工厂（抽象工厂）等。
我们的项目代码同样是由简到繁一步一步迭代来的，但是对于调用者来说却是越来越简单化了。

简单工厂模式：
是指由一个工厂对象决定创建哪一种产品类的实例，但它不属于23种常用设计模式，简单工厂模式适用于工厂类负责创建的对象较少的场景，切客户端只需要传入工厂类的参数，对于如何创建对象不需要关心。
话不多说，以代码举例：
现在有个学校，开设有Java架构、大数据、人工智能等课程，已经形成了一个生态。我们定义一个课程标准ICourse接口：

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

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

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

我们这样假设客户端调用代码：

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

在上面的代码中，父类ICourse指向子类JavaCourse的引用，应用层代码需要依赖JavaCourse，如果业务扩展，继续增加PythonCourse甚至更多课程，那么客户端的依赖会变得越来越臃肿。因此，我们要想办法把这种依赖减弱，把创建细节隐藏起来。虽然在目前的代码中，创建对象的过程并不复杂，但从代码设计的交付来讲，不易于扩展。现在，我们用简单工厂模式对代码进行优化：
学校增加了python课程：

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

创建工厂类：CourseFactory：

public class CourseFactory {
    public ICourse creat(String name){
        if("java".equals(name)){
            return new JavaCourse();
        }else if("python".equals(name)){
            return new PythonCourse();
        }else {
            return null;
        }
    
修改客户端调用代码如下：

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

为了调用方便我们可以将工厂的方法转为静态方法，客户端调用变简单了，但是如果我们的业务继续拓展，要增加前端课程，那么工厂中的create()方法就要每次都根据产品修改代码逻辑，不符合开闭原则。因此，我们还可以对简单工厂模式继续优化，这次我们采用反射优化：

public class CourseFactory {
    public static ICourse creat(String className){
        try {
            if(!(null==className||"".equals(className))){
                return (ICourse) Class.forName(className).newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return null;
    }
}

修改客户端调用代码：

public class Main {
    public static void main(String[] args) {
        CourseFactory factory = new CourseFactory();
        ICourse course = factory.creat("com.设计模式.简单工厂.JavaCourse");
        course.record();
    }
}

优化之后，产品不断丰富的过程中不需要修改CourseFactory中的代码。但是还有个问题，方法参数是字符串，可控性有待提示，而且还需要强制转型，再修改一下工厂代码：

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

优化客户端代码：

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

这样看起来就比较接近Spring中的使用了：
比如logback中LoggerFactory中有多个重载的方法，getLogger():

    public static Logger getLogger(String name){
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }
    public static Logger getLogger(Class clazz){
        return getLogger(clazz.getName());
    }

简单工厂模式也有他的缺点：工厂类的职责相对过重，不易于扩展过于复杂的产品结构