抽象工厂

使用工厂方法模式足以应付我们可能遇到的大部分业务需求。

但是当产品种类非常多时，就会出现 大量的与之对应的工厂类，这不应该是我们所希望的。所以建议在这种情况下使用简单工厂模式与工厂 方法模式相结合的方式来减少工厂类：

即

• 对于产品树上类似的种类(一般是树的叶子中互为兄弟的)使用简单工厂模式来实现
• 如果产品树上涉及多个产品族，则可以使用抽象工厂模式

下面我们来详细看一下抽象工厂：

概念

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

首先我们要理解产品族和产品等级：

• 产品族：一个品牌下面的所有产品；例如奥迪下面的商务型、MINI型称为华为的产品族；

• 产品等级：多个品牌下面的同种产品；例如奥迪和宝马下面的各种商务车型，称为一个产品等级；

抽象工厂模式的各个角色和工厂方法的如出一辙：

优缺点

优点

抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展

缺点

抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这就违背了"开闭原则"。

适用场景

使用抽象工厂模式的系统应该符合以下几个条件:

• 一个系统不要求依赖产品实例如何被创建、组合和表达
• 这个系统有多个系列产品，而系统中只消费其中某一系列产品
• 系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现

下面我们实现一个案例来分析一下

代码案例

以生产不同厂牌生产不同车型为例子：

• 有商务车和MINI型车 两种产品，定义两个接口；
• 奔驰、奥迪、宝马都可以生产这两种产品，所以有6（2*3）个实现类；
• 现在需要创建奔驰、奥迪、宝马的工厂类，先将工厂类进行抽象，里面有创建两个产品的方法，返回的是产品的接口类；
• 创建奔驰、奥迪、宝马的工厂实现类，继承工厂类接口，实现创建各自产品的方法；
• 客户端调用时，直接用工厂接口类创建需要的工厂，拿到对应的型号的产品；

类图分析：

代码如下：

商务车抽象产品族：BusinessCar

package com.shixun.design.factory.abstract_factory;

import com.shixun.design.factory.Car;

/**
 * 抽象产品族（BusinessCar）
 */
public interface BusinessCar extends Car {
    boolean isAutoDoor();
}

1
2
3
4
5
6
7
8
9
10
11

MINI车抽象产品族：SportCar

package com.shixun.design.factory.abstract_factory;

import com.shixun.design.factory.Car;

/**
 * 抽象产品族（SportCar）
 */
public interface SportCar extends Car {
    boolean isStrong();
}

1
2
3
4
5
6
7
8
9
10
11

AodiBusinessCar

package com.shixun.design.factory.abstract_factory;

/**
 * 新业务奥迪商务汽车
 */
public class AodiBusinessCar implements BusinessCar {
    @Override
    public boolean isAutoDoor() {
        return false;
    }

