Java设计模式之建造者模式（Builder）

前言：

    最近一直在学习okHttp，也对其做了一些整理，okHttp和Retrofit结合大大加速我们的开发效率，源码里面采用了很多设计模式，今天我们来学习一下其中的设计模式之一建造者模式。

建造者模式

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

 使用场景：

• 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

• 当构造过程必须允许被构造的对象有不同的表示时。

主要组成部分

• Builder 是为创建一个product对象的各个部件指定的抽象接口

• ConcreteBuilder 实现Builder的接口以构造和装配该产品的各个部件

• Director 他是构建一个使用Builder接口的对象

• Product 表示被构造的复杂对象

举例说明

    对于上面的描述多多少少会让人感觉一头雾水，接下来我们以一个简单的例子来说明一下。模拟一个需求：李先生想要托人建造一个马力为300，轮胎尺寸为18的suv，我们该如何通过建造者模式满足李先生的需求呢。

1.）第一步先基于李先生的要求 确定这部suv的部件

Car类

public class Car {
    private final Engine engine;
    private final Tyre tyre;

    Car() {
        this(new Builder());
    }

    Car(final Engine engine, final Tyre tyre) {
        this.engine = engine;
        this.tyre = tyre;
    }

    Car(Builder builder) {
        this.engine = builder.engine;
        this.tyre = builder.tyre;
    }

    public void startDrive() {
        this.engine.startRun();
        this.tyre.startGo();
    }

 }

Engine类

final class Engine {

    private int power;

    Engine(int power) {
        this.power = power;
    }

    Engine() {
        this.power = 235;
    }

    public void startRun() {
        Log.e("startRun", "startRun----->" + power);
    }

}

Tyre类

final class Tyre {

    private int size;

    Tyre(int size) {
        this.size = size;
    }

    Tyre() {
        this.size = 18;
    }

    public void startGo() {
        Log.e("startRun", "startGo----->" + size);
    }
}

2.）第二步我们按照需求安排工序

 interface ICar {

    /**
     * 建造一个发动机
     * @param power
     */
    void buildEngine(int power);

    /**
     * 安装一个轮胎
     * @param size
     */
    void buildTyre(int size);

    /**
     * 组装车辆
     * @return
     */
    Car build();
}

3.）第三步安排建造者生产

 public static class Builder implements ICar {
        private Engine engine;
        private Tyre tyre;

        private Builder(Car car) {
            this.engine = car.engine;
            this.tyre = car.tyre;
        }

        public Builder() {
            engine = new Engine();
            tyre = new Tyre();
        }

        @Override
        public void buildEngine(int power) {
            this.engine = new Engine(power);
        }

        @Override
        public void buildTyre(int size) {
            this.tyre = new Tyre(size);
        }

        @Override
        public Car build() {
            return new Car(this);
        }
    }

4.）生产完毕交付到李先生手里

        Car.Builder builder = new Car.Builder();
        builder.buildEngine(120);
        builder.buildTyre(30);
        Car car = builder.build();
        car.startDrive();

5.）一般情况下Director ，Product 放在一个类里实现 详细代码如下

public class Car {
    private final Engine engine;
    private final Tyre tyre;

    Car() {
        this(new Builder());
    }

    Car(final Engine engine, final Tyre tyre) {
        this.engine = engine;
        this.tyre = tyre;
    }

    Car(Builder builder) {
        this.engine = builder.engine;
        this.tyre = builder.tyre;
    }

    public void startDrive() {
        this.engine.startRun();
        this.tyre.startGo();
    }

    public Builder newBuilder() {
        return new Builder(this);
    }

    public static class Builder implements ICar {
        private Engine engine;
        private Tyre tyre;

        private Builder(Car car) {
            this.engine = car.engine;
            this.tyre = car.tyre;
        }

        public Builder() {
            engine = new Engine();
            tyre = new Tyre();
        }

        @Override
        public void buildEngine(int power) {
            this.engine = new Engine(power);
        }

        @Override
        public void buildTyre(int size) {
            this.tyre = new Tyre(size);
        }

        @Override
        public Car build() {
            return new Car(this);
        }
    }
}

小结

   整个例子里面特别注意一下类的权限已经构造函数的权限控制，其实李先生从下单到提车对整个过程的细节一无所知，这样就有效的实现建造者模式的好处，很好的让造车其中各个复杂的环节与造车剥离开。