builder 构造器模式

构造器模式的原理与实现

常见于在构建一个复杂的对象，或者是构建一个复杂的表达式的时候，在开源框架中有大量广泛的运用给大家举个例子，Mockito框架中，when().thenReturn()之类的，其实就是构造器模式的一种，通过多个连续的方法完成一个模拟对象的构建；还有就是spring test框架汇总，MvcMock对象，也是通过thenExpected()等多个连续的方法，完成一个mvc测试对象的构建.

用构造器模式的最大好处是啥？

复杂对象的构建过程太复杂了，里面可能包含一些业务逻辑，比如值检查，格式转换之类的。如果每个客户端都自己手动去完成构建的话，那么大量的冗余代码是一个；另外一个，如果我们要改变对象的构建过程的实现，可以就在构造器中一个地方修改即可，对于调用方完全透明；最后，如果我们要完全替换掉以前的builder实现的话，那么完全可以在工厂里替换一个实现，还跟简单工厂模式结合起来使用了。

场景

构造一个复杂的对象，很多的属性，有些属性构造的时候需要做一些校验，格式转换

package wang.jinggo.basics.zhss.builder;

/**
 * @author: wangyj
 * @create: 2021-10-20
 * @version: 1.0.0
 **/
public class WithoutBuilderPatternDemo {

    public static void main(String[] args) {
        // 构造这个复杂的product对象
        Product product = new Product();
        // 设置field1属性
        System.out.println("在设置field1之前进行复杂的校验逻辑");
        product.setField1("值1");
        // 设置field2属性
        System.out.println("在设置field2之前进行复杂的数据格式转化逻辑");
        product.setField2("值2");
        // 设置field3属性
        System.out.println("在设置field3之前进行复杂的数据处理逻辑，跟其他对象的数据进行关联");
        product.setField3("值3");

        // 上面是简化的一个逻辑，实际上对于一些有几十个字段，甚至是上百个字段的复杂对象的构建
        // 上面那段代码会极度膨胀，非常复杂
        // 一个是说，大量代码堆积在一起，维护性非常差，可读性非常差，一坨代码，读不懂，没法改
        // 另外一个，就是说，这段逻辑，如果在多个地方都有使用的话，一旦这段逻辑出现了一些变化，那么可能就需要在多个地方修改
        // 把不同的构造的步骤，抽取成某一个方法
    }

    public static class Product {

        private String field1;
        private String field2;
        private String field3;

        public String getField1() {
            return field1;
        }

        public void setField1(String field1) {
            this.field1 = field1;
        }

        public String getField2() {
            return field2;
        }

        public void setField2(String field2) {
            this.field2 = field2;
        }

        public String getField3() {
            return field3;
        }

        public void setField3(String field3) {
            this.field3 = field3;
        }
    }
}

package wang.jinggo.basics.zhss.builder;

/**
 * @author: wangyj
 * @create: 2021-10-20
 * @version: 1.0.0
 **/
public class BuilderPatternDemo {

    public static class Product {

        private String field1;
        private String field2;
        private String field3;

        public String getField1() {
            return field1;
        }
        public void setField1(String field1) {
            this.field1 = field1;
        }
        public String getField2() {
            return field2;
        }
        public void setField2(String field2) {
            this.field2 = field2;
        }
        public String getField3() {
            return field3;
        }
        public void setField3(String field3) {
            this.field3 = field3;
        }

        @Override
        public String toString() {
            return "Product [field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + "]";
        }

    }

    public interface Builder {

        void field1(String value);
        void field2(String value);
        void field3(String value);
        Product create();
    }

    public static class ConcreteBuilder implements Builder {

        private Product product = new Product();

        public void field1(String value) {
            System.out.println("在设置field1之前进行复杂的校验逻辑");
            product.setField1(value);
        }

        public void field2(String value) {
            System.out.println("在设置field2之前进行复杂的数据格式转化逻辑");
            product.setField2(value);
        }

        public void field3(String value) {
            System.out.println("在设置field3之前进行复杂的数据处理逻辑，跟其他对象的数据进行关联");
            product.setField3(value);
        }

        public Product create() {
            return product;
        }

    }

    /**
     * director是面向builder的接口，来编程的
     * director可以复杂控制构建的一个步骤，具体的每个步骤的逻辑封装在具体的builder类中
     * 如果我们此时要更换一整套的构建逻辑，可以再搞一个新的builder类就可以了
     * 但是我们的整个构建步骤是没有任何改变的
     *
     * 如果整个构建步骤变化了，但是对构建的逻辑是没有影响的
     *
     */
    public static class Director {

        private Builder builder;

        public Director(Builder builder) {
            this.builder = builder;
        }

        public Product build(String field1, String field2, String field3) {
            builder.field1(field1);
            builder.field2(field2);
            builder.field3(field3);
            return builder.create();
        }

    }
}