目录
- 建造者模式概述
- 建造者模式的结构与实现
- 建造者模式的应用实例
- 指挥者类的深入讨论
- 建造者模式的优缺点与适用环境
建造者模式概述
复杂对象:如何将汽车的各个复杂部件组装成一辆完整的汽车并返回给用户?
建造者模式可以将部件本身和它们的组装过程分开,关注如何一步步创建一个包含多个组成部分的复杂对象,用户只需要指定复杂对象的类型即可得到该对象,而无须知道其内部的具体构造细节。
建造者模式定义
- 建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
- Builder Pattern: Separate the construction of a complex object from its representation so that the same construction process can create different representations.
- 对象创建型模式
注:将客户端与包含多个部件的复杂对象的创建过程分离,客户端无须知道复杂对象的内部组成部分与装配方式,只需要知道所需建造者的类型即可。注如何逐步创建一个复杂的对象,不同的建造者定义了不同的创建过程。
建造者模式的结构与实现
建造者模式的结构
建造者模式包含以下4个角色:
- Builder(抽象建造者)
抽象建造者为创建一个产品Product对象的各个部件指定抽象接口,在该接口中一般声明两类方法,一类方法是buildPartX(),它们用于创建复杂对象的各个部件。另一类方法是getResult(),它们用于返回复杂对象。它既可以是抽象类也可以是接口。
- ConcreteBuilder(具体建造者)
具体建造者实现Builder接口,实现各个部件的构造和装配方法,定义并明确它所创建的复杂对象,也可以提供一个方法返回创建好的复杂产品对象。
- Product(产品)
产品角色是被创建的复杂对象,包含多个组成部件,具体建造者创建产品的内部表示并定义它的装配过程。
- Director(指挥者)
指挥者又叫导演类,他负责安排复杂对象的建造次序,指挥着与抽象建造者之间存在关联关系,可以在其construct建造方法中调用建造者对象的部件构造与装配方法,完成复杂对象的建造。客户端一般只需要与指挥者进行交互,在客户端确定具体建造者的类型,并实例化具体建造者对象(也可以通过配置文件或反射机制),然后通过指挥者类的构造函数或者set方法将该对象传入指挥者类中。
经典建造者模式的实现
复杂对象类Product:
/**
* Created by yitian.z on 2016/4/13.
*
* 复杂产品类
*/
public class Product {
/**
* 复杂对象组成A
*/
private String partA;
/**
* 复杂对象组成B
*/
private String partB;
/**
* 复杂对象组成C
*/
private String partC;
public String getPartA() {
return partA;
}
public void setPartA(String partA) {
this.partA = partA;
}
public String getPartB() {
return partB;
}
public void setPartB(String partB) {
this.partB = partB;
}
public String getPartC() {
return partC;
}
public void setPartC(String partC) {
this.partC = partC;
}
}
抽象建造者类Builder:
/**
* Created by yitian.z on 2016/4/13.
*
* 抽象建造者,可以为抽象类也可以是接口
*/
public abstract class Builder {
/**
* 抽象建造者,所要创建的product对象
*/
protected Product product = new Product();
/**
* 抽象建造方法
*/
public abstract void buildPartA();
public abstract void buildPartB();
public abstract void buildPartC();
/**
* 工厂方法,用于返回一个创建好的完整对象
* @return
*/
public Product getResult() {
return product;
}
}
具体建造者类ConcreteBuilder:
/**
* Created by yitian.z on 2016/4/13.
*
* 具体建造者类
*/
public class ConcreteBuilder extends Builder {
@Override
public void buildPartA() {
System.out.println("Building Part A...");
}
@Override
public void buildPartB() {
System.out.println("Building Part B...");
}
@Override
public void buildPartC() {
System.out.println("Building Part C...");
}
// public Product getResult() {
// return product;
// }
}
指挥者类Director:
/**
* Created by yitian.z on 2016/4/13.
*
* 指挥者类
*/
public class Director {
private Builder builder;
/**
* 构造函数
* @param builder
*/
public Director(Builder builder) {
this.builder = builder;
}
/**
* ???
* @param builder
*/
public void setBuilder(Builder builder) {
this.builder = builder;
}
public Product construct() {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
return builder.getResult();
}
}
客户端类Client:
public class Client {
public static void main(String[] args) throws SAXException, IllegalAccessException, IOException, InstantiationException, ParserConfigurationException, ClassNotFoundException {
Builder builder = (Builder) XMLUtil.getBean();
Director director = new Director(builder);
Product product = director.construct();
}
}
建造者模式的应用实例
某游戏软件公司决定开发一款基于角色扮演的多人在线网络游戏,玩家可以在游戏中扮演虚拟世界中的一个特定角色,角色根据不同的游戏情节和统计数据(例如力量、魔法、技能等)具有不同的能力,角色也会随着不断升级而拥有更加强大的能力。
作为该游戏的一个重要组成部分,需要对游戏角色进行设计,而且随着该游戏的升级将不断增加新的角色。通过分析发现,游戏角色是一个复杂对象,它包含性别、面容等多个组成部分,不同类型的游戏角色,其性别、面容、服装、发型等外部特性都有所差异,例如“天使”拥有美丽的面容和披肩的长发,并身穿一袭白裙;而“恶魔”极其丑陋,留着光头并穿一件刺眼的黑衣。
无论是何种造型的游戏角色,它的创建步骤都大同小异,都需要逐步创建其组成部分,再将各组成部分装配成一个完整的游戏角色。现使用建造者模式来实现游戏角色的创建。
实例类图:
实例代码:
-
(1) Actor:游戏角色类,充当复杂产品对象
-
(2) ActorBuilder:游戏角色建造者,充当抽象建造者
-
(3) HeroBuilder:英雄角色建造者,充当具体建造者
-
(4) AngelBuilder:天使角色建造者,充当具体建造者
-
(5) DevilBuilder:恶魔角色建造者,充当具体建造者
-
(6) ActorController:角色控制器,充当指挥者
-
(7) 配置文件App.config
-
(8) Program:客户端测试类
结果及分析:
- 如果需要更换具体角色建造者,只需要修改配置文件
- 当需要增加新的具体角色建造者时,只需将新增具体角色建造者作为抽象角色建造者的子类,然后修改配置文件即可,原有代码无须修改,完全符合开闭原则
指挥者类的深入讨论
省略Director
1. 将Director和抽象建造者Builder合并:
abstract class ActorBuilder
{
protected static Actor actor = new Actor();
public abstract void BuildType();
public abstract void BuildSex();
public abstract void BuildFace();
public abstract void BuildCostume();
public abstract void BuildHairstyle();
public static Actor Construct(ActorBuilder ab)
{
ab.BuildType();
ab.BuildSex();
ab.BuildFace();
ab.BuildCostume();
ab.BuildHairstyle();
return actor;
}
}
……
ActorBuilder ab;
string builderType = ConfigurationManager.AppSettings["builder"];
ab = (ActorBuilder)Assembly.Load("BuilderExtend").CreateInstance(builderType);
Actor actor;
actor = ActorBuilder.Construct(ab);
……
2. 将Construct()方法中的参数去掉,直接在Construct()方法中调用BuildPartX()方法:
abstract class ActorBuilder
{
protected Actor actor = new Actor();
public abstract void BuildType();
public abstract void BuildSex();
public abstract void BuildFace();
public abstract void BuildCostume();
public abstract void BuildHairstyle();
public Actor Construct()
{
this.BuildType();
this.BuildSex();
this.BuildFace();
this.BuildCostume();
this.BuildHairstyle();
return actor;
}
}
钩子方法的引入
钩子方法(Hook Method):返回类型通常为bool类型,方法名一般为isXXX()。
abstract class ActorBuilder
{
protected Actor actor = new Actor();
public abstract void BuildType();
public abstract void BuildSex();
public abstract void BuildFace();
public abstract void BuildCostume();
public abstract void BuildHairstyle();
//钩子方法,需要使用virtual关键字
public virtual bool IsBareheaded()
{
return false;
}
public Actor CreateActor()
{
return actor;
}
}
class DevilBuilder : ActorBuilder
{
public override void BuildType()
{
actor.Type = "恶魔";
}
public override void BuildSex()
{
actor.Sex = "妖";
}
public override void BuildFace()
{
actor.Face = "丑陋";
}
public override void BuildCostume()
{
actor.Costume = "黑衣";
}
public override void BuildHairstyle()
{
actor.Hairstyle = "光头";
}
//覆盖钩子方法
public override bool IsBareheaded()
{
return true;
}
}
class ActorController
{
public Actor Construct(ActorBuilder ab)
{
Actor actor;
ab.BuildType();
ab.BuildSex();
ab.BuildFace();
ab.BuildCostume();
//通过钩子方法来控制产品的构建
if(!ab.IsBareheaded())
{
ab.BuildHairstyle();
}
actor=ab.CreateActor();
return actor;
}
}
建造者模式的优缺点与适用环境
模式优点:
- 客户端不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象
- 每一个具体建造者都相对独立,与其他的具体建造者无关,因此可以很方便地替换具体建造者或增加新的具体建造者,扩展方便,符合开闭原则
- 可以更加精细地控制产品的创建过程
模式缺点:
- 建造者模式所创建的产品一般具有较多的共同点,其组成部分相似,如果产品之间的差异性很大,不适合使用建造者模式,因此其使用范围受到一定的限制
- 如果产品的内部变化复杂,可能会需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大,增加了系统的理解难度和运行成本
模式适用环境:
- 需要生成的产品对象有复杂的内部结构,这些产品对象通常包含多个成员变量
- 需要生成的产品对象的属性相互依赖,需要指定其生成顺序
- 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类,将创建过程封装在指挥者类中,而不在建造者类和客户类中
- 隔离复杂对象的创建和使用,并使得相同的创建过程可以创建不同的产品