java设计模式之Builder建造者模式

java设计模式之Builder建造者模式

---

建造者模式时日常开发中比较常见的设计模式，它的主要作用就是将复杂事物创建过程抽象出来，通俗的讲，创建一个对象一般都会有一个固定的步骤，这个固定的步骤我们把它抽象出来，每个步骤都有不同的实现方式，举个比较常见的例子，我们生产一辆汽车，这汽车分为高配版版和低配版，无论时低配版还是高配版，最终的对象都是汽车，生产步骤相同，只是材料和设备组成不同。建造者模式大体分为两种：一种是经典建造者模式，一种是变种建造者模式。我们逐个举例说明一下：

1.经典建造者模式代码示例：

建造一辆宝马汽车，同一个生产线，同一个生产流程，分别生产高配版和低配版车型。

1.1创建汽车模板类 MyCar， 分别有两个字段 引擎排量和最高时速

package com.builder;

public class MyCar {

    public String getEngine() {
        return engine;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public Integer getHightSpeed() {
        return hightSpeed;
    }

    public void setHightSpeed(Integer hightSpeed) {
        this.hightSpeed = hightSpeed;
    }

    private String engine;

    private Integer hightSpeed;

    @Override
    public String toString() {
        return "MyCar{" +
                "engine='" + engine + '\'' +
                ", hightSpeed=" + hightSpeed +
                '}';
    }
}

1.2创建生成线类，一个Interface接口 

public interface MyCarConfigBuilder {

    void setEngine();

    void setHightSpeed();

    MyCar getMyCar();

}

1.3 分别创建低配版车型配置和高配版车型配置

package com.builder;

public class MyCarHighConfig implements MyCarConfigBuilder {

    private MyCar myCar;


    MyCarHighConfig(){
        this.myCar = new MyCar();
    }

    @Override
    public void setEngine() {
        this.myCar.setEngine("2.0T");
    }

    @Override
    public void setHightSpeed() {
        this.myCar.setHightSpeed(200);
    }

    @Override
    public MyCar getMyCar() {
        return myCar;
    }
}
package com.builder;

public class MyCarLowConfig implements MyCarConfigBuilder {

    private MyCar myCar;


    MyCarLowConfig(){
        this.myCar = new MyCar();
    }

    @Override
    public void setEngine() {
        this.myCar.setEngine("2.0L");
    }

    @Override
    public void setHightSpeed() {
        this.myCar.setHightSpeed(160);
    }

    @Override
    public MyCar getMyCar() {
        return myCar;
    }
}

1.4创建生产工人类，按照生产指令生产汽车

package com.builder;

public class Director {


    private MyCarConfigBuilder myCarConfigBuilder;


    public void builder(MyCarConfigBuilder myCarConfigBuilder){
        this.myCarConfigBuilder = myCarConfigBuilder;
    }

    public void createCar(){
        myCarConfigBuilder.setEngine();
        myCarConfigBuilder.setHightSpeed();
    }

    public MyCar build(){
        return this.myCarConfigBuilder.getMyCar();
    }

}

1.5 测试汽车生产，生产一台高配车型

        Director director = new Director();

        director.builder(new MyCarHighConfig());

        director.createCar();

        MyCar build = director.build();

        System.out.println(build.toString());

程序输出：

MyCar{engine='2.0T', hightSpeed=200}

Process finished with exit code 0

2.变种构造者模式代码示例

如果我们创建一个类，这个类有许多参数，我们设置的参数每次可能不一样，难道我们要为每种情况创建一个构造函数吗，还是创建一个大而全的构造函数，其实我们可以直接使用JAVA8 函数式变成创建一个Builder来完成

2.1通用的Builder类

package com.builder;


import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class Builder<T> {

    private final Supplier<T> instantiator;

    private List<Consumer<T>> modifiers = new ArrayList<>();

    public Builder(Supplier<T> instantiator){
        this.instantiator = instantiator;
    }

    public static <T> Builder<T> of(Supplier<T> instantiator){
        return new Builder<>(instantiator);
    }

    public <P1> Builder<T> with(Consumer1<T, P1> consumer,P1 p1){
            Consumer<T> c = instance -> consumer.accept(instance,p1);
            modifiers.add(c);
            return this;
    }

    public <P1, P2> Builder<T> with(Consumer2<T, P1, P2> consumer,P1 p1, P2 p2){
        Consumer<T> c = instance -> consumer.accept(instance,p1, p2);
        modifiers.add(c);
        return this;
    }

    public <P1, P2, P3> Builder<T> with(Consumer3<T, P1, P2, P3> consumer,P1 p1,  P2 p2,  P3 p3){
        Consumer<T> c = instance -> consumer.accept(instance,p1, p2, p3);
        modifiers.add(c);
        return this;
    }

    public T build(){
        T value = instantiator.get();
        modifiers.forEach(modifiers -> modifiers.accept(value));
        modifiers.clear();
        return value;
    }


    @FunctionalInterface
    public interface  Consumer1<T, P1>{
        void accept(T t,P1 p1);
    }
    
    
    @FunctionalInterface
    public interface  Consumer2<T, P1, P2>{
        void accept(T t,P1 p1, P2 p2);
    }
    

    @FunctionalInterface
    public interface  Consumer3<T, P1, P2, P3>{
        void accept(T t,P1 p1, P2 p2, P3 p3);
    }

}

2.2 创建MyCar类

    public static void main(String[] args) {

        Builder.of(MyCar::new)
                .with(MyCar::setEngine,"20T")
                .with(MyCar::setHightSpeed, 200)
                .build();

    }

以上就是构造者模式主要思路和使用。