06 GoF之工厂模式

设计模式：一种可以被重复利用的解决方案。
GoF（Gang of Four），中文名——四人组。
《Design Patterns: Elements of Reusable Object-Oriented Software》（即《设计模式》一书），1995 年由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著。这几位作者常被称为"四人组（Gang of Four）"。
该书中描述了 23 种设计模式。我们平常所说的设计模式就是指这 23 种设计模式。
不过除了 GoF 23 种设计模式之外，还有其它的设计模式，比如：JavaEE 的设计模式（DAO 模式、MVC 模式等）。
GoF 23 种设计模式可分为三大类：
- 创建型（5 个）：解决对象创建问题。
  - 单例模式
  - 工厂方法模式
  - 抽象工厂模式
  - 建造者模式
  - 原型模式
- 结构型（7 个）：一些类或对象组合在一起的经典结构。
  - 代理模式
  - 装饰模式
  - 适配器模式
  - 组合模式
  - 享元模式
  - 外观模式
  - 桥接模式
- 行为型（11 个）：解决类或对象之间的交互问题。
  - 策略模式
  - 模板方法模式
  - 责任链模式
  - 观察者模式
  - 迭代子模式
  - 命令模式
  - 备忘录模式
  - 状态模式
  - 访问者模式
  - 中介者模式
  - 解释器模式
工厂模式是解决对象创建问题的，所以工厂模式属于创建型设计模式。这里为什么学习工厂模式呢？这是因为 Spring 框架底层使用了大量的工厂模式。

6.1 工厂模式的三种形态¶

工厂模式通常有三种形态： - 第一种：简单工厂模式（Simple Factory）：不属于 23 种设计模式之一。简单工厂模式又叫做：静态工厂方法模式。简单工厂模式是工厂方法模式的一种特殊实现。 - 第二种：工厂方法模式（Factory Method）：是 23 种设计模式之一。 - 第三种：抽象工厂模式（Abstract Factory）：是 23 种设计模式之一。

6.2 简单工厂模式¶

简单工厂模式的角色包括三个： - 抽象产品角色 - 具体产品角色 - 工厂类角色简单工厂模式的代码如下：

抽象产品角色： ```java title:Weapon package com.powernode.factory;

/** * 武器（抽象产品角色） * @author 动力节点 * @version 1.0 * @className Weapon * @since 1.0 / public abstract class Weapon { /* * 所有的武器都有攻击行为 */ public abstract void attack(); }

具体产品角色：
```java title:Tank
package com.powernode.factory;

/**
 * 坦克（具体产品角色）
 * @author 动力节点
 * @version 1.0
 * @className Tank
 * @since 1.0
 */
public class Tank extends Weapon{
    @Override
    public void attack() {
        System.out.println("坦克开炮！");
    }
}

```java title:Fighter package com.powernode.factory;

/** * 战斗机（具体产品角色） * @author 动力节点 * @version 1.0 * @className Fighter * @since 1.0 */ public class Fighter extends Weapon{ @Override public void attack() { System.out.println("战斗机投下原子弹！"); } }

```java title:Dagger
package com.powernode.factory;

/**
 * 匕首（具体产品角色）
 * @author 动力节点
 * @version 1.0
 * @className Dagger
 * @since 1.0
 */
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("砍他丫的！");
    }
}

工厂类角色： ```java title:WeaponFactory package com.powernode.factory;

/** * 工厂类角色 * @author 动力节点 * @version 1.0 * @className WeaponFactory * @since 1.0 / public class WeaponFactory { /* * 根据不同的武器类型生产武器 * @param weaponType 武器类型 * @return 武器对象 */ public static Weapon get(String weaponType){ if (weaponType == null || weaponType.trim().length() == 0) { return null; } Weapon weapon = null; if ("TANK".equals(weaponType)) { weapon = new Tank(); } else if ("FIGHTER".equals(weaponType)) { weapon = new Fighter(); } else if ("DAGGER".equals(weaponType)) { weapon = new Dagger(); } else { throw new RuntimeException("不支持该武器！"); } return weapon; } }

测试程序（客户端程序）：
```java title:Client
package com.powernode.factory;

/**
 * @author 动力节点
 * @version 1.0
 * @className Client
 * @since 1.0
 */
public class Client {
    public static void main(String[] args) {
        Weapon weapon1 = WeaponFactory.get("TANK");
        weapon1.attack();

        Weapon weapon2 = WeaponFactory.get("FIGHTER");
        weapon2.attack();

        Weapon weapon3 = WeaponFactory.get("DAGGER");
        weapon3.attack();
    }
}

执行结果： ![[06.02-1.png]]

