设计模式——建造者模式（Builder模式）

建造者模式（Builder Pattern）通过多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

建造者模式通过将一个复杂对象的构建过程与它的表现分离，使得构建的过程可以自由扩展，降低部件与组装过程的耦合。

建造者模式（Builder Pattern）使用的场景

• 需要初始化生成的对应成员变量过多，初始化特别复杂，需要的构造函数参数过多；
• 同一个方法，不同的类对应调用，产生不同的结果。（主要是因为初始化的成员变量不同引起的。）
• 产品类复杂，多个成员变量都可以构建类对应，并且产生的结果不同。

建造者的UML图

通过UML图，可以看出BuilderPattern中的角色分类。

• AbstractBuilder（抽象建造者）：抽象建造者定义了产品的组建过程，一般是需要子类进行实现的方法。
• ConcreteBuilder（具体构建者）：抽象构建者的实现，根据具体的需求进行实现。
• Product：产品类
• Director：统一组装构建过程

实例演示
我们知道手机由屏幕、按键、cpu、电池等组件组成，这里我们以构建一个手机的例子来讲解。

定义产品类

/**
 * 定义手机产品类
 * @author Iflytek_dsw
 *
 */
class PhoneProduct {
    private String screen;
    private String battery;
    private String hardware;
    protected PhoneProduct() {}
    public void setScreen(String screen) {
        this.screen = screen;
    }
    public void setBattery(String battery) {
        this.battery = battery;
    }
    public void setHardware(String hardware) {
        this.hardware = hardware;
    }
}

定义抽象Builder

/**
 * 定义抽象Builder类，定义构造Product的方法
 * @author Iflytek_dsw
 *
 */
public abstract class AbstractPhoneBuilder {
    public abstract void buildScreen(String screen);
    public abstract void buildBattery(String battery);
    public abstract void buildHardware(String hardware);
    public abstract PhoneProduct createPhone();
}

定义具体Builder类

/**
 * 创建一个Android手机产品
 * @author Iflytek_dsw
 *
 */
public class AndroidPhoneBuilder extends AbstractPhoneBuilder{

    private PhoneProduct product = new PhoneProduct();

    @Override
    public void buildScreen(String screen) {
        product.setScreen(screen);
    }

    @Override
    public void buildBattery(String battery) {
        product.setBattery(battery);
    }

    @Override
    public void buildHardware(String hardware) {
        product.setHardware(hardware);
    }

    @Override
    public PhoneProduct createPhone() {
        return product;
    }
}

定义Director类

public class Director {
    private AbstractPhoneBuilder builder;

    public Director(AbstractPhoneBuilder builder) {
        super();
        this.builder = builder;
    }
    
    public void concreatePhone(String screen,String battery,String hardware){
        builder.buildBattery(battery);
        builder.buildHardware(hardware);
        builder.buildScreen(screen);
    }
}

定义客户端

public class Client {
    public static void main(String args[]){
        AndroidPhoneBuilder androidPhoneBuilder = new AndroidPhoneBuilder();
        Director director = new Director(androidPhoneBuilder);
        director.concreatePhone("三星", "南孚", "Imax6");
        PhoneProduct product= androidPhoneBuilder.getPhone();
    }
}

通过上面的例子，Director类封装了构建复杂对象的过程，然后通过指定具体的Builder类生成具体的实例对象。通过Builder和Director类一起讲复杂对象的构建过程与它的表示进行风力，使得同样的过程可以创建不同的实例对象。

通过上面的例子，是不是感觉搞通过建造者模式去生成一个对象也是很复杂的一件事。所以在实际的使用中，一般都是Director类省略，形成一个精简版。针对上面的例子，我们来看看下面的精简版：

/**
 * 定义手机产品类
 * @author Iflytek_dsw
 *
 */
class PhoneProduct {
    private String screen;
    private String battery;
    private String hardware;
    protected PhoneProduct() {}
    public void setScreen(String screen) {
        this.screen = screen;
    }
    public void setBattery(String battery) {
        this.battery = battery;
    }
    public void setHardware(String hardware) {
        this.hardware = hardware;
    }
    
    /**
     * 封装Builder内部类
     * @author Iflytek_dsw
     *
     */
    public static class Builder{
        private PhoneProduct product = new PhoneProduct();
        
        public Builder setScreen(String screen){
            product.screen = screen;
            return this;
        }
        
        public Builder setBattery(String battery) {
            product.battery = battery;
            return this;
        }
        
        public Builder setHardware(String hardware) {
            product.hardware = hardware;
            return this;
        }
        
        public PhoneProduct buildProduct(){
            return product;
        }
    }
}

//客户端
public class Client {
    public static void main(String[]args){
        PhoneProduct.Builder builder = new PhoneProduct.Builder();
        builder.setBattery("南孚");
        builder.setHardware("Imax6");
        builder.setScreen("镁光");
        PhoneProduct product = builder.buildProduct();
    }
}

通过去除Director类，整个类的构建结构更加简洁了，代码的可读性也提高了很多。所以推荐大家使用这种方式进行。