06.建造者模式

概念：

建造者模式是一种创建型设计模式，又叫"生成器模式"。定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。其实就是将建造负责对象的过程和组成对象的部件解耦。

用途：

假设现在我们是一家游戏公司，我们要设计游戏中的各种角色。在梦幻西游中包括人、仙、魔等的角色，而每种不同的角色有包含龙太子、逍遥生等具体角色。

作为一个出色的开发人员，我们设计的角色生成系统应该包含以下功能和特性：

为了保证游戏平衡，所有角色的基本属性应该一致

因为角色的创建过程可能很复杂，所以角色的生成细节不应该对外暴露

随时可以新增角色

对某个具体角色的修改应该不影响其他角色

其实，对于角色的设计，我们可以使用抽象工厂模式，将同一的角色看成是一个产品族。但是，这样做可能就会出现一个问题，那就是我们要在每个角色创建过程中都要从头到尾的构建一遍该角色，比如一个角色有头、身体、腿，其中头有包括眉毛、嘴巴、鼻子等部位。整个角色的创建过程是极其复杂的。

那么，我们可以将这些具体部位的创建工作和对象的创建进行解耦。这就是建造者模式。

实现方式：

建造者模式包含如下角色：

Builder：抽象建造者

ConcreteBuilder：具体建造者

Director：指挥者

Product：产品角色

这里采用设计角色的例子，为了便于理解，我们只创建两个角色，分别是普通角色和超级角色。他们都有设置头部、脸部、身体、气血值、魔法值、能量值等方法。值得注意的是设置脸部是依赖于设置头部的，要有先后顺序。

（1）产品角色

/**
 * 产品角色
 */
@Data
@ToString
public class Role {
    /**
     * 头部
     */
    private String head;
    /**
     * 面部
     */
    private String face;
    /**
     * 身体
     */
    private String body;

    /**
     * 血量
     */
    private Double hp;
    /**
     * 能量值
     */
    private Double sp;
    /**
     * 魔法值
     */
    private Double mp;
}

（2）抽象建造者

/**
 * 抽象建造者
 */
public abstract class Builder {
    protected Role role = new Role();
    public abstract void buildHead();
    public abstract void buildFace();
    public abstract void buildBody();
    public abstract void bulidHp();
    public abstract void bulidSp();
    public abstract void bulidMp();

    public Role getResult(){
        return role;
    }
}

（3）指挥者

/**
 * 指挥者
 */
public class Director {
    public void construct(Builder builder){
        builder.buildBody();
        builder.buildHead();
        builder.buildFace();
        builder.bulidHp();
        builder.bulidMp();
        builder.bulidSp();
    }
}

（4）普通角色

/**
 * 普通角色 - 具体建造者
 */
@ToString
public class CommonRoleBuilder extends Builder {
    private Role role = new Role();

    @Override
    public void buildHead() {
        role.setHead("common head");
    }

    @Override
    public void buildFace() {
        role.setFace("common face");
    }

    @Override
    public void buildBody() {
        role.setBody("common body");
    }

    @Override
    public void bulidHp() {
        role.setHp(100d);
    }

    @Override
    public void bulidSp() {
        role.setSp(100d);
    }

    @Override
    public void bulidMp() {
        role.setMp(100d);
    }
}

/**
 * 超级角色 - 具体建造者
 */
@ToString
public class SuperRoleBuilder extends Builder {
    private Role role = new Role();

    @Override
    public void buildHead() {
        role.setHead("super head");
    }

    @Override
    public void buildFace() {
        role.setFace("super face");
    }

    @Override
    public void buildBody() {
        role.setBody("super body");
    }

    @Override
    public void bulidHp() {
        role.setHp(120d);
    }

    @Override
    public void bulidSp() {
        role.setSp(120d);
    }

    @Override
    public void bulidMp() {
        role.setMp(120d);
    }
}

（5）测试

public class Main {
    public static void main(String[] args) {
        final Director director = new Director();
        final CommonRoleBuilder commonRoleBuilder = new CommonRoleBuilder();
        director.construct(commonRoleBuilder);
        final Role result = commonRoleBuilder.getResult();
        System.out.println(commonRoleBuilder);

        final SuperRoleBuilder superRoleBuilder = new SuperRoleBuilder();
        director.construct(superRoleBuilder);
        final Role result1 = superRoleBuilder.getResult();
        System.out.println(superRoleBuilder);
    }
}

由于建造角色的过程比较复杂，其中还有相互依赖关系（如脸部依赖于头部），所以我们使用建造者模式将建造复杂对象的过程和组成对象的部件解耦。这样既保证了基本属性全部一致，也封装了其中的具体实现细节。

同时，在修改某个具体角色的时候我们只需要修改对应的具体角色就可以了，不会影响到其他角色。

如果需要新增角色，只要在增加一个具体的建造者，并在该建造者中写好具体细节的建造部分代码就OK了。

建造者模式的优缺点

优点：

（1）封装性很好，使用建造者模式可以有效的封装变化

（2）客户端不必知道产品内部组成的细节，将产品本身和创建过程解耦

（3）可以更加精细的控制产品的创建过程

（4）建造者模式很容易扩展

缺点：

建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式。因此其使用范围受到一定的限制。

如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

适用的环境：

（1）需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。

（2）需要生成的产品对象的属性相互依赖，需要制定其生成顺序。

（3）对象的创建过程独立于创建该对象的类，在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中。

（4）隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

建造者模式和工厂模式的区别

建造者模式和工厂模式极为相似，总体上，建造者模式仅仅只比工厂模式多了一个指挥者角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看做是一个简单的工厂模式。

与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。

也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类，有导演类负责将各个组件按照特定的规则组建为产品，然后将组件好的产品交付给客户端。

建造者模式与工厂模式类似，适应的场景也相似。一般来说，如果产品的建造很复杂就使用建造者模式，如果产品建造不复杂，就用工厂模式。

总结：

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

在建造者模式的结构中引入了一个指挥者类，该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面他负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象。