建造者模式
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，是一种对象创建型模式
类图
实现
产品，被构建的复杂对象（包含多个成员变量）
package design.builder.realize;
/*
*
*@author:zzf
*@time:2020-12-22
*
*/
public class Product {
//定义部件，部件可以是任意类型，包括值类型和引用类型
private String partA;
private String partB;
private String partC;
//get、set方法
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;
}
}
抽象建造者，定义了产品的创建与返回方法
package design.builder.realize;
/*
*
*@author:zzf
*@time:2020-12-22
*
*/
public abstract class Builder {
//创建产品对象
protected Product product=new Product();
public abstract void buildPartA();
public abstract void buildPartB();
public abstract void buildPartC();
//返回产品对象
public Product getResult(){
return product;
}
}
具体建造者
package design.builder.realize;
/*
*
*@author:zzf
*@time:2020-12-22
*
*/
public class ConcreteBuilder1 extends Builder {
@Override
public void buildPartA() {
product.setPartA("A1");
}
@Override
public void buildPartB() {
product.setPartB("B1");
}
@Override
public void buildPartC() {
product.setPartC("C1");
}
}
指挥者，负责安排复杂对象的建造次序，与抽象建造者之间存在关联关系
package design.builder.realize;
/*
*
*@author:zzf
*@time:2020-12-22
*
*/
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public void setBuilder(Builder builder){
this.builder=builder;
}
//产品构建与组装方法
public Product construct(){
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
return builder.getResult();
}
}
客户端
package design.builder.realize;
/*
*
*@author:zzf
*@time:2020-12-22
*
*/
public class Client {
public static void main(String[] args) {
Builder builder=new ConcreteBuilder1();//可通过配置文件实现
Director director=new Director(builder);
Product product=director.construct();
}
}
应用实例
某游戏软件公司决定开发一款基于角色扮演的多人在线网络游戏，玩家可以在游戏中扮演虚拟世界中的一个特定角色，角色根据不同的游戏情节和统计数据（例如力量、魔法、技能等）具有不同的能力，角色也会随着不断升级而拥有更加强大的能力。
作为该游戏的一个重要组成部分，需要对游戏角色进行设计，而且随着该游戏的升级将不断增加新的角色。通过分析发现，游戏角色是一个复杂对象，它包含性别、面容等多个组成部分，不同类型的游戏角色，其性别、面容、服装、发型等外部特性都有所差异，例如“天使”拥有美丽的面容和披肩的长发，并身穿一袭白裙；而“恶魔”极其丑陋，留着光头并穿一件刺眼的黑衣。
无论是何种造型的游戏角色，它的创建步骤都大同小异，都需要逐步创建其组成部分，再将各组成部分装配成一个完整的游戏角色。现使用建造者模式来实现游戏角色的创建。
代码实现
游戏角色类，充当复杂产品类
package design.builder;
public class Actor {
private String type;// 角色类型
private String sex;// 性别
private String face;// 脸型
private String costume;// 服装
private String hairstyle;// 发型
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getFace() {
return face;
}
public void setFace(String face) {
this.face = face;
}
public String getCostume() {
return costume;
}
public void setCostume(String costume) {
this.costume = costume;
}
public String getHairstyle() {
return hairstyle;
}
public void setHairstyle(String hairstyle) {
this.hairstyle = hairstyle;
}
}
游戏角色建造者，充当抽象建造者
package design.builder;
public 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 createActor() { return actor; }
}
具体建造者
package design.builder;
public class HeroBuilder extends ActorBuilder {
@Override
public void buildType() {
actor.setType("英雄");
}
@Override
public void buildSex() {
actor.setSex("男");
}
@Override
public void buildFace() {
actor.setFace("英俊");
}
@Override
public void buildCostume() {
actor.setCostume("盔甲");
}
@Override
public void buildHairstyle() {
actor.setHairstyle("飘逸");
}
}
package design.builder;
public class AngelBuilder extends ActorBuilder {
@Override
public void buildType() {
actor.setType("天使");
}
@Override
public void buildSex() {
actor.setSex("女");
}
@Override
public void buildFace() {
actor.setFace("漂亮");
}
@Override
public void buildCostume() {
actor.setCostume("白裙");
}
@Override
public void buildHairstyle() {
actor.setHairstyle("披肩长发");
}
}
package design.builder;
public class DevilBuilder extends ActorBuilder {
@Override
public void buildType() {
actor.setType("恶魔");
}
@Override
public void buildSex() {
actor.setSex("妖");
}
@Override
public void buildFace() {
actor.setFace("丑陋");
}
@Override
public void buildCostume() {
actor.setCostume("黑衣");
}
@Override
public void buildHairstyle() {
actor.setHairstyle("光头");
}
}
角色控制器，充当指挥者
package design.builder;
public class ActorController {
// 逐步构建复杂产品对象
public Actor construct(ActorBuilder ab) {
Actor actor;
ab.buildType();
ab.buildSex();
ab.buildFace();
ab.buildCostume();
ab.buildHairstyle();
actor = ab.createActor();
return actor;
}
}
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<config>
<className>design.builder.AngelBuilder</className>
</config>
工具类
package design.builder;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class XMLUtil {
public static Object getBean() {
try {
// 创建DOM文档对象
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("src//design//builder//config.xml"));
// 获取包含类名的文本节点
NodeList nl = doc.getElementsByTagName("className");
Node classNode = nl.item(0).getFirstChild();
String cName = classNode.getNodeValue();
// 通过类名生成实例对象
Class c = Class.forName(cName);
Object obj = c.newInstance();
return obj;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
客户端
package design.builder;
public class Client {
public static void main(String[] args) {
ActorBuilder ab;//针对抽象建造者编程
ab = (ActorBuilder) XMLUtil.getBean();//反射生成具体建造者对象
ActorController ac=new ActorController();
Actor actor;
actor = ac.construct(ab);//通过指挥者创建完整的建造者对象
String type = actor.getType();
System.out.println(type + "的外观:");
System.out.println("性别：" + actor.getSex());
System.out.println("面容：" + actor.getFace());
System.out.println("服装：" + actor.getCostume());
System.out.println("发型：" + actor.getHairstyle());
}
}
运行结果
如果需要更换具体角色建造者，只需要修改配置文件
指挥者扩展
简单的指挥者类用于指导具体建造者如何构建产品，按一定次序调用Builder的builPartX方法，控制调用的先后次序，并向客户端返回一个完整的产品对象，除此之外还有两种变化形式
1、省略Director
有些情况下，为了简化系统结构，将Director和抽象建造者进行合并，在Builder中提供逐步构建复杂产品的方法，由于Builder类通常为抽象类，因此可以将construct方法定义为静态方法，以便客户端直接调用
对上述例子应用
修改ActorBuilder
package design.builder;
public 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;
}
}
修改客户端
package design.builder;
public class Client {
public static void main(String[] args) {
ActorBuilder ab;
ab = (ActorBuilder) XMLUtil.getBean();
// ActorController ac=new ActorController();
Actor actor;
actor = ab.construct();
String type = actor.getType();
System.out.println(type + "的外观:");
System.out.println("性别：" + actor.getSex());
System.out.println("面容：" + actor.getFace());
System.out.println("服装：" + actor.getCostume());
System.out.println("发型：" + actor.getHairstyle());
}
}
2、钩子方法的引入
钩子方法详情见：设计模式之模板方法模式
通过钩子方法来控制是否对某个buildPartX调用
对上述例子应用，例如可以增加个方法判断某个角色是否为光头，默认false
修改ActorBuilder类
package design.builder;
public 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 createActor() { return actor; }
//钩子方法
public boolean isBareheaded() {
return false;
}
}
由于恶魔角色是光头，无需构建头发部件，可以在建造类里覆盖钩子方法
package design.builder;
public class DevilBuilder extends ActorBuilder {
@Override
public void buildType() {
actor.setType("恶魔");
}
@Override
public void buildSex() {
actor.setSex("妖");
}
@Override
public void buildFace() {
actor.setFace("丑陋");
}
@Override
public void buildCostume() {
actor.setCostume("黑衣");
}
@Override
public void buildHairstyle() {
actor.setHairstyle("光头");
}
//覆盖钩子方法
public boolean isBareheaded() {
return true;
}
}
修改指挥者类
package design.builder;
public 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;
}
}
建造者模式的优缺点
优点：
（1）在客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
（2）可以很方便地替换具体建造者或增加新的具体建造者
（3）可以更加精细地控制产品的创建过程
缺点：
（1）建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，并不适合适用建造者模式
（2）如果产品内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加系统的理解难度和运行成本
适用环境
（1）需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员变量
（2）需要生成的产品对象的属性相互依赖，需要指定其生成顺序
（3）对象的创建过程独立于创建该对象的类
（4）隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品
参考
Java设计模式
扫一扫
349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
