建造者模式

创建型UML

什么是建造者模式

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

在GoF23种设计模式中，属于创建型模式（ Creational patterns）。

通过建造者模式，可以解耦产品的构建与使用过程。

还可以，自由控制对象的生成步骤，一步一步的创建出一个复杂的产品。

GOF建造者模式

在GOF设计模式中，建造者一般会包含以下几种对象。

Builder：抽象接口，负责定义产品的组成部件。

ConcreteBuilder：具体实现接口，负责实现产品部件的构建方法。并返回产品对象。

Director：指挥类，负责指挥Builder构建产品。

Product：产品。

• UML

GOF建造者模式举例

以一辆车的构建过程举例。假设，构成车需要三个部件：轮胎、车身和油。

• UML

• code

AbstractCarBuilder.java

public abstract class AbstractCarBuilder {

    /**
     * 造轮子
     */
    abstract void buildTyre(String tyre);

    /**
     * 造车身
     */
    abstract void buildBody(String body);

    /**
     * 加油
     */
    abstract void buildOil(String oil);

    /**
     * 构建
     */
    abstract Car build();

}

CarBuilder.java

public class CarBuilder extends AbstractCarBuilder {

    private Car car = new Car();

    @Override
    void buildTyre(String tyre) {
        car.setTyre(tyre);
    }

    @Override
    void buildBody(String body) {
        car.setBody(body);
    }

    @Override
    void buildOil(String oil) {
        car.setOil(oil);
    }

    @Override
    Car build() {
        return this.car;
    }
}

CarDirector.java

public class CarDirector {

    private AbstractCarBuilder carBuilder;

    public CarDirector(AbstractCarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public Car build(String tyre,String body,String oil) {
        carBuilder.buildTyre(tyre);
        carBuilder.buildBody(body);
        carBuilder.buildOil(oil);
        return carBuilder.build();
    }
}

Car.java

public class Car {

    private String tyre;

    private String body;

    private String oil;

    public String getTyre() {
        return tyre;
    }

    public void setTyre(String tyre) {
        this.tyre = tyre;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getOil() {
        return oil;
    }

    public void setOil(String oil) {
        this.oil = oil;
    }

    @Override
    public String toString() {
        return "Car{" +
                "tyre='" + tyre + '\'' +
                ", body='" + body + '\'' +
                ", oil='" + oil + '\'' +
                '}';
    }
}

Test.java

public class Test {

    public static void main(String[] args) {

        //  特斯拉 =  指挥者(建造者).建造
        Car tesl  = new CarDirector(new CarBuilder()).build(
                "Tesl tyre",
                "Tesl body",
                "Tesl oil"
        );

        System.out.println(tesl);

        //  比亚迪 =  指挥者(建造者).建造
        Car byd  = new CarDirector(new CarBuilder()).build(
                "byd tyre",
                "byd body",
                "byd oil"
        );

        System.out.println(byd);
    }

}

output

Car{tyre='Tesl tyre', body='Tesl body', oil='Tesl oil'}
Car{tyre='byd tyre', body='byd body', oil='byd oil'}

• 优点

  • 可以使用相同的构建过程构建出不同的产品
  • 新增建造者就能实现新的产品构想，符合开闭原则
  • 使创建过程清晰，可控

• 不足

  • 差异较大的产品不能使用该模式构建
  • 如果产品复杂，则需要很多具体的构建者来构建，导致系统复杂

内部类实现

在实际的使用过程中，一般会将指挥者省略，将建造者以内部类的方式实现建造者。

以上面的造车为例，可改造成如下模式。

• uml

• code

car.java

public class Car {

    /**
     * 轮胎
     */
    private String tyre;

    /**
     * 车身
     */
    private String body;

    /**
     * 油
     */
    private String oil;

    public Car(Builder builder) {
        this.tyre = builder.tyre;
        this.body = builder.body;
        this.oil = builder.oil;
    }


    public static class Builder {

        private String tyre;

        private String body;

        private String oil;

        public Builder builderTyre(String tyre) {
            this.tyre = tyre;
            return this;
        }

        public Builder builderBody(String body) {
            this.body = body;
            return this;
        }

        public Builder builderOil(String oil) {
            this.oil = oil;
            return this;
        }

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

    }

    @Override
    public String toString() {
        return "Car{" +
                "tyre='" + tyre + '\'' +
                ", body='" + body + '\'' +
                ", oil='" + oil + '\'' +
                '}';
    }
}

Test.java

public class Test {

    public static void main(String[] args) {

        Car car = new Car.Builder()
                .builderBody("Tesl body")
                .builderTyre("Tesl tyre")
                .builderOil("Tesl oil")
                .build();

        System.out.println(car);

    }
}

output

Car{tyre='Tesl tyre', body='Tesl body', oil='Tesl oil'}

• 优点

  • 链式调用
  • 编码精简

• 实例

之前我们使用的curator客户端，在创建client时，就是一个典型的建造者模式。

CuratorFrameworkFactory.java

public class CuratorFrameworkFactory {

    //省略...

    public static Builder builder() {
        return new Builder();
    }
    
    //省略...

    public static class Builder {
        private EnsembleProvider ensembleProvider;
        private int sessionTimeoutMs = DEFAULT_SESSION_TIMEOUT_MS;
        private int connectionTimeoutMs = DEFAULT_CONNECTION_TIMEOUT_MS;
        private int maxCloseWaitMs = DEFAULT_CLOSE_WAIT_MS;
        private RetryPolicy retryPolicy;
        //省略...


        public CuratorFramework build() {
            return new CuratorFrameworkImpl(this);
        }
        //省略...

        public Builder authorization(List<AuthInfo> authInfos) {
            this.authInfos = ImmutableList.copyOf(authInfos);
            return this;
        }

        
        public Builder connectString(String connectString) {
            ensembleProvider = new FixedEnsembleProvider(connectString);
            return this;
        }

        
        public Builder ensembleProvider(EnsembleProvider ensembleProvider) {
            this.ensembleProvider = ensembleProvider;
            return this;
        }

        //省略...

        private Builder() {
        }
    }

    private CuratorFrameworkFactory() {
    }
}

使用

public CuratorFramework obtainClient() throws Exception {
        synchronized (ZkClient.class) {
            if (client != null) {
                return client;
            }
            //链式调用，创建client
            client = CuratorFrameworkFactory.builder()
                    .connectString(zkServerPath)
                    .sessionTimeoutMs(sessionTimeout)
                    .retryPolicy(new ExponentialBackoffRetry(100, 10, 5000))
                    .build();
            client.start();
            client.blockUntilConnected();
            return client;
        }
    }

总结

建造者模式主要用于复杂对象组件的创建过程。

通过该种模式，我们可以很优雅的使用建造出来的产品，而不关心产品的创建过程。

相比与工厂模式，建造者模式更专注产品建造的细节，建造的产品专一。

当产品差异较大时，使用工厂模式更为适合。

本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名,转载请标明出处
最后编辑时间为: