Elasticsearch8的java开发起步篇（builder pattern）

Java
289
0
0
2024-01-27
不可变性：被忽视却很重要的东西，很神奇的final关键字
上一篇
线程池-从零到一了解并掌握线程池
下一篇
标签   Elasticsearch

关于《java与es8实战》系列

  • 如标题所述，本文从一个java程序员视角去学习和实践elasticsearch的8.2版本，目标是与大家一起掌握与elasticsearch开发相关的技能，以应对实际应用中的需求和挑战
  • 纵观欣宸过往各种系列的技术文章，对一个特定技术的起步无外乎两种套路
  1. 第一种是对该系列的主题做重点介绍，把重点、背景说清楚
  2. 第二种更加实在，就是准备工作，例如安装相关的软件，介绍对应版本，甚至写个初级的hello world
  • 那么今天的文章该是哪种风格？是介绍elasticsearch8？还是动手部署一套es集群？亦或是用java写一套简单的增删改查代码，让大家可以快速入门？
  • 这个问题难住我了，思考良久，想到了自己刚开始写es代码时的困惑，那时去看es的java库源码中的单元测试部分，研究如何调用java库的api，看到那里是这么写代码的，例如创建索引的操作，创建请求对象会用到builder

  • 再随意逛到了批量操作的代码，如下图，还是builder

  • 最常用的聚合查询，如下图，也离不开builder

  • 于是我就纳闷了：以后写es相关的代码，这builder操作难道会一直伴随我？
  • 去翻阅es的官方文档，发现说的很清楚：Java客户端中的数据对象都是不可变的，这些数据对象在创建时用的是2008版本《Effective Java》中的builder模式

  • 回忆了这么多，我终于想清楚起步的内容了：咱们不急着部署ES，也不急着写增删改查的入门级代码，搞清楚以下问题：
  1. 直接用构造方法创建对象有什么问题？
  2. 用静态方法创建对象有什么问题？
  3. builder模式是什么？
  4. builder模式解决了什么问题？
  5. builder模式自己有啥问题？
  6. es API和builder有啥关系？
  • 等咱们搞清楚这些问题，写代码操作es时遇到builder就不再疑惑，而是感受到builder带来的好处，进而养成习惯，在今后设计不可变类时自然而然的用上builder模式，那时候您不一定还在用es，然而builder模式可以长久陪伴您，因为，经典就是经典，如下图

  • 现在，咱们java程序员的es8开发之旅，就从经典的builder pattern出发

不可变对象（Immutable Objects）

  • es的API中的对象都是不可变的(immutable)，关于不可变，简单的说就是： 实例一旦创建后，不能改变其成员变量的值
  • 本篇文章讨论的创建对象， 都是指的不可变对象

三种创建对象的常用方法

  • 这三种分别是
  1. 构造方法
  2. 静态工厂方法
  3. builder模式

直接用构造方法创建对象有什么问题

  • 创建一个对象，最常用的方法不就是构造方法么？new Object()不香吗？
  • 成员变量很多的时候，构造方法就没那么香了，举例如下，NutritionFacts是食品包装外面显示的营养成分标签，这里面有的营养成分是必须的：每一份的含量、每一罐的含量，其他的可选 
 <pre class="prettyprint hljs java" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public class NutritionFacts {
    private final int servingSize;  // (mL)            required
    private final int servings;     // (per container) required
    private final int calories;     //                 optional
    private final int fat;          // (g)             optional
    private final int sodium;       // (mg)            optional
    private final int carbohydrate; // (g)             optional

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings,);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories) {
        this(servingSize, servings, calories,);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat) {
        this(servingSize, servings, calories, fat,);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium,);
    }

    public NutritionFacts(int servingSize, int servings,
           int calories, int fat, int sodium, int carbohydrate) {
        this.servingSize  = servingSize;
        this.servings     = servings;
        this.calories     = calories;
        this.fat          = fat;
        this.sodium       = sodium;
        this.carbohydrate = carbohydrate;
    }
}
</pre>
  • 从上面的代码可见，为了尽量满足用户需要，NutritionFacts提供了多个构造方法给用户使用，其实相信您也明白这里面的问题：这简直是成员变量的各种排列组合呀，以后要是加字段就麻烦了
  • 再以一个使用者的视角来看看，实例化代码如下，这就有点晕了，这一眼看过去，谁知道240给了哪个字段？只能去核对构造方法的入参声明 
 <pre class="prettyprint hljs fsharp" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
</pre>
  • 缓解上述问题的一种方法是使用JavaBeans模式，用无参构造方法，然后按照调用setXXX设置每个所需字段，示例如下所示 
 <pre class="prettyprint hljs fsharp" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize();
cocaCola.setServings();
cocaCola.setCalories();
cocaCola.setSodium();
cocaCola.setCarbohydrate();
</pre>
  • 上述方法似乎不错，哪些字段被设置一目了然，所以，成员变量多的时候，用上述方法是正确选择吗？
  • 然而，《Effective Java》原著对上述做法的评价是 有着严重的弊端 （the JavaBeans pattern has serious disadvantages of its own），所以，尽早放弃吧…咱们来看看具体有啥问题
  1. 首先，直观的看，这种做法违背了不可变对象的定义，创建出对象后，又用setXXX方法改变了成员变量
  2. 《Effective Java》的原话是在构造过程中JavaBean可能处于不一致的中的状态，我的理解如下图所示，不用颜色代表不同线程，可以看到，红色线程获取calories的值的时候，蓝色线程还没有开始设置calories的值，所以红色线程拿到的等于初始值0，这显然是不对的，正常逻辑应该是：只要cocaCola对象非空，其calories字段对外显示的值就是100

  1. 经验丰富的您应该想到了这是典型的线程同步问题，应该用synchronize或ReentrantLock给蓝色代码段加锁，让红色代码先block住，直到蓝色代码执行完毕，这样就能拿到正确的值了—这种方法显然可以解决问题，然而《Effective Java》预判了您的预判：这种方式十分笨拙，在实践中很少使用，想想也是，创建和使用对象是最常见的编码了，这个思路要加多少synchronize或ReentrantLock
  • 所以构造方法不能满足我们的实际需要，再来看看静态工厂方法，它的优势在哪里

静态工厂方法的优势

  • 相比静态工厂方法，构造方法存在以下五个典型问题
  1. 随着入参的不同，构造方法可以有多个，如下所示，然而都是同名的，这会给用户造成困惑，此刻用静态工厂方法，可以自由设置方法名（例如createWithName或者createWithAge），让用户更方便的选择合适的方法 
 <pre class="prettyprint hljs cpp" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }
</pre>
  1. 使用构造方法意味着创建对象，而有时候我们只想使用，并不在乎对象本身是否是新建的，下面是Boolean.valueOf方法的源码，此处并未新建Boolean对象： 
 <pre class="prettyprint hljs gradle" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public static Boolean valueOf(String s) {
        return parseBoolean(s) ? TRUE : FALSE;
    }
</pre>
  1. 以动物类Animal.class为例，Animal类的构造方法创建的对象Animal的实例，而静态工厂方法的返回值声明虽然是Animal，但实际返回的实例可以是Animal的子类，例如Dog
  2. 静态工厂方法内部可以有灵活的逻辑来决定返回那种子类的实例，来看的静态工厂方法源码，根据底层枚举类型的大小来决定是返回RegularEnumSet实例还是JumboEnumSet实例 
 <pre class="prettyprint hljs php" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
        Enum<?>[] universe = getUniverse(elementType);
        if (universe == null)
            throw new ClassCastException(elementType + " not an enum");

        if (universe.length <=)
            return new RegularEnumSet<>(elementType, universe);
        else
            return new JumboEnumSet<>(elementType, universe);
    }
</pre>
  1. 静态工厂方法还有一个优势：方法返回对象所属的类，在编写此静态方法时可以不存在，这句话有点晦涩，可以回想一下JDBC的获取connection的API，在编写此API的时候，并不需要知道MySQL的driver实现
  • 以上的比较暴露出构造方法的缺陷，此时静态工厂方法更加合适，然而，静态工厂方法就这么完美吗？

静态工厂方法的不足

  • 只有最合适的，没有最好的，静态工厂方法也有自己的不足
  1. 当您开发一个类时，如果决定对外提供静态工厂方法，那么将构造方法设为私有，就可以让用户只能选择静态工厂方法了，代码如下所示，然而，这样的Student类就无法被继承 
 <pre class="prettyprint hljs java" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public class Student {
    private String name;

    private int age;

    public void setName(String name) {
        this.name = name;
    }

    private Student() {

    }

    public static Student newInstance(String name) {
        Student student = new Student();
        student.setName(name);

        return student;
    }
}
</pre>
  1. 一个类的代码中，可能已有一些静态方法，再加入静态工厂方法，一堆静态方法混杂在一起，用户从中找出静态工厂方法怕是不容易

builder pattern

  • 看过了构造方法和静态工厂方法，认识到它们的不足，终于该第三种方法登场了
  • builder pattern，《Effective Java》中文版译作建造者模式，用builder对象来创建真正的对象实例，前面提到的构造方法和静态工厂的不足，在builder pattern这里都得到了改善
  • 来看代码吧，以刚才的NutritionFacts为例，使用builder pattern后的代码如下，新增一个静态成员类Builder，可以设置Builder的每个成员变量，最后调用其build方法的时候，才真正创建NutritionFacts对象 
 <pre class="prettyprint hljs java" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories      =;
        private int fat           =;
        private int carbohydrate  =;
        private int sodium        =;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings    = servings;
        }

        public Builder calories(int val) { calories = val;      return this; }
        public Builder fat(int val) { fat = val;           return this; }
        public Builder carbohydrate(int val) { carbohydrate = val;  return this; }
        public Builder sodium(int val) { sodium = val;        return this; }

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

    private NutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}
</pre>
  • 以一个使用者的视角来看如何创建NutritionFacts对象，如下所示，流畅的写法，那些字段被设置以及具体的值都一目了然，最终build方法才会创建NutritionFacts对象，而且这是个不可变对象 
 <pre class="prettyprint hljs fsharp" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
                              .calories()
                              .sodium()
                              .carbohydrate()
                              .build();
</pre>

builder pattern自身的问题和适用场景

  • 即便能解决构造方法和静态工厂自身的一些问题，builder pattern也不是万能的，缺点很明显：创建对象之前，先要创建builder对象，这在一些性能要求高、资源限制苛刻的场景中就不适合了
  • 另外builder pattern适合的场景是成员变量多的时候，而这个所谓的多究竟如何理解呢？这可能是个小马过河的问题吧：见惯了几十个成员变量的类，再去看十几个成员变量的类，可能会有种很清爽的感觉，呃，扯远了，其实《Effective Java》的说法是四个或者更多个参数，就适合用builder apttern了

elasticsearch API中的builder

  • 终于到达重点了：接下来的es之旅，会遇到什么样的builder？咱们该怎么用它？
  • 先总结builder的使用套路，其实在es中的builder也是按照套路去用的，如下图，其实很简单，三步走而已，暂时把下图称为 套路图 ，后面还会提到

  • 看看es API的用法，以es自己的单元测试代码为例，如下图所示，创建一个索引时，会指向红色箭头所指的create方法

  • 来看看create的源码，入参是个Function，里面执行了function的apply，这是个典型的lambda表达式作为入参 
 <pre class="prettyprint hljs php" style="padding:.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto;">public final CreateIndexResponse create(Function<CreateIndexRequest.Builder, ObjectBuilder<CreateIndexRequest>> fn)
            throws IOException, ElasticsearchException {
        return create(fn.apply(new CreateIndexRequest.Builder()).build());
    }
</pre>
  • Function的两个泛型，第一个表示入参，第二个表示返回，对于create方法的用户来说，这就有意思了：
  1. 咱们在写这个lambda表达式时，入参是builder对象，这可以从上面的代码中看到（即apply方法的入参），也就是说套路图中的第一步：创建builder对象，已经被create方法内部做好了
  2. 再看看上面的截图中，lambda表达式做了什么？ b.index(“my-index”)，这里可以按照实际业务需要调用builder的多个方法来来设置参数，所以套路图中的第二步，需要咱们在lambda表达式中完成，这很合理：需要设置哪些参数只有用户最清楚
  3. 最后，也是最巧妙的地方，就是上面的create方法源码中的.build()，因为fn.apply方法的实现是调用者写的，例如刚才写的是 b.index(“my-index”)，这个index方法的返回值就是build实例，所以fn.apply(xxx).build()就是套路图中的第三步：builder的build方法被执行了，真正的对象，即CreateIndexRequest对象此刻被创建，这也被es内部给做好了

  • 经历了本文，今后在写es操作代码时，面对各种builder和lambda，相信您不再迷茫，取而代之的是模式的欣赏和品味，以及本就该如此的感悟
  • 网络上写es开发的系列文章并不少，builder做开篇的，应该独一无二了…吧
不可变性：被忽视却很重要的东西，很神奇的final关键字
上一篇
线程池-从零到一了解并掌握线程池
下一篇