源码中的设计模式--工厂模式

本文要解决的几个问题，

1、什么是工厂模式

2、工厂模式分为哪几种

3、工厂模式的优点

4、源码中有哪些地方使用了工厂模式

一、模式入场

  看到标题想必小伙伴很好理解，所谓“工厂模式”从字面上就可以理解，比亚迪工厂的作用不就是生产比亚迪汽车的，在java中的工厂模式就是用来产生实例的。现在我有这样一个类，

Car.java

package com.my.factory;
/**
 * 汽车类
 * @date 2022/5/8 11:15
 */
public class Car {
    //汽车唯一编码
    private String code;
    //汽车型号
    private String model;
}

现在要使用Car生成一个具体的实例，那么平时的做法肯定是new了，如下

Car car=new Car();

  现在有这样一个场景，在很多地方都要使用Car的实例，那么每一次使用都new一次，都是重复的代码从代码规范层面上就不好看，而且这也不符合设计原则。我们是不是可以专门有一个类来生成Car的实例，在需要Car实例的地方只需要调用该类的方法即可，为此有了下面的工具类，

package com.my.factory.simple;

import com.my.factory.Car;
/**
 * 简单Car工厂
 * @date 2022/5/8 11:22
 */
public class SimpleCarFactory {
    public Car productCar(){
        return new Car();
    }
}

现在想生成Car，就不再使用new了，我调用工具类就可以了，

SimpleCarFactory carFactory=new SimpleCarFactory();
Car car=carFactory.productCar();

  有了SimpleCarFactory工具类就好多了，调用其productCar()方法就给我返回Car实例了，摆脱了new的方式，再也不用被隔壁的小姐姐嘲笑只会new了。

  上面提到的SimpleCarFactory工具类，其实就是工厂模式的一种实现，给它起个名字叫“简单工厂”，《Head first 设计模式》一书中给出的释义是

简单工厂其实不是一个设计模式，反而比较像是一种编程习惯。但由于经常被使用，所以我们给它一个“Head First Pattern荣誉奖”。

上面说了简单工厂更像是一种编程习惯，不过这里我也把它看作是工厂模式的一种实现方式。

  在使用了一段SimpleCarFactory类后，有小伙伴提出每次都需要new一个SimpleCarFactory的实例才能调用其productCar()方法，既然是工具类，把productCar()方法声明为static不是更好，的确在设计理念上又进了一步，

package com.my.factory.simple;

import com.my.factory.Car;
/**
 * 简单Car工厂
 * @date 2022/5/8 11:22
 */
public class SimpleCarFactory {
    public static Car productCar(){
        return new Car();
    }
}

再使用的时候只需这样用就好了，

Car car=SimpleCarFactory.productCar();

上面的这种方式给它起个名字叫“简单静态工厂”，不知不觉中又会了另一种实现，可以和隔壁的小姐姐去炫耀一番了。

“简单工厂”和“简单静态工厂”都是有一个专门的类来生成实例，区别是后者的方法是静态的。

二、深入工厂模式

  上面说到的无论是“简单工厂”还是“简单静态工厂”其实本质上都是一样的，都是在一个类中生成类的实例。

2.1、工厂方法模式

  还是拿上面的汽车工厂的例子来举例，有这样的一个场景，由于汽车订单激增，一个工厂已经无法完成订单了，必须要新建一个工厂来生产汽车，而且每个工厂可以生产不同类型的汽车，现在要对上面的SimpleCarFactory和Car进行改造。假设有两个工厂分别是ConcreteCarFactoryOne和ConcreteCarFactoryTwo，生产的汽车有Biyadiar、XiandaiCar等，现在的类图如下，

ConcreteCarFactoryOne.java

package com.my.factory.concrete;

import com.my.factory.BiyadiCar;
import com.my.factory.ConcreteCar;
/**
 * 生产比亚迪汽车的工厂
 * @date 2022/5/8 16:17
 */
public class ConcreteCarFactoryOne extends ConcreteCarFactory {

    @Override public ConcreteCar productCar() {
        car = new BiyadiCar();
        car.setCode("1");
        car.setModel("byd");
        return car;
    }
}

ConcreteCarFactoryTwo.java

package com.my.factory.concrete;

import com.my.factory.ConcreteCar;
import com.my.factory.XiandaiCar;

/**
 * 生产现代汽车的工厂
 * @date 2022/5/8 16:42
 */
public class ConcreteCarFactoryTwo extends ConcreteCarFactory {
    @Override public ConcreteCar productCar() {
        car = new XiandaiCar();
        car.setCode("2");
        car.setModel("xiandai");
        return car;
    }
}

好了，两个工厂类已经完成了，分别生成比亚迪汽车和现代汽车，细心的小伙伴发现一个问题，这两个工厂都有productCar()方法，可不可以抽取出来，答案是必须抽出来，我这里抽取为抽象类，让ConcreteCarFactoryOne和ConcreteCarFactoryTwo分别进行实现，

ConcreteCarFactory.java

package com.my.factory.concrete;

import com.my.factory.ConcreteCar;

/**
 * 抽象工厂
 * @date 2022/5/8 16:46
 */
public abstract class ConcreteCarFactory {
    //要生产的汽车，由子类进行初始化
    protected ConcreteCar car;

    //由子类实现该方法
    protected abstract ConcreteCar productCar();

