4.建造者模式
1.建造者模式是什么？
对于一些复杂对象，它们是由多个组成部分组成。用户不需要知道每个部分，只使用完整的对象就行。
以汽车为例，包括发动机、方向盘、车轮，用户不需要知道它们是怎么做的，只需要使用汽车这个对象就行。
建造者模式需要做的是将部件本身和它们的组装过程分开，关注如何一步步的创建一个复杂对象。而用户只需要指定复杂对象的类型就可以得到复杂对象，不需要知道其细节。
2.建造者模式结构
（1）Builder（抽象建造者）：指定抽象接口。在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Build既可以是抽象类，也可以是接口。
（2）ConcreteBuilder（具体建造者）：它实现Builder接口，实现各个部件的具体构造和装配方法
（3）Product（产品）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程
（4）Director（指挥者）：指挥者又叫导演类，它负责安排复杂对象的建造次序。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象，然后通过指挥者类的构造函数或者setter方法将该对象传入指挥者类中
3.建造者模式实现
复杂对象=包含多个成员变量的对象
（1）声明复杂对象
public class Product {
//定义部件
private String partA;
private String partB;
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;
}（2）抽象建造者
/**
* 抽象建造者
*/
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;
}
}（3）具体建造者
/**
* 具体建造者
*/
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");
}
}（4）指挥者
/**
* 指挥者
*/
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();
}
}（5）客户端使用建造者模式
/**
* 客户端使用建造者模式
*/
public class Client {
public static void main(String[] args) {
Builder builder = new ConcreteBuilder1();//可通过配置文件实现
Director director = new Director(builder);
Product product = director.construct();
}
}
4.建造者模式应用实例——使用建造者模式来实现游戏角色的创建
（1）游戏角色，复杂对象
/**
* 游戏角色
*/
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;
}
}（2）抽象建造者
/**
* 游戏角色抽象建造者
*/
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;
}
}（3）三个具体建造者
/**
* 英雄角色建造者，充当具体建造者
*/
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("飘逸");
}
}/**
* 天使角色创造者，充当具体建造者
*/
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("披肩长发");
}
}/**
* 恶魔角色创造者，充当具体建造者
*/
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("光头");
}
}
（4）指挥者
/**
* 指挥者
*/
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;
}
}（5）配置文件
controller.buildModuleRole.AngelBuilder
（6）工具类
public class XMLUtil {
/**
* 从xml配置文件中提取具体类的类名，并返回一个实例对象
*/
public static Object getBean(){
try {
//创建DOM文档对象
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
Document document = builder.parse(new File("src//controller//buildModuleRole//config.xml"));
//获取包含类名的文本节点
NodeList nl = document.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;
}
}
}（7）客户端测试类
/**
* 客户端测试类
*/
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());
}
}（8）路径及返回结果
5.指挥者类的深入讨论
指挥者类用于指导具体建造者如何构建产品，它按一定顺序调用Builder的buildPartX()方法，控制调用的先后次序，并向客户端返回一个完整的产品对象。下面讨论几种指挥者类的变化形式：
（1）省略指挥者类
在Builder中提供construct()方法，记得定义为静态方法，以使得客户端能够直接调用。代码要适当调整
/**
* 游戏角色抽象建造者
*/
public 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 Actor createActor(){
// return actor;
// }
public static Actor construct(ActorBuilder ab){
ab.buildType();
ab.buildSex();
ab.buildFace();
ab.buildCostume();
ab.buildHairstyle();
return actor;
}
}/**
* 客户端测试类
*/
public class Client {
public static void main(String args[]){
ActorBuilder ab;
ab = (ActorBuilder)XMLUtil.getBean();//反射生成具体建造者对象
Actor actor;
actor = ActorBuilder.construct(ab);
// ActorController ac = new ActorController();
// 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());
}
}在此基础上还可以更加简便一步，将construct()中的参数去掉：（注意static）
/**
* 游戏角色抽象建造者
*/
public 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 Actor createActor(){
// return actor;
// }
public Actor construct(){
this.buildType();
this.buildSex();
this.buildFace();
this.buildCostume();
this.buildHairstyle();
return actor;
}
}/**
* 客户端测试类
*/
public class Client {
public static void main(String args[]){
ActorBuilder ab;
ab = (ActorBuilder)XMLUtil.getBean();//反射生成具体建造者对象
Actor actor;
actor = ab.construct();
// ActorController ac = new ActorController();
// 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());
}
}（2）钩子方法的引入
建造者模式可以逐步构建一个复杂产品，还可以通过钩子方法（Hook Method）来控制是否对某个buildPartX()进行调用。
钩子方法的返回类型通常类boolean类型，方法名一般是isXXX()，钩子方法定义在抽象建造者的类中。
说白了，就是加一个校验，仅此而已。
/**
* 游戏角色抽象建造者
*/
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 boolean isBareHeaded(){
return false;
}
//工厂方法，返回一个完整的游戏角色对象
public Actor createActor(){
return actor;
}
}
/**
* 恶魔角色创造者，充当具体建造者
*/
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("光头");
}
//覆盖钩子方法
@Override
public boolean isBareHeaded(){
return true;
}
}
/**
* 客户端测试类
*/
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());
}
}
6.建造者模式的优缺点
优：
（1）客户端不必知道产品细节，将产品与产品创建解耦
（2）每个具体建造者独立，所以替换或者新增具体建造者很方便
（3）通过钩子更加精确的控制创建过程
缺：
（1）建造者模式适用于产品有较多共同点的，如果差异很大不适合。因此适用范围受到限制
（2）过多的具体建造者会增加系统理解程度
7.适用范围
（1）复杂的对象，一般含有多个成员变量
（2）对象属性互相依赖，需要制定生成顺序
（3）对象的创建过程独立于创建该对象的类。建造者模式是在指挥者类完成，而不是建造者类
（4）隔离复杂对象的创建和使用，并使得相同的创建国产可以创建不同的产品