    @Override
    public void show() {
        System.out.println("我是Aodi的商务汽车");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

AodiSportCar

package com.shixun.design.factory.abstract_factory;

/**
 * 新业务奥迪运动汽车
 */
public class AodiSportCar implements SportCar {
    @Override
    public boolean isStrong() {
        return false;
    }

    @Override
    public void show() {
        System.out.println("我是Aodi的运动汽车");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

BenzBusinessCar

package com.shixun.design.factory.abstract_factory;

/**
 * 具体产品(BenzBusinessCar)
 */
public class BenzBusinessCar implements BusinessCar {
    @Override
    public boolean isAutoDoor() {
        return true;
    }

    @Override
    public void show() {
        System.out.println("我是Benz的商务汽车");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

BenzSportCar

package com.shixun.design.factory.abstract_factory;

/**
 * 具体产品(BenzSportCar)
 */
public class BenzSportCar implements SportCar {
    @Override
    public boolean isStrong() {
        return true;
    }

    @Override
    public void show() {
        System.out.println("我是Benz的运动汽车");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

BmwBusinessCar

package com.shixun.design.factory.abstract_factory;

/**
 * 具体产品(BmwBusinessCar)
 */
public class BmwBusinessCar implements BusinessCar {
    @Override
    public boolean isAutoDoor() {
        return true;
    }

    @Override
    public void show() {
        System.out.println("我是Bmw的商务汽车");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

BmwSportCar

package com.shixun.design.factory.abstract_factory;

/**
 * 具体产品(BmwSportCar)
 */
public class BmwSportCar implements SportCar {
    @Override
    public boolean isStrong() {
        return true;
    }

    @Override
    public void show() {
        System.out.println("我是Bmw的运动汽车");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

生产的抽象工厂：CarFactory

定义两个接口方法：

• 生产商务车
• 生产MINI车

package com.shixun.design.factory.abstract_factory;

/**
 * 抽象工厂
 */
public interface CarFactory {
    /**
     * 生产运动汽车
     *
     * @return
     */
    SportCar produceSportCar();

    /**
     * 生产商务汽车
     *
     * @return
     */
    BusinessCar produceBusinessCar();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

AodiCarFactory

package com.shixun.design.factory.abstract_factory;

/**
 * 新业务工厂AodiCarFactory
 */
public class AodiCarFactory implements CarFactory {
    @Override
    public SportCar produceSportCar() {
        return new AodiSportCar();
    }

    @Override
    public BusinessCar produceBusinessCar() {
        return new AodiBusinessCar();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

BmwCarFactory

package com.shixun.design.factory.abstract_factory;

/**
 * 具体工厂(BenzCarFactory)
 */
public class BenzCarFactory implements CarFactory {
    @Override
    public SportCar produceSportCar() {
        return new BenzSportCar();
    }

    @Override
    public BusinessCar produceBusinessCar() {
        return new BenzBusinessCar();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

BenzCarFactory

package com.shixun.design.factory.abstract_factory;

/**
 * 具体工厂(BmwCarFactory)
 */
public class BmwCarFactory implements CarFactory {
    @Override
    public SportCar produceSportCar() {
        return new BmwSportCar();
    }

    @Override
    public BusinessCar produceBusinessCar() {
        return new BmwBusinessCar();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

编写测试类:

package com.shixun.design.factory.abstract_factory;

/**
 * 使用者
 */
public class Test {
    public static void main(String[] args) {
        //生产Bmw
        BmwCarFactory bmwCarFactory = new BmwCarFactory();
        //宝马运动
        SportCar bmwSportCar = bmwCarFactory.produceSportCar();
        System.out.println("宝马运动strong:" + bmwSportCar.isStrong());
        bmwSportCar.show();
        //宝马商务
        BusinessCar bmwBusinessCar = bmwCarFactory.produceBusinessCar();
        System.out.println("宝马商务autoDoor:" + bmwBusinessCar.isAutoDoor());
        bmwBusinessCar.show();
        //生产Benz
        BenzCarFactory benzCarFactory = new BenzCarFactory();
        //奔驰运动
        SportCar benzSportCar = benzCarFactory.produceSportCar();
        System.out.println("奔驰运动strong:" + benzSportCar.isStrong());
        benzSportCar.show();
        //奔驰商务
        BusinessCar benzBusinessCar = benzCarFactory.produceBusinessCar();
        System.out.println("奔驰自动autoDoor:" + benzBusinessCar.isAutoDoor());
        benzBusinessCar.show();

        //新业务
        //生产Aodi
        AodiCarFactory aodiCarFactory = new AodiCarFactory();
        //奥迪运动
        SportCar aodiSportCar = aodiCarFactory.produceSportCar();
        System.out.println("奥迪运动strong:" + aodiSportCar.isStrong());
        aodiSportCar.show();
        //奥迪商务
        BusinessCar aodiBusinessCar = aodiCarFactory.produceBusinessCar();
        System.out.println("奥迪自动autoDoor:" + aodiBusinessCar.isAutoDoor());
        aodiBusinessCar.show();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

运行结果如下：