简单工厂模式的优点： - 客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。简单工厂模式的缺点： - 缺点 1：工厂类集中了所有产品的创造逻辑，形成一个无所不知的全能类，有人把它叫做上帝类。显然工厂类非常关键，不能出问题，一旦出问题，整个系统瘫痪。 - 缺点 2：不符合 OCP 开闭原则，在进行系统扩展时，需要修改工厂类。 Spring 中的 BeanFactory 就使用了简单工厂模式。

6.3 工厂方法模式¶

工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点。工厂方法模式的角色包括： - 抽象工厂角色 - 具体工厂角色 - 抽象产品角色 - 具体产品角色

代码如下： ```java title:Weapon package com.powernode.factory;

/** * 武器类（抽象产品角色） * @author 动力节点 * @version 1.0 * @className Weapon * @since 1.0 / public abstract class Weapon { /* * 所有武器都有攻击行为 */ public abstract void attack(); }

```java title:Gun
package com.powernode.factory;

/**
 * 具体产品角色
 * @author 动力节点
 * @version 1.0
 * @className Gun
 * @since 1.0
 */
public class Gun extends Weapon{
    @Override
    public void attack() {
        System.out.println("开枪射击！");
    }
}

```java title:Fighter package com.powernode.factory;

/** * 具体产品角色 * @author 动力节点 * @version 1.0 * @className Fighter * @since 1.0 */ public class Fighter extends Weapon{ @Override public void attack() { System.out.println("战斗机发射核弹！"); } }

```java title:WeaponFactory
package com.powernode.factory;

/**
 * 武器工厂接口(抽象工厂角色)
 * @author 动力节点
 * @version 1.0
 * @className WeaponFactory
 * @since 1.0
 */
public interface WeaponFactory {
    Weapon get();
}

```java title:GunFactory package com.powernode.factory;

/** * 具体工厂角色 * @author 动力节点 * @version 1.0 * @className GunFactory * @since 1.0 */ public class GunFactory implements WeaponFactory{ @Override public Weapon get() { return new Gun(); } }

```java title:FighterFactory
package com.powernode.factory;

/**
 * 具体工厂角色
 * @author 动力节点
 * @version 1.0
 * @className FighterFactory
 * @since 1.0
 */
public class FighterFactory implements WeaponFactory{
    @Override
    public Weapon get() {
        return new Fighter();
    }
}

客户端程序： ```java title:Client package com.powernode.factory;

/** * @author 动力节点 * @version 1.0 * @className Client * @since 1.0 */ public class Client { public static void main(String[] args) { WeaponFactory factory = new GunFactory(); Weapon weapon = factory.get(); weapon.attack();

    WeaponFactory factory1 = new FighterFactory();
    Weapon weapon1 = factory1.get();
    weapon1.attack();
}

} 执行客户端程序： ![[06.03-1.png]] 如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，例如新增：匕首java title:Dagger package com.powernode.factory; /** * @author 动力节点 * @version 1.0 * @className Dagger * @since 1.0 */ public class Dagger extends Weapon{ @Override public void attack() { System.out.println("砍丫的！"); } } ```

```java title:DaggerFactory package com.powernode.factory;

/** * @author 动力节点 * @version 1.0 * @className DaggerFactory * @since 1.0 */ public class DaggerFactory implements WeaponFactory{ @Override public Weapon get() { return new Dagger(); } }

客户端程序：
```java title:Client
package com.powernode.factory;

/**
 * @author 动力节点
 * @version 1.0
 * @className Client
 * @since 1.0
 */
public class Client {
    public static void main(String[] args) {
        WeaponFactory factory = new GunFactory();
        Weapon weapon = factory.get();
        weapon.attack();

        WeaponFactory factory1 = new FighterFactory();
        Weapon weapon1 = factory1.get();
        weapon1.attack();

        WeaponFactory factory2 = new DaggerFactory();
        Weapon weapon2 = factory2.get();
        weapon2.attack();
    }
}

执行结果如下： ![[06.03-2.png]]

我们可以看到在进行功能扩展的时候，不需要修改之前的源代码，显然工厂方法模式符合 OCP 原则。

工厂方法模式的优点： - 一个调用者想创建一个对象，只要知道其名称就可以了。 - 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 - 屏蔽产品的具体实现，调用者只关心产品的接口。工厂方法模式的缺点： - 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

6.4 抽象工厂模式（了解）¶

抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。

抽象工厂模式特点：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。

抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。它有多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，一个抽象工厂类，可以派生出多个具体工厂类，每个具体工厂类可以创建多个具体产品类的实例。

每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。

抽象工厂中包含 4 个角色： - 抽象工厂角色 - 具体工厂角色 - 抽象产品角色 - 具体产品角色抽象工厂模式的类图如下： ![[06.04-1.png]]

抽象工厂模式代码如下：

