设计模式[5]-构建者模式-Builder Pattern

1. 构建者模式

构建者模式是创建型的设计模式，可以将复杂对象的创建过程和表示分离，使得同样的构建过程可以创建不同的表示。构建者模式包括以下四种角色。

产品（Product）：是被构建的对象，是包含多个组件的复杂结构。

抽象建造者（Builder）：为创建的产品对象规定抽象接口，一般包括两类方法，一类是创建组件的方法（以build开头），一类是返回创建的对象的方法。

具体建造者（ConcreteBuilder）：实现建造者接口，实现各个部件的具体构造和装配方法。

导演者（Director）：负责指挥复杂对象的构建次序。

2. 构建者模式举例

游戏里的玩家形象的设定，可能包括了角色、服饰、坐骑、武器；不同玩家可能会选择不同的形象，这些形象的创建过程是大同小异的，需要逐步创建组成部分，再将不同的部分装配成完整的玩家形象。

序号	类名	角色	说明
1	Actor	产品	玩家形象
2	ActorBuilder	抽象建造者	玩家抽象构建者
3	ActorDirector	导演类	指挥对象构建次序
4	SwordmanBuilder	具体建造者	剑客
5	WizardBuilder	具体建造者	魔法师
6	BuilderMain	客户端	调用发起者

1. Actor

/**
 * 产品类，玩家
 */
public class Actor {

    private String role; // 角色

    private String clothing; // 服饰

    private String mount; // 坐骑

    private String weapon; // 武器

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    public String getClothing() {
        return clothing;
    }

    public void setClothing(String clothing) {
        this.clothing = clothing;
    }

    public String getMount() {
        return mount;
    }

    public void setMount(String mount) {
        this.mount = mount;
    }

    public String getWeapon() {
        return weapon;
    }

    public void setWeapon(String weapon) {
        this.weapon = weapon;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "role='" + role + '\'' +
                ", clothing='" + clothing + '\'' +
                ", mount='" + mount + '\'' +
                ", weapon='" + weapon + '\'' +
                '}';
    }
}

2. ActorBuilder

/**
 * 抽象构建者类，玩家构建者
 */
public interface ActorBuilder {

    void buildRole();

    void buildClothing();

    void buildMount();

    void buildWeapon();

    Actor buildActor();

}

3. ActorDirector

/**
 * 导演类
 */
public class ActorDirector {

    private ActorBuilder builder;

    public ActorDirector(ActorBuilder builder) {
        this.builder = builder;
    }

    /**
     * 构建玩家对象
     * @return Actor
     */
    public Actor construct() {
        builder.buildRole();
        builder.buildClothing();
        builder.buildMount();
        builder.buildWeapon();
        return builder.buildActor();
    }

}

4. SwordmanBuilder

/**
 * 具体构建者，剑客
 */
public class SwordmanBuilder implements ActorBuilder {

    private Actor swordman = new Actor();

    @Override
    public void buildRole() {
        System.out.println("构建玩家角色：剑侠客");
        swordman.setRole("剑侠客");
    }

    @Override
    public void buildClothing() {
        System.out.println("构建玩家角色：长衫");
        swordman.setClothing("长衫");
    }

    @Override
    public void buildMount() {
        System.out.println("构建玩家坐骑：麒麟");
        swordman.setMount("麒麟");
    }

    @Override
    public void buildWeapon() {
        System.out.println("构建玩家武器：长剑");
        swordman.setWeapon("长剑");
    }

    @Override
    public Actor buildActor() {
        return swordman;
    }
}

5. WizardBuilder

/**
 * 魔法师构建者
 */
public class WizardBuilder implements ActorBuilder {

    private Actor wizard = new Actor();

    @Override
    public void buildRole() {
        System.out.println("构建玩家角色：魔法师");
        wizard.setRole("魔法师");
    }

    @Override
    public void buildClothing() {
        System.out.println("构建玩家角色：长袍斗篷");
        wizard.setClothing("长袍斗篷");
    }

    @Override
    public void buildMount() {
        System.out.println("构建玩家坐骑：白霜战马");
        wizard.setMount("白霜战马");
    }

    @Override
    public void buildWeapon() {
        System.out.println("构建玩家武器：魔法杖");
        wizard.setWeapon("魔法杖");
    }

    @Override
    public Actor buildActor() {
        return wizard;
    }
}

6. BuilderMain

/**
 * 客户端
 */
public class BuilderMain {

    public static void main(String[] args) {
        // 构建剑侠客对象
        ActorBuilder builder = new SwordmanBuilder();
        ActorDirector director = new ActorDirector(builder);
        Actor swordman = director.construct();
        System.out.println(swordman);
        // 构建魔法师对象
        ActorBuilder wizardBuilder = new WizardBuilder();
        director = new ActorDirector(wizardBuilder);
        Actor wizard = director.construct();
        System.out.println(wizard);
    }
}

3. 构建者模式总结

有的时候，Director角色可以省略，合并到抽象Builder类中。

优点：
客户端不知道产品内部的组成细节，将产品本身和产品的创建过程解耦，使用相同的创建过程可以创建不同的产品对象。每一个具体建造者都相对独立，而与其他的具体建造者无关。

缺点：建造者模式所创建的产品一般具有较多的共同点，如果产品之间差异大，可能就不适用创建者模式；或者导致代码变得复杂，难以理解。
（完）