略懂设计模式之工厂模式

前言

工厂模式应该是大家的老朋友了，相信很多朋友在学习和工作中一定遇到过，但是不一定很了解，这篇文章将通过几个例子，带大家一起进一步了解工厂模式。

简介

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式 ，它提供了一种创建对象的最佳方式。

在创建型模式中工厂模式是比较重要的一种，之所以名称中包含“工厂”二字，是因为用工厂代替了 new 操作，将对象实例化的过程交给工厂来实现。

工厂模式关心的是最终创建的对象, 而不关心创建的过程。举个例子，好比您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

工厂模式可以分为三类：

简单工厂模式 （Simple Factory）
工厂方法模式 （Factory Method）
抽象工厂模式 （Abstract Factory）

其中简单工厂模式并不属于23种 GOF 设计模式之一，而是将其看作工厂方法模式的一种特例，两者归为一类。

简单工厂模式

简单工厂模式又叫静态工厂模式，由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（继承自一个父类或接口）的实例。

简单工厂模式的主要组成：

工厂（Factory）：负责实现创建所有实例的内部逻辑，并提供一个外界调用的方法，创建所需的产品对象

抽象产品（Product）：负责描述产品的公共接口

具体产品（ConcreteProduct）：描述生产的具体产品

这里我们就以生产汽车为例：

首先定义产品，先想好要生产什么：

// 汽车基类
public abstract class Car {
    // 输出汽车信息
    public abstract void printInfo();
}

// 比亚迪汽车
public class BydCar extends Car{
    @Override
    public void printInfo() {
        System.out.println("这是比亚迪汽车");
    }
}

// 吉利汽车
public class GeelyCar extends Car{
    @Override
    public void printInfo() {
        System.out.println("这是吉利汽车");
    }
}

然后定义工厂类，想好生产什么产品之后，就要建工厂了：

// 汽车工厂类
public class CarFactory {
    // 生产汽车
    public static Car productionCar(String brand) {
        if ("geely".equals(brand)) {
            return new GeelyCar();
        } else if ("byd".equals(brand)) {
            return new BydCar();
        } else {
            return null;
        }
    }
}

工厂建好了，有了比亚迪和吉利两条生产线，就可以大胆生产汽车了：

public class FactoryPatternDemo {
    public static void main(String[] args) {
        Car car = CarFactory.productionCar("byd");
        car.printInfo();
    }
}
// 输出：这是比亚迪汽车

是不是很简单，这时候可能有朋友就要问了，那我想要红旗汽车怎么办，还得再创建一个红旗汽车类，然后修改工厂类的判断逻辑，显然这是违背开闭原则的。

那么可不可以不修改工厂类里的逻辑呢？

当然可以，还有一种方式是通过反射来创建具体的产品，我们熟悉的 Spring 的 BeanFactory 就是采用反射的方式实现的。

还是汽车工厂类，我们修改一下代码：

public class CarFactory {
    public static Car productionCar(Class c){
        Car car = null;
        try {
            car = (Car) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return car;
    }
}

反射的方式看起来代码简洁多了是吧，但是某些情况下并不合适，而且反射对程序性能也会有影响。

简单工厂模式适用于业务简单的情况下，而对于复杂的业务环境可能就不太适用了。这个时候就要工厂方法模式登场了。

工厂方法模式

在简单工厂模式中，工厂负责所有产品的生产，就像上面例子中，一个汽车工厂负责所有汽车的生产。而工厂方法模式则是将工厂类抽象化，把生成具体产品的任务分发给继承抽象方法的具体的产品工厂。

工厂方法模式的主要组成：

抽象工厂（Abstract Factory）：描述具体工厂的公共接口

具体工厂（ConcreteFactory）：描述具体工厂，创建产品的实例，供外界调用

抽象产品（Product）：负责描述产品的公共接口

具体产品（ConcreteProduct）：描述生产的具体产品

我们还是以生产汽车为例：

将简单工厂方法中的工厂类改为抽象工厂类，再创建具体工厂类来实现汽车的生产工作：

// 抽象汽车工厂类
public abstract class AbstractCarFactory {
    // 生产汽车
    abstract Car productionCar();
}

// 比亚迪汽车工厂
public class BydCarFactory extends AbstractCarFactory{
    @Override
    Car productionCar()
        return new BydCar();
    }
}