第一部分：武器产品族 ```java title:Weapon package com.powernode.product;

/** * 武器产品族 * @author 动力节点 * @version 1.0 * @className Weapon * @since 1.0 */ public abstract class Weapon { public abstract void attack(); }

```java title:Gun
package com.powernode.product;

/**
 * 武器产品族中的产品等级1
 * @author 动力节点
 * @version 1.0
 * @className Gun
 * @since 1.0
 */
public class Gun extends Weapon{
    @Override
    public void attack() {
        System.out.println("开枪射击！");
    }
}

```java title:Dagger package com.powernode.product;

/** * 武器产品族中的产品等级2 * @author 动力节点 * @version 1.0 * @className Dagger * @since 1.0 */ public class Dagger extends Weapon{ @Override public void attack() { System.out.println("砍丫的！"); } }

第二部分：水果产品族
```java title:Fruit
package com.powernode.product;

/**
 * 水果产品族
 * @author 动力节点
 * @version 1.0
 * @className Fruit
 * @since 1.0
 */
public abstract class Fruit {
    /**
     * 所有果实都有一个成熟周期。
     */
    public abstract void ripeCycle();
}

```java title:Orange package com.powernode.product;

/** * 水果产品族中的产品等级1 * @author 动力节点 * @version 1.0 * @className Orange * @since 1.0 */ public class Orange extends Fruit{ @Override public void ripeCycle() { System.out.println("橘子的成熟周期是10个月"); } }

```java title:Apple
package com.powernode.product;

/**
 * 水果产品族中的产品等级2
 * @author 动力节点
 * @version 1.0
 * @className Apple
 * @since 1.0
 */
public class Apple extends Fruit{
    @Override
    public void ripeCycle() {
        System.out.println("苹果的成熟周期是8个月");
    }
}

第三部分：抽象工厂类 ```java title:AbstractFactory package com.powernode.factory;

import com.powernode.product.Fruit; import com.powernode.product.Weapon;

/** * 抽象工厂 * @author 动力节点 * @version 1.0 * @className AbstractFactory * @since 1.0 */ public abstract class AbstractFactory { public abstract Weapon getWeapon(String type); public abstract Fruit getFruit(String type); }

第四部分：具体工厂类
```java title:WeaponFactory
package com.powernode.factory;

import com.powernode.product.Dagger;
import com.powernode.product.Fruit;
import com.powernode.product.Gun;
import com.powernode.product.Weapon;

/**
 * 武器族工厂
 * @author 动力节点
 * @version 1.0
 * @className WeaponFactory
 * @since 1.0
 */
public class WeaponFactory extends AbstractFactory{

    public Weapon getWeapon(String type){
        if (type == null || type.trim().length() == 0) {
            return null;
        }
        if ("Gun".equals(type)) {
            return new Gun();
        } else if ("Dagger".equals(type)) {
            return new Dagger();
        } else {
            throw new RuntimeException("无法生产该武器");
        }
    }

    @Override
    public Fruit getFruit(String type) {
        return null;
    }
}

```java title:FruitFactory package com.powernode.factory;

import com.powernode.product.*;

/** * 水果族工厂 * @author 动力节点 * @version 1.0 * @className FruitFactory * @since 1.0 */ public class FruitFactory extends AbstractFactory{ @Override public Weapon getWeapon(String type) { return null; }

public Fruit getFruit(String type){
    if (type == null || type.trim().length() == 0) {
        return null;
    }
    if ("Orange".equals(type)) {
        return new Orange();
    } else if ("Apple".equals(type)) {
        return new Apple();
    } else {
        throw new RuntimeException("我家果园不产这种水果");
    }
}

} 第五部分：客户端程序java title:Client package com.powernode.client; import com.powernode.factory.AbstractFactory; import com.powernode.factory.FruitFactory; import com.powernode.factory.WeaponFactory; import com.powernode.product.Fruit; import com.powernode.product.Weapon; /** * @author 动力节点 * @version 1.0 * @className Client * @since 1.0 */ public class Client { public static void main(String[] args) { // 客户端调用方法时只面向AbstractFactory调用方法。 AbstractFactory factory = new WeaponFactory(); // 注意：这里的new WeaponFactory()可以采用简单工厂模式进行隐藏。 Weapon gun = factory.getWeapon("Gun"); Weapon dagger = factory.getWeapon("Dagger"); gun.attack(); dagger.attack(); AbstractFactory factory1 = new FruitFactory(); // 注意：这里的new FruitFactory()可以采用简单工厂模式进行隐藏。 Fruit orange = factory1.getFruit("Orange"); Fruit apple = factory1.getFruit("Apple"); orange.ripeCycle(); apple.ripeCycle(); } } ```

执行结果： ![[06.04-2.png]] 抽象工厂模式的优缺点： - 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。 - 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在 AbstractFactory 里加代码，又要在具体的里面加代码。