这一讲的内容是Builder生成器模式
先看看Builder模式的动机
在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。
对比一下抽象工厂的动机:在软件系统中,经常面临着"一系列相互依赖的对象"的创建工作;同时,由于需求的变化,往往存在更多系列对象的创建工作。如何应对这种变化?如何绕过常规的对象创建方法(new),提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合。
抽象工厂面对的是一系列相互依赖的对象的创建工作,而Builder模式面对的是一个复杂对象的创建工作,这个复杂对象的创建工作中使用的类型经常面临着剧烈的变化,但是算法相对稳定。
Builder模式的意图:将一个复杂对象的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。
抽象工厂的意图:提供一个接口,让该接口负责创建一系列"相关或者相互依赖的对象",无需指定它们具体的类。
下面通过Builder模式的代码来表现Builder模式。
首先我们有一个Builder的抽象基类,规定这个Builder产生的各种对象。这个Build可以产生Door、Wall、Window、Floor、HouseCelling等。
public abstract class Builder
{
public abstract void BuildDoor();
public abstract void BuildWall();
public abstract void BuildWindow();
public abstract void BuildFloor();
public abstract void BuildHouseCelling();
public abstract House GetHouse();
}
那么我们知道这个抽象基类是稳定的。
public abstract class Door
{
}
public abstract class Wall
{
}
public abstract class Window
{
}
public abstract class Floor
{
}
public abstract class HouseCelling
{
}
public abstract class House
{
}
public class GameManager
{
public static House CreateHouse(Builder builder)
{
builder.BuildDoor();
builder.BuildDoor();
builder.BuildWall();
builder.BuildWall();
builder.BuildWindow();
builder.BuildWindow();
builder.BuildFloor();
builder.BuildHouseCelling();
return builder.GetHouse();
}
}
public class RomanHouse : House
{
}
public class RomanDoor : Door
{
}
public class RomanWall : Wall
{
}
public class RomanWindow : Window
{
}
public class RomanFloor : Floor
{
}
public class RomanHouseCelling : HouseCelling
{
}
public class RomanHouseBuilder : Builder
{
public override void BuildDoor()
{
}
public override void BuildWall()
{
}
public override void BuildWindow()
{
}
public override void BuildFloor()
{
}
public override void BuildHouseCelling()
{
}
public override House GetHouse()
{
}
}
那么我们的变化就在这个Builder的派生类RomanBuilder类和具体实现window、wall等类中。我们可以让RomanBuilder类中的各个方法产生不同的Window、Floor,不一定是一样的风格比如BuildWindow可以使用RomanWindow,但BuildDoor产生的是ChineseDoor。
客户端调用
{
House house = GameManager.CreateHouse(new RomanHouseBuilder());
}
static void Main(string[] args)
{
string assemblyName = ConfigrationSettings["BuildAssembly"];
string builderName = ConfigrationSettings["BuildClass"];
Assembly assembly = Assembly.Load(assemblyName);
Type t = assembly.GetType(builderName);
Builder builder = Activator.CreateInstance(t);
House house = GameManager.CreateHouse(builder);
}
public void BuildGameFacilites()
{
Road road = faciliesFactory.CreateRoad();
Building building = faciliesFactory.CreateBuilding();
Tunnel tunnel = faciliesFactory.CreateTunnel();
Jungle jungle = faciliesFactory.CreateJungle();
}
public static House CreateHouse(Builder builder)
{
builder.BuildDoor();
builder.BuildDoor();
builder.BuildWall();
builder.BuildWall();
builder.BuildWindow();
builder.BuildWindow();
builder.BuildFloor();
builder.BuildHouseCelling();
return builder.GetHouse();
}
Builder 模式的几个要点
- Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法,而复杂对象的各个部分则经常变化。
- 变化点在哪里,封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。也就是说CreateHouse方法变动频繁,Builder模式就不是很适用了。
- Abstract Factory模式解决“系列对象”的需求变化,Builder模式解决“对象部分”的需求变化。Builder模式通常和Composite模式组合使用。