// 吉利汽车工厂
public class GeelyCarFactory extends AbstractCarFactory{
    @Override
    Car productionCar()
        return new GeelyCar();
    }
}

这下要生产什么品牌的汽车，就要交给具体的工厂了：

public class FactoryPatternDemo {
    public static void main(String[] args) {
        AbstractCarFactory factory = new BydCarFactory();
        Car car = factory.productionCar();
        car.printInfo();
    }
}
// 输出：这是比亚迪汽车

工厂方法模式看起来要比简单工厂模式更复杂一些，每增加一个新的产品就要增加一个工厂，但是他提高了系统的可扩展性和可维护性，完全符合开闭原则。

我们可能遇到的大部分业务需求使用工厂方法模式足以应付，但是凡事都有特殊情况。当产品种类更加复杂，存在产品族的时候，就要使用抽象工厂模式了。

抽象工厂模式

在介绍抽象工厂模式前，我们先了解下产品族是什么：位于不同产品等级结构中，功能相关联的产品组成的家族。

没有理解的话可以看下图：

图中，比亚迪的商务汽车和吉利的商务汽车都属于商务车产品族，运动车产品族同理。

抽象工厂模式提供了一种方式，可以将同一产品族的单独的工厂封装起来。它是三种工厂模式里面最为抽象、最具一般性的。

抽象工厂模式和工厂方法模式一样，都符合开闭原则。但是不同的是，工厂方法模式在增加一个具体产品的时候，都要增加对应的工厂。但是抽象工厂模式只有在新增一个类型的具体产品时才需要新增工厂。也就是说，工厂方法模式的一个工厂只能创建一个具体产品。而抽象工厂模式的一个工厂可以创建属于一类类型的多种具体产品。工厂创建产品的个数介于简单工厂模式和工厂方法模式之间。

抽象工厂模式的主要组成：

抽象工厂（AbstractFactory）：描述具体工厂的公共接口

具体工厂（ConcreteFactory）：描述具体工厂，创建产品的实例，供外界调用

抽象产品（族）（AbstractProduct）：描述抽象产品的公共接口

具体产品（ConcreteProduct）：描述具体产品的公共接口

同样以生产汽车为例：

创建商务汽车产品族和运动汽车产品族相关类：

// 商务汽车抽象类
public abstract class BusinessCar {
    public abstract void printInfo();
}

// 比亚迪商务汽车
public class BydBusinessCar extends BusinessCar{
    @Override
    public void printInfo() {
        System.out.println("这是比亚迪商务汽车");
    }
}

// 吉利商务汽车
public class GeelyBusinessCar extends BusinessCar{
    @Override
    public void printInfo(){
        System.out.println("这是吉利商务汽车");
    }
}

// 运动汽车抽象类
public abstract class SportCar {
    public abstract void printInfo();
}

// 比亚迪运动汽车
public class BydSportCar extends SportCar{
    @Override
    public void printInfo()
 {
        System.out.println("这是比亚迪运动汽车");
    }
}

// 吉利运动汽车
public class GeelySportCar extends SportCar{
    @Override
    public void printInfo()
{
        System.out.println("这是吉利运动汽车");
    }
}

创建抽象工厂类和具体工厂类：

// 抽象汽车工厂类
public abstract class AbstractCarFactory {
    // 生产商务汽车
    abstract BusinessCar productionBusinessCar();
    // 生产运动汽车
    abstract SportCar productionSportCar();
}

// 比亚迪汽车工厂
public class BydCarFactory extends AbstractCarFactory{
    @Override
    public BusinessCar productionBusiness() {
        return new BydBusinessCar();
    }
    
    @Override
    public SportCar productionSport() {
        return new BydSportCar();
    }
}

// 吉利汽车工厂
public class GeelyCarFactory extends AbstractCarFactory{
    @Override
    public BusinessCar productionBusiness() {
        return new GeelyBusinessCar();
    }
    
    @Override
    public SportCar productionSport() {
        return new GeelySportCar();
    }
}

开始生产汽车：

public class FactoryPatternDemo {
    public static void main(String[] args) {
        AbstractCarFactory factory = new BydCarFactory();
        BusinessCar car = factory.BydBusinessCar();
        car.printInfo();
    }
}
// 输出：这是比亚迪商务汽车

抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。但是产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改，不能很好地支持开闭原则。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。