    //给汽车喷漆
    public void sprayPaint() {
        System.out.println("给--" + car + "--喷漆");
    }
}

ConcreteCarFactoryOne和ConcreteCarFactoryTwo的修改不再贴出，聪明的你肯定知道怎么改。

另外，对于汽车类这里也抽出了一个公共类，BiyadiCar和XiandaiCai会继承改类，

ConcreteCar.java

package com.my.factory;

/**
 * 汽车接口
 * @date 2022/5/8 16:21
 */
public class ConcreteCar {
    protected String code;
    protected String model;

    //省略get/set方法
}

BiyadiCar.java

package com.my.factory;

/**
 * 比亚迪汽车
 * @date 2022/5/8 16:18
 */
public class BiyadiCar extends ConcreteCar{
    @Override public String toString() {
        return "BiyadiCar{" + "code='" + code + '\'' + ", model='" + model + '\'' + '}';
    }
}

XiandaiCar这里就不再给出类似的代码。

下面看下测试类，

TestConcreteCarFactory.java

package com.my.factory.concrete;

import com.my.factory.ConcreteCar;

/**
 * 测试类
 * @date 2022/5/8 16:57
 */
public class TestConcreteCarFactory {
    public static void main(String[] args) {
        ConcreteCarFactory biyadaCarFactory = new ConcreteCarFactoryOne();
        ConcreteCar biyadiCar = biyadaCarFactory.productCar();
        biyadaCarFactory.sprayPaint();

        ConcreteCarFactory xiandaiCarFactory = new ConcreteCarFactoryTwo();
        ConcreteCar xiandaiCar = xiandaiCarFactory.productCar();
        xiandaiCarFactory.sprayPaint();
    }
}

测试结果可以看到创建了两个不同的汽车

给--BiyadiCar{code='1', model='byd'}--喷漆
给--XiandaiCar{code='2', model='xiandai'}--喷漆

其UML图如下

上面便是工厂模式的工厂方法模式的实现，《Head frist 设计模式》一书中对此模式给出的释义是

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

从上面的UML图中可以很好的理解上面的话，”一个创建对象的接口“这里指的不但但是interface，在本例中定义的则是一个抽象方法。同时类的实例化是在具体的子类中实现的，到底要实例化什么样的类则要根据相应的工厂来决定。

2.2、抽象工厂模式

  前面我们创建了两个工厂，都是用来生产汽车的，唯一的区别是生产的汽车是不一样的。现在有这样的场景，一个工厂仅生产汽车太浪费资源了，现在新能源是发展的趋势，每个工厂再上一条生产线生产电池吧，为此，上面的工厂需要提供一个接口来生产汽车和电池，这次我们不使用抽象类了，使用接口，

package com.my.factory.concrete.factory;

import com.my.factory.Battery;
import com.my.factory.ConcreteCar;

/**
 * 生产汽车和电池的接口
 * @date 2022/5/8 18:46
 */
public interface ConcreteFactory {
    //生产汽车
    ConcreteCar productCar();
    //生产电池
    Battery productBattery();
}

上面的接口中有两个方法一个生产汽车一个生产电池，相应的实现类也必须实现这两个方法。这种一个接口中包含多个生成实例的模式称为”抽象工厂模式“，《Head first 设计模式》一书中给出的释义是，

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

该释义说的很清楚，注意”家族“二字，说的就是包含一个以上的方法，后续”不需要明确指定具体类“，则是要在具体使用的时候选择合适的实现即可。

三、追寻源码

3.1、mybatis中的SqlSessionFactory

在mybatis中的SqlSessionFactory，便是工厂模式的一种体现，更确切的说是抽象工厂模式，

在SqlSessionFactory中有openSession方法，且该方法有多个重载，并且还有一个getConfiguration方法，下面看起具体的实现类，

共有两个实现分别是DefaultSqlSessionFactory和SqlSessionManager，看下openSession()方法在DefaultSqlSesssionFactory中的实现

最终返回的是一个SqlSession的实现DefaultSqlSession，和上面的工厂模式的UML神奇的类似。

3.2、Spring中的BeanFactory

在spring中有BeanFactory接口，

可以看到该接口中有getBean、getType、getAliases方法，这些都可以作为抽象工厂的证据，小伙伴们说了还有isSingleton、containsBean方法，这些我们说不能作为工厂模式的证据，因为，工厂模式的定义是要生成实例，也就是说工厂模式要创建并返回一个类的实例，而isSingleton、containsBean没有创建实例。看下该接口的实现

在其实现中有AbstractBeanFactory实现，其getBean方法的一个实现如下，

  由于spring实现的太复杂，这里不再详述。有小伙伴会问没看到在实现中有new啊，的确没有，在spring的实现中是通过反射的方式创建的，我们说生成类的实例不仅只有new的方式，工厂模式的关键在于生成类的实例，而不在于如何生成。

 

四、总结

  总结下工厂模式的要点，

  1、工厂模式分为简单工厂、简单静态工厂、工厂方法、抽象工厂四种不同的实现；

  2、工厂模式的使用原则在于如何创建类的实例，可以使用new，也可以使用反射、反序列化等方式；

  3、工厂模式摆脱了使用者传统的new的方式，让对象的创建集中在一处，对设计进行了解耦，让使用者不必关心创建对象的细节，只需使用接口；

 

  今天的分享就到这里了，小伙伴们回想下文章开头提的几个问题都有答案了么，没有的话多读几遍哦。