Spring源码学习笔记：经典设计模式之工厂模式

1、博客内容均出自于咕泡学院架构师第三期
2、架构师系列内容：架构师学习笔记（持续更新）

0、工厂模式（Factory Pattern）

工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。
工厂模式跟单例模式紧密相关

1、简单工厂模式（ Simple Factory Pattern）

是指由一个工厂对象决定创建出哪一种产品类的实例 属于创建型模式，但它不属于GOF的23种设计模式。
简单工厂类负责创建的对象较少，客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关系。
优点： 只需要传入一个正确的参数，就可以获取你所需要的对象，无需知道其创建的细节。
缺点： 工厂类的职责相对于过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则；不易于扩展对于复杂的产品结构。

Calendar.getInstance(); 就属于简单工厂模式
具体看代码：
创建课程接口：

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:42
* @description ：
*/
public interface ICourse {


    public void record();
}

创建JavaCourse实现类

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:43
* @description ：
*/
public class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制Java课程");
    }
}

创建课程创建工厂：

package com.jarvisy.demo.pattern.factory.simplefactory;


import com.jarvisy.demo.pattern.factory.ICourse;
import com.jarvisy.demo.pattern.factory.JavaCourse;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:45
* @description ：课程创建工厂
*/
public class CourseFactory {


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


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

创建测试类：

package com.jarvisy.demo.pattern.factory.simplefactory;


import com.jarvisy.demo.pattern.factory.ICourse;
import com.jarvisy.demo.pattern.factory.JavaCourse;


import java.util.Calendar;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:44
* @description ：
*/
public class SimpleFactoryTest {


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

2、工厂方法模式（Fatory Method Pattern）

是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。 属于创建型设计模式 在23种设计模式中。
工厂方法模式适用场景：
创建对象需要大量重复的代码；客户端（应用层）不依赖于产品类实例如何被创建，实现等细节，一个类通过其子类来指定创建哪个对象。
工厂方法模式的优点：
用户只需要关心所需产品对应的工厂，无需关心创建细节 ； 加入新产品符合开闭原则，提高了系统的可扩展性。
工厂方法模式的缺点：
类的个数容易过多，增加了代码结构的复杂度，增加了系统的抽象性和理解难度。

LoggerFactory.getLogger() 就属于工厂方法模式
具体看代码：
创建课程接口：

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:42
* @description ：
*/
public interface ICourse {


    public void record();
}

创建JavaCourse，PythonCourse 课程：

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:43
* @description ：
*/
public class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制Java课程");
    }
}

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:43
* @description ：
*/
public class PythonCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制Python课程");
    }
}

创建工厂接口并实现两门课程工厂类：

package com.jarvisy.demo.pattern.factory.factorymethod;


import com.jarvisy.demo.pattern.factory.ICourse;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:13
* @description ：
*/
public interface ICourseFactory {
    ICourse create();
}

package com.jarvisy.demo.pattern.factory.factorymethod;


import com.jarvisy.demo.pattern.factory.ICourse;
import com.jarvisy.demo.pattern.factory.JavaCourse;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:15
* @description ：
*/
public class JavaCourseFactory implements ICourseFactory {
    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}

package com.jarvisy.demo.pattern.factory.factorymethod;


import com.jarvisy.demo.pattern.factory.ICourse;
import com.jarvisy.demo.pattern.factory.PythonCourse;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:15
* @description ：
*/
public class PythonCourseFactory implements ICourseFactory {
    @Override
    public ICourse create() {
        return new PythonCourse();
    }
}

创建测试类：

package com.jarvisy.demo.pattern.factory.factorymethod;


import com.jarvisy.demo.pattern.factory.ICourse;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:17
* @description ：
*/
public class FactoryMethodTest {
    public static void main(String[] args) {
        ICourseFactory factory = new PythonCourseFactory();
        ICourse course = factory.create();
        course.record();
    }
}

2、抽象工厂模式（Abastract Factory Pattern）

是指提供一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类。 属于创建型设计模式 在23种设计模式中。
适用场景：
客户端（应用层）不依赖于唱片类实例如何被创建，实现等细节。
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。
提供一个产品类的库，所有的产品以同样的接口出现。从而使客户端不依赖于具体实现。

优点：
具体产品再应用层代码隔离，无须关心创建细节。
将一个系列的产品族统一到一起创建。

缺点：
规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口，不符合开闭原则。
增加了系统的抽象性和理解难度。

DefaultListableBeanFactory 就属于抽象工厂模式
具体看代码：
创建课程，笔记，视频接口：

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:42
* @description ：
*/
public interface ICourse {


    public void record();
}

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:40
* @description ：
*/
public interface INote {
}

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:40
* @description ：
*/
public interface IVideo {
}

创建它们的实现类：

package com.jarvisy.demo.pattern.factory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 17:43
* @description ：
*/
public class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制Java课程");
    }
}

package com.jarvisy.demo.pattern.factory.abstractfactory;


import com.jarvisy.demo.pattern.factory.INote;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:42
* @description ：
*/
public class JavaNote implements INote {
}

package com.jarvisy.demo.pattern.factory.abstractfactory;


import com.jarvisy.demo.pattern.factory.IVideo;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:42
* @description ：
*/
public class JavaVideo implements IVideo {
}

创建工厂接口，并且创建JavaCourseFactory工厂，如果还有Python课程，那就继续创建PythonCourseFactory工厂:

package com.jarvisy.demo.pattern.factory.abstractfactory;


import com.jarvisy.demo.pattern.factory.ICourse;
import com.jarvisy.demo.pattern.factory.INote;
import com.jarvisy.demo.pattern.factory.IVideo;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:38
* @description ：要求所有的子工厂都实现这个工厂 一个品牌的抽象
*/
public interface ICourseFactory {


    ICourse createCourse();


    INote crateNote();


    IVideo createVideo();
}

package com.jarvisy.demo.pattern.factory.abstractfactory;


import com.jarvisy.demo.pattern.factory.ICourse;
import com.jarvisy.demo.pattern.factory.INote;
import com.jarvisy.demo.pattern.factory.IVideo;
import com.jarvisy.demo.pattern.factory.JavaCourse;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:38
* @description ：
*/
public class JavaCourseFactory implements ICourseFactory {
    @Override
    public ICourse createCourse() {
        return new JavaCourse();
    }


    @Override
    public INote crateNote() {
        return new JavaNote();
    }


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

创建测试类：

package com.jarvisy.demo.pattern.factory.abstractfactory;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/13 18:44
* @description ：
*/
public class AbstractFactoryTest {
    public static void main(String[] args) {
        ICourseFactory factory = new JavaCourseFactory();
        factory.createCourse().record();
        factory.createVideo();
        factory.crateNote();
    }
}