软件体系结构-抽象工厂模式

定义

工厂方法模式中，每个具体工厂只有一个或者一组重载的工厂方法，只能生产一种产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。

抽象工厂模式中，一个工厂可以生产一系列产品（一族产品），极大减少了工厂类的数量

UML类图

应用实例：

更换产品族只需要修改配置文件

代码

抽象产品Map

1
2
3
public abstract class Map {
    public abstract void loadMap();
}

具体产品MapA

1
2
3
4
5
6
7
public class MapA extends Map{

    @Override
    public void loadMap() {
        System.out.println("load map A");
    }
}

抽象产品Sound

1
2
3
public abstract class Sound {
    public abstract void loadSound();
}

具体产品SoundA

1
2
3
4
5
6
7
public class SoundA extends Sound{

    @Override
    public void loadSound() {
        System.out.println("play sound A");
    }
}

抽象工厂

1
2
3
4
5
public abstract class SceneFactory {
    public abstract Map createMap();
    public abstract Sound createSound();
    public abstract Weather createWeather();
}

产品族A具体工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SceneAFactory extends SceneFactory{

    @Override
    public Map createMap() {
        return new MapA();
    }

    @Override
    public Sound createSound() {
        return new SoundA();
    }

    @Override
    public Weather createWeather() {
        return new WeatherA();
    }
}

客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Client {
    public static void main(String[] args) {
        SceneFactory sceneFactory = new SceneAFactory();
        Map map = sceneFactory.createMap();
        Sound sound = sceneFactory.createSound();
        Weather weather = sceneFactory.createWeather();

        map.loadMap();
        sound.loadSound();
        weather.loadWeather();

    }
}

优点

  • 隔离了具体类的生成，使得客户端并不需要知道什么被创建
  • 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象
  • 增加新的产品族很方便，无须修改已有系统，符合开闭原则

缺点

  • 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了开闭原则（开闭原则的倾斜性）

适用

  • 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节
  • 系统中有多于一个的产品族，但每次只使用其中某一产品族
  • 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来
  • 产品等级结构稳定，在设计完成之后不会向系统中增加新的产品等级结构或者删除已有的产品等级结构