建造者模式

GOF给建造者模式的定义是：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

来看看建造者模式的组成：

1.产品角色：建造中的复杂对象、它要包含哪些定义组件的类，包括将这些组件装配成产品的接口。

2.抽象建造者角色：这个角色用来规范产品对象的各个组成成分的建造。一般而言，此角色独立于应用程序的业务逻辑。

3.具体建造者角色：担任这个角色的是与应用程序紧密相关的类，它们在指导者的调用下创建产品实例。这个角色在实现抽象角色提供的方法的前提下，达到完成产品组装，提供成品的功能。

4.指导者角色：调用具体建造者角色以创建产品对象。指导者并没有产品类的具体知识，真正拥有产品类的具体知识是具体建造者对象。

来看看这些角色组成的类图：

建造者模式和工厂方法模式都是创建模式。下面通过代码来讲解来熟悉建造者模式：

产品角色：

package com.bluemsun.BuilderModel;


/**
 * 产品类,一个Person的产品模型
 * @author zhouxy
 *
 */
public class PersonModel {
    private Body body;
    private Soul soul;
    
    public Body getBody() {
        return body;
    }
    public void setBody(Body body) {
        this.body = body;
    }
    public Soul getSoul() {
        return soul;
    }
    public void setSoul(Soul soul) {
        this.soul = soul;
    }
    @Override
    public String toString() {
        return "Person ["+body.toString()+","+soul.toString()+"]";
    }
}

产品角色中body,soul组件的定义如下：

package com.bluemsun.BuilderModel;

public class Body {
    private int eyes;
    private int ear;
    private int nose;
    private int mouse;
    private int hand;
    private int leg;
    
    /*此处省略setter,getter方法*/
    
    public Body(int eyes, int ear, int nose, int mouse, int hand, int leg) {
        super();
        this.eyes = eyes;
        this.ear = ear;
        this.nose = nose;
        this.mouse = mouse;
        this.hand = hand;
        this.leg = leg;
    }
    @Override
    public String toString() {
        return "Body [eyes=" + eyes + ", ear=" + ear + ", nose=" + nose
                + ", mouse=" + mouse + ", hand=" + hand + ", leg=" + leg + "]";
    }
}

package com.bluemsun.BuilderModel;

public class Soul {
    private String soul_type;

    /*此处省略setter,getter方法*/
    public Soul(String soul_type) {
        super();
        this.soul_type = soul_type;
    }
    @Override
    public String toString() {
        return "Soul [soul_type=" + soul_type + "]";
    }
}

抽象建造者角色：

package com.bluemsun.BuilderModel;

/**
 * 抽象建造者接口,指明建造一个Person产品需要的组件(方法)
 * @author zhouxy
 *
 */
public interface Builder{
    
    public void buildBody();//构建body组件
    public void buildSoul();//构建soul组件
    
    public PersonModel getPersonModel();//通过上面两个组件的完成,在这里将组件组装,返回成品对象
}

具体建造者角色：

package com.bluemsun.BuilderModel;

/**
 * 具体建造者类,实现Builder
 * @author zhouxy
 *
 */
public class PersonBuilder implements Builder{
    private PersonModel personModel = new PersonModel();//创建一个待组装的对象
    
    @Override
    public void buildBody() {    //生产真正组件
        Body body = new Body(2, 2, 1, 1, 2, 1);
        personModel.setBody(body);
    }

    @Override
    public void buildSoul() {    //生产真正组件
        Soul soul = new Soul("高尚的");
        personModel.setSoul(soul);
    }

    @Override
    public PersonModel getPersonModel() { //将上面实际产生的组件进行组装
        return personModel;    //返回成品
    }
}

指导者角色：

package com.bluemsun.BuilderModel;


/**
 * 指导者.指导者根据不同的builder指导创建不同成品
 * @author zhouxy
 *
 */
public class Director {
    private Builder builder;
    
    public Director(Builder builder){
        this.builder = builder;
    }
    
    public void construct(){    //根据客户端提供的builder产生与builder对应的组件
        builder.buildBody();
        builder.buildSoul();
    }
}

客户端代码：

package com.bluemsun.BuilderModel;


/**
 * 客户端代码
 * @author zhouxy
 *
 */
public class Client {
    public static void main(String[] args) {
        Builder builder = new PersonBuilder();    
        Director director = new Director(builder);
        director.construct();
        PersonModel personModel = builder.getPersonModel();
        
        System.out.println(personModel.toString());
        
        /*builder = new SuperManBuilder();
        director = new Director(builder);
        director.construct();
        personModel = builder.getPersonModel();
        
        System.out.println(personModel.toString());*/
    }
}

在客户端代码中，我们创建了一个具体建造者对象，并把这个对象交给指导者，指导者将会根据它的信息指导创建具体产品实例。如果现在我们需要创建另外一种产品实例，我们仅仅需要定义这种产品具体实现（代码如下），其他部分的代码不需要修改，客户端也仅仅只是需要增加上面注释部分的代码即可。

package com.bluemsun.BuilderModel;

/**
 * 另一种具体产品的实现
 * @author zhouxy
 *
 */

public class SuperManBuilder implements Builder {
    
    private PersonModel personModel = new PersonModel();
    
    @Override
    public void buildBody() {
        Body body = new Body(4, 4, 2, 2, 4, 4);
        personModel.setBody(body);
    }

    @Override
    public void buildSoul() {
        Soul soul = new Soul("善良的,伟大的");
        personModel.setSoul(soul);
    }

    @Override
    public PersonModel getPersonModel() {
        
        return personModel;
    }

}

建造模式的优点：

1.建造者模式可以使得产品内部的表象独立变化。在原来的工厂方法模式中，产品内部的表象是由产品自身来决定的，而在建造者模式中则是“外部化”为由具体的建造者来负责。这样定义一个新的具体建造者角色（就像上面的SuperManBuilder）就可以改变产品的内部表象，符合“开闭原则”。

2.建造者模式使得客户端不需要知道太多产品内部的细节。他将复杂对象的组件和表示方式封装在一个具体的建造角色中，而且由指导者类协调建造者角色来得到具体产品实例。