Chapter 2 工厂设计模式

1 概述

和单例设计模式一样，工厂设计模式也是属于创建型模式。其主要作用是抽象了对象被创建时的具体细节，对外暴露一个创建的方法，省去用户new一个对象的操作。乍一看，工厂设计模式只是抽象了一个new对象的操作。其实，实际项目中new一个对象的逻辑比较复杂，如果这个逻辑以后被修改了，那么之前new出来的所有对象的创建创建逻辑都会受到影响。那么将创建对象的过程统一到一些类工厂中（简单工厂模式只有一个工厂），就可以将改动的代码量降到最低。

工厂设计模式一般分为三种：简单工厂（Simple Factory）、工厂方法（Factory Method）以及抽象工厂（Abstract Factory）。

2 实现方式

2.1 简单工厂（Simple Factory）

简单工厂模式又叫静态工厂模式，是工厂模式三中状态中结构最为简单的。其主要有一个静态方法，该方法接受参数，并根据参数来决定返回实现同一接口的不同类的具体对象。为了更好的说明该模式的使用，这里用下面的例子进行说明：假设有一个汽车工厂，该工厂生产宝马和奔驰两种汽车。

首先抽象出一个共同的汽车接口（其实用抽象类也是可以的），并分别定义宝马和奔驰两个具体的都实现了该接口的汽车类：

interface Car {}

class BMW implements Car {

public BMW() {
System.out.println("A BMW is produced......");
}
}

class Benz implements Car {

public Benz() {
System.out.println("A Benz is produced......");
}
}然后定义一个简单工厂，提供一个静态方法，根据输入的汽车名生产具体的汽车：

class SimpleFactory {

public static Car create(String name) {
if ("BMW".equals(name)) {
return new BMW();
} else if ("Benz".equals(name)) {
return new Benz();
} else {
throw new IllegalArgumentException("输入的汽车名不合法!");
}
}
}最后可以在客户端进行测试：

public class SimpleFactoryDemo {
public static void main(String[] args) {
SimpleFactory.create("BMW");
SimpleFactory.create("Benz");
}
}

这里只是为了演示简单工厂模式，所以拿到创建后的对象以后并没有进行任何的操作。测试的输出如下：



从以上的代码可以看到，简单工厂模式的核心就是SimpleFactory对外暴露的create方法，用户只要将需要生产的产品名传给该方法就可以得到一个想要的产品对象。然而，简单工厂模式也有很多的缺点，例如，当有一个新的产品类型出现了，这个时候想要生产该产品则必须进入create内部修改逻辑，这不仅违背了“单一职责”原则，而且使得工厂类和产品类的耦合度变得很高，不利于系统扩展。

简单工厂设计模式的UML类图如下图所示：

2.2 工厂方法（Factory Method）

为了改善简单工厂模式的不足，又出现了工厂方法模式。该模式和简单工厂模式的不同在于不同的产品放在了不同的工厂中去生产了。还是以上面生产汽车的例子进行说明：

汽车相关类的定义不需要进行任何变动，而工厂类也抽象出了一个工厂接口，并定义了两个实现了该接口的工厂类，分别用于生产宝马和奔驰：

interface Factory {
Car create();
}

class BMWFactory implements Factory {

@Override
public Car create() {
return new BMW();
}
}

class BenzFactory implements Factory {

@Override
public Car create() {
return new Benz();
}
}

最后在客户端进行测试：

public class FactoryMethodDemo {
public static void main(String[] args) {
new BMWFactory().create();
new BenzFactory().create();
}
}

这样在新增了一种产品以后，只需要定义一个实现了工厂接口的共产类就可以生产该新的产品。并且，就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响。

工厂方法设计模式的UML类图如下图所示：

2.3 抽象工厂（Abstract Factory）

首先假设现在生产两种型号的汽车，即经典版和豪华版两种，那么可以抽象出这两种汽车的接口：

interface ClassicCar {}

interface LuxuryCar{}

然后还是以宝马和奔驰为例，假设这两种品牌的汽车都有经典版和豪华版两种型号，那么可以分别定义出具体的汽车实现类：

class ClassicBMW implements ClassicCar {

public ClassicBMW() {
System.out.println("classic BMW is produced......");
}
}

class LuxuryBMW implements LuxuryCar {

public LuxuryBMW() {
System.out.println("luxury BMW is produced......");
}
}

class ClassicBenz implements ClassicCar {

public ClassicBenz() {
System.out.println("classic Benz is produced......");
}
}

class LuxuryBenz implements LuxuryCar {

public LuxuryBenz() {
System.out.println("luxury Benz is produced......");
}
}

接着，抽象出一个汽车工厂接口，该接口有两个方法，分别对应生产经典版汽车和生产豪华版汽车的方法。而这个接口对应宝马和奔驰分别有两个具体的实现类，这两个具体的实现类中分别实现了生产经典版和豪华版两种汽车的方法：

interface Factory {

ClassicCar buildClassicCar();
LuxuryCar buildLuxuryCar();
}

class BMWFactory implements Factory {

@Override
public ClassicCar buildClassicCar() {
return new ClassicBMW();
}

@Override
public LuxuryCar buildLuxuryCar() {
return new LuxuryBMW();
}
}

class BenzFactory implements Factory {

@Override
public ClassicCar buildClassicCar() {
return new ClassicBenz();
}

@Override
public LuxuryCar buildLuxuryCar() {
return new LuxuryBenz();
}
}最后，编写客户端的测试程序：

public class AbstractFactoryDemo {
public static void main(String[] args) {
Factory bmwFactory = new BMWFactory();
bmwFactory.buildClassicCar();
bmwFactory.buildLuxuryCar();
Factory benzFactory = new BenzFactory();
benzFactory.buildClassicCar();
benzFactory.buildLuxuryCar();
}
}

抽象工厂设计模式的UML类图如下图所示：

3 总结

简单来说，工厂设计模式是提供一种方便的构建对象的实例，而让用户不用去关心构建过程中的细节和复杂过程。按照工厂和产品的抽象程度，工厂设计模式又可以分成简单工厂模式，工厂方法模式和抽象工厂模式三种，其中工厂方法模式在实际生产环境中应用最广泛。