Java设计模式（十一） 之创建型模式（建造者模式）

一、定义

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

建造者模式作用：

• 将类对象的创建过程和细节封装起来，客户代码只需要知道自己建造对象的建造者是谁就可以获取到自己需要的类对象。
• 根据客户代码的需求可以通过相同的创建顺序和逻辑创建出拥有相同成员类型但是不同成员值的类对象。

二、角色

在这样的设计模式中，有以下几个角色：

• 1 builder： 为创建一个产品对象的各个部件指定抽象接口。
• 2 ConcreteBuilder： 实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。
• 3 Director： 构造一个使用Builder接口的对象。
• 4 Product： 表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

 类图如下：

三、场景展示

首先创建产品类

package com.ssy.wlj.build;

/**
 * 最终生产的'复杂产品'对象
 * 
 * @author Administrator
 * @since 2019/05/25
 *
 */
public class Car {
    private String roof;// 车顶
    private String bottom;// 车底
    private String wheel;// 车轮

    public String getRoof() {
        return roof;
    }

    public void setRoof(String roof) {
        this.roof = roof;
    }

    public String getBottom() {
        return bottom;
    }

    public void setBottom(String bottom) {
        this.bottom = bottom;
    }

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }
}

创建者Builder接口

package com.ssy.wlj.build;

/**
 * 生产汽车：创建者Builder接口
 * 
 * @author Administrator
 * @since 2019/05/25
 *
 */
public interface CarBuilder {
    void carRoof();// 生产车顶
    void carBottom();// 生产车底盘
    void carWheel();// 生产车轮
    Car buildCar();
}

具体创建者管理对象（Director），建造者

package com.ssy.wlj.build;

/**
 * 类说明: 具体创建者管理对象（Director），建造者
 * 
 * @author happy
 * @since 2019年5月25日
 * 
 */
public class CarDirector {
    public Car constructPerson(CarBuilder carBuilder) {
        carBuilder.carRoof();
        carBuilder.carBottom();
        carBuilder.carWheel();
        return carBuilder.buildCar();
    }
}

具体创建对象ConcreteBuilder:白色汽车

package com.ssy.wlj.build;
/**
 * 类说明: 具体创建对象ConcreteBuilder:白色汽车
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class WhiteCar implements CarBuilder {
      Car car;
      public WhiteCar() {
        car = new Car();
      }
      @Override
      public void carRoof() {
        car.setRoof("制造白色汽车---车顶");
      }
      @Override
      public void carBottom() {
        car.setBottom("制造白色汽车---车底");
      }
      @Override
      public void carWheel() {
        car.setWheel("制造白色汽车---车轮");
      }
      @Override
      public Car buildCar() {
        // TODO Auto-generated method stub
        return car;
      }
    }

客户端调用

package com.ssy.wlj.build;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class Client {
    
    public static void main(String[] args) {
        CarDirector carDirector = new CarDirector();
        Car car = carDirector.constructPerson(new WhiteCar());
        System.out.println(car.getRoof());
        System.out.println(car.getBottom());
        System.out.println(car.getWheel());
        System.out.println("----整个车子就完成了！--");
    }

}

优点：

• 解耦，低耦合。客户代码不需要关注产品的创建逻辑和顺序。
• 扩展性好，根据客户的需求，可以扩展不同的建造者类或者根据产品创建的顺序的不同，新增不同的指挥方法，符合开闭原则。
• 便于控制内部细节和逻辑，便于维护。

缺点：

• 局限性：产品本身的局限性，一般需要构建的产品之间又相同或较多的共同点，产品的组成结构相同。这种局限性使得建造者模式的使用场景相对较少，当产品的差异性很大时，例如手机和电脑，这样则不适合使用该模式。
• 有类膨胀的理论风险：当产品类型很多时，我们就需要设计多个建造者类，这样会造成类过多的问题，该问题同样体现在工厂方法中。但是一班情况下不会出现这种情况。