设计模式之工厂模式

为什么要用设计模式

不用设计模式并非不可以，但是用好设计模式能帮助我们更好的解决实际问题，设计模式最重要的是解耦。设计模式天天都在用，但自己却无感知。我们把设计模式作为一个专题，主要是学习设计模式是如何总结经验的，把经验为自己作用。学设计模式也是锻炼将业务需求转换技术实现的一种非常有效的方式。
帮助我们写出更加优雅的代码、更好的去重构项目

Spring中用到的设计模式

1. 工厂模式 ：BeanFactory
2. 装饰器模式 ：BeanWrapper；
3. 代理模式 ：AopProxy
4. 单例模式 ：ApplicationContext
5. 委派模式 ：DispatcherServlet
6. 策略模式 ：HandlerMappeing
7. 适配器模式 ：HandlerAdapter
8. 模板方法模式 ：JdbcTemplate
9. 观察者模式 ：ContextLoaderListener

简单工厂模式

• 简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例，
• 属于创建型模式，但它不属于GOF 23种设计模式。
• 简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

源码分析

// 创建课程接口
public interface ICourse {
    void record();
}
//创建java课程实体
public class JavaCourse implements ICourse {
    public void record(){
        System.out.println("录制java课程");
    }
}
//创建python课程实体
public class PythonCourse implements ICourse {
    public void record(){
        System.out.println("录制Python课程");
    }
}
//创建工厂
public class CourseFactory {
    public ICourse create(Class<? extends ICourse> clazz){
        try{
            if(clazz != null ){
                return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
//普通情况下都是这样创建的
//        ICourse course1 = new JavaCourse();
//        ICourse course2 = new PythonCourse();
//        course1.record();
//        course2.record();
//使用工厂后
        ICourse course = new CourseFactory().create(JavaCourse.class);
        course.record();
    }
}

打印：
录制java课程

案例：
Calendar.getInstance();
LoggerFactory.getLogger();
Calendar为例
//部分源码
if (aLocale.hasExtensions()) {
    String caltype = aLocale.getUnicodeLocaleType("ca");
    if (caltype != null) {
        switch (caltype) {
        case "buddhist":
        cal = new BuddhistCalendar(zone, aLocale);
            break;
        case "japanese":
            cal = new JapaneseImperialCalendar(zone, aLocale);
            break;
        case "gregory":
            cal = new GregorianCalendar(zone, aLocale);
            break;
        }
    }
}
Calendar.getInstance()方法中的
createCalendar方法会根据传入不同时区的参数来创建不同实体（BuddhistCalendar、JapaneseImperialCalendar、GregorianCalendar）这些实体都会继承Calendar，由Calendar来提供对外的接口

类图：

简单工厂的适用场景

• 工厂类负责创建的对象较少。
• 客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

简单工厂的缺点

• 只需要传入一个正确的参数，就可以获取你所需要的对象，无需知道其创建的细节

简单工厂的缺点

• 工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则。
• 不易于扩展过于复杂的产品结构。

工厂方法模式

• 工厂方法模式（Factory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。
• 在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。
• 属于创建型设计模式

源码分析

//创建课程接口
public interface ICourse {
    void record();
}
//创建课程实体
public class JavaCourse implements ICourse {
    public void record(){
        System.out.println("录制java课程");
    }
 }
//创建工厂接口
public interface ICourseFactory {
    ICourse create();
}
//创建具体的课程工厂
public class JavaCourseFactory implements ICourseFactory {
    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        ICourseFactory courseFactory = new JavaCourseFactory();
        ICourse course =  courseFactory.create();
        course.record();
    }
}

打印：
录制java课程

类图：

课程和工厂都有个抽象，用户只需要去找对应的工厂就可以创建具体的产品了，具体的实现是由工厂来实现

举例：
ILoggerFactory中
顶层工厂有三个实现，它们都有三个工厂实现且都有创建产品的getLogger方法
每个工厂都可以创建对应的Logger产品

NOPLoggerFactory ->> NOPLogger

工厂方法模式适用场景

• 创建对象需要大量重复的代码。
• 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
• 一个类通过其子类来制定创建哪个对象

工厂方法模式的优点

• 用户只需要关心所需产品对应的工厂，无需关心创建细节。
• 加入新产品符合开闭原则，提高了系统的可扩展性

工厂方法模式的缺点

• 类的个数容易过多，增加了代码结构的复杂度
• 增加了系统的抽象性和理解难度

抽象工厂模式

• 抽象工厂模式（AbastractFactory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。
• 属于创建型设计模式。

理解抽象工厂之前，我们要了解两个概念产品等级结构和产品族，看下面的图：
产品族：一系列的相关产品，整合到一起有关联性
产品等级：同一个继承体系

源码分析

//创建笔记接口
public interface INote {
    void edit();
}
//创建录制接口
public interface IVideo {
    void record();
}
//创建java笔记实体
public class JavaNote implements INote {
    @Override
    public void edit() {
        System.out.println("记录Java笔记");
    }
}
//创建java视频实体
public class JavaVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("录制Java视频");
    }
}
//创建抽象工厂
public abstract class CourseFactory {
    public void init(){
        System.out.println("初始化基础数据");
    }
    protected abstract INote createNote();
    protected abstract IVideo createVideo();
}
//创建工厂接口
public interface ICourseFactory {
    ICourse create();
}
//创建具体的课程工厂
public class JavaCourseFactory extends CourseFactory {
    @Override
    protected INote createNote() {
        super.init();
        return new JavaNote();
    }
    @Override
    protected IVideo createVideo() {
        super.init();
        return new JavaVideo();
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        CourseFactory courseFactory = new JavaCourseFactory();
        courseFactory.createNote().edit();
        courseFactory.createVideo().record();
    }
}
打印：
初始化基础数据
记录Java笔记
初始化基础数据
录制Java视频

解析：
课程都是一个系列的，每个课程又有记录笔记或者录制视频等需求，如果每个课程都有公共的逻辑比如初始化数据就可以用抽象类将公共方法写到抽象类中、工厂中有创建笔记和录制视频的功能，我们就可以通过java工厂来创建java视频和java笔记

应用案例：
数据库连接池
系统的开启和关闭都会创建和关闭链接，放入连接池中就可以在系统启动时默认初始化创建链接，每次都是通过getConnection拿到连接 pool就是一个顶层工厂mysql有mysql的Connection，Oracle有Oracle的Connection每中数据库创建连接都有差异，分别由不同的工厂来实现

抽象工厂模式的缺点

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

抽象工厂模式的优点

• 具体产品在应用层代码隔离，无需关系创建细节。
• 将一个系列的产品族统一到一起创建。

抽象工厂模式的适用场景

• 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
• 强调一系列相关的产品对象（属于统一产品族），一起使用创建对象需要大量重复的代码。
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

本文仅作个人记录学习使用