阅读 2176

你一定不知道的链式调用新姿势

如何链式调用Java静态方法?

链式调用

首先需要提一下最近几年在开发界大🔥的链式调用,链式调用非常利于编写,更利于阅读,那么,什么是链式调用呢,为了扫盲,举个例子。

栗子

示例代码如下,如果我们想创建一个Dialog,不依赖链式调用的话,将会产生如下代码:

    NRStandardDialog.Builder nrStandardDialogBuilder = NRDialog.standard();

    nrStandardDialogBuilder.setTitle("Test");
    nrStandardDialogBuilder.setMessage("Test");
    nrStandardDialogBuilder.setNegativeTitle("Test");
    nrStandardDialogBuilder.setPositiveTitle("Test");
    nrStandardDialogBuilder.setNeutralTitle("Test");

    nrStandardDialogBuilder.show(this);
复制代码

上述代码共计372个字符,当然,通过依赖强大的IDEA,我们站在巨人的肩膀上操作,通过智能提示和自动补全,极大降低了开发成本。

那么,现在来估算一下操作成本,通过FreeKey记录键盘输入,我们的操作路径大概是

“NRdia .sta ; nr .set "Test; nr .setM "Test; nr .setnet ""Test; nr .setPo ""Test; nr .setneu "Test; nr .sh thi ;”
复制代码

共计需要输入126个字符,What?这样看好像其实也没有比全部输入少很多。

大腿

那么,我们将这个Dialog改为链式调用模式创建,会产生如下代码。

    NRDialog.standard()
            .setTitle("Test")
            .setMessage("Test")
            .setNegativeTitle("Test")
            .setPositiveTitle("Test")
            .setNeutralTitle("Test")
            .show(this);
复制代码

上述代码共计223个字符,减少了149个字符。怎么样,代码数量是不是一下子掉下来了很多。

3.png

那么,我们来统计一下链式调用的操作路径成本,再次通过FreeKey记录键盘输入,我们的操作路径大概是:

NRD .st .sett "Test.setme "Test.setneg "Test.setpo "Test.setNe "Test.sho thi ;
复制代码

共计需要输入94个字符,通过链式调用,我们节省了1.5倍的开发时间成本,并且隐形的节省了代码的阅读成本。

方法链的优秀案例

一些流行的开源库的方法链优秀使用案例如下:

RxJava

    Flowable.range(1, 10)
      .observeOn(Schedulers.computation())
      .map(v -> v * v)
      .blockingSubscribe(System.out::println);
复制代码

EventBus

    EventBus.builder()
            .eventInheritance(false)
            .logSubscriberExceptions(false)
            .build()
            .register(this);
复制代码

静态方法的链式调用

有些时候,我们会遇到一些需求,考虑想把静态方法进行封装一下,来实现优美的链式调用,Like this;

public class Test {

    public static Test doSth(){
        // dosth.
        return this;
    }
}
复制代码

如果是非静态方法的话,我们可以从容的返回this,如果是静态方法,这么操作,真的就是想太多。

4.png

或者我们这么操作?

5.png

这么操作?

6.png

R U OK?

7.png

一顿操作后,我们还是没法实现静态方法的链式调用,因为他必须返回一个自身的实例。

闹太套

好吧,最终屈服于IDEA,你反悔了这个静态方法的实例。

9.png

创建了一个Test类的实例,然后愉快地实现了链式调用

public class MainTest {

    public void test(){
        Test.doSth().doSth2();
    }
}
复制代码

可是问题来了,为了实现链式调用,我们必须为每个对象开辟内存空间吗?

10.jpeg

当然不!

姿势来了,其实我们可以这样处理:

public class Test {

    public static Test doSth(){
        return null;
    }

    public static Test doSth2(){
        return null;
    }
}
复制代码

定义两个静态方法,返回为空

public class MainTest {

    public void test(){
        Test.doSth().doSth2();
    }

}
复制代码

完美实现链式调用,而且不会报空指针,这是为什么?

原理分析

我们对上述调用代码的示例进行编译与反编译:

    public void test(){
        Test.doSth().doSth2();
    }
复制代码

对应的反编译后的字节码如下:

  public void test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: invokestatic  #2                  // Method com/Test.doSth:()Lcom/Test;
         3: pop
         4: invokestatic  #3                  // Method com//Test.doSth2:()Lcom/Test;
         7: pop
         8: return
      LineNumberTable:
        line 9: 0
        line 10: 8
复制代码

invokestatic调用静态方法doSth和doSth2,可以直接找到索引2和索引4的方法,所以并没有依赖Test实例。

而对于正常的对象调用,如果使用Null调用为什么会报空指针呢?我们再来看一段示例代码和其反编译的字节码。

声明mainTest为空并调用其test方法。

public void test2(){
    MainTest mainTest = null;
    mainTest.test();
}
复制代码

反编译后的字节码如下,invokevirtual为调用实例方法,动态绑定,invokevirtual #4代表会调用索引4的方法,即test()。

  public void test2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=1
         0: aconst_null  // 将null入栈
         1: astore_1     // 将引用存入局部变量表1中
         2: aload_1      // 将局部变量表1的对象引用压入栈顶
         3: invokevirtual #4     // Method com/MainTest.test:()V
         6: return
      LineNumberTable:
        line 25: 0
        line 26: 2
        line 27: 6
复制代码

而invokevirtual则负责找到操作栈栈顶元素所指向的对象并查找和调用其相关方法,但此时栈顶为空,自然就无法找到相关方法,抛出空指针。

而这里就涉及到了静态绑定和动态绑定。绑定过程,即指方法的调用与其类的关联过程。

其中的静态绑定,是在方法执行前,已经被关联,而动态绑定则是在运行时绑定。

最后

最后,在项目代码中还是并不推荐这种方式,团队开发,难免会有小伙伴们产生误解,会认为该对象已经生成了实例了,而创建非静态方法调用导致空指针。

关注下面的标签,发现更多相似文章
评论