【修炼内功】[Java8] 使用Optional的正确姿势及序列化问题

本文已收录【修炼内功】跃迁之路

Java8的Optional为解决 '空' 的问题带来了很多新思路，查看 Optional 源码，实现非常简单，逻辑也并不复杂。 Stuart Marks 在其一次演讲中花了约1个小时的时间来讲述如何正确的使用Optional ( Optional - The Mother of All Bikesheds by Stuart Marks )，也有人调侃道 1 hour for Optional, you gotta be kidding me. 使用Optional不难，但用好Optional并不容易

Stuart Marks在演讲中提到了Optional的基本作用

Optional is intended to provide a limited mechanism for library method return types where there is a clear need to represent "no result", and where using null for that is overwhelmingly likely to cause errors .

在以往的编程模型中，对于“没有内容”，大多数情况需要使用null来表示，而null值总是被人忽略处理(判断)，从而在使用过程中极易引起NPE异常

Optional 的出现并不是为了替代 null ，而是用来表示一个不可变的容器，它可以包含一个非null的 T 引用，也可以什么都不包含(不包含不等于null)，非空的包含被称作 persent ，而空则被称作 absent

本质上讲Optional类似于异常检查，它迫使API用户去关注/处理Optional中是否包含内容，从而避免因为忽略null值检查而导致的一些潜在隐患

假设有一个函数用来根据ID查询学生信息 public Student search(Long id) ，现在有一个需求，需要根据ID查询学生姓名

public String searchName(Long id) {
    Student student = search(id);
    return student.getName();
}

注意，search函数是可能返回null的，在这种情况下searchName很有可能会抛出NPE异常

public String searchName(Long id) {
    Student student = search(id);
    return Objects.nonNull(student) ? student.getName() : "UNKNOWN";
}

除非特别明确函数的返回值不可能为null，否则一定要做null值检查，虽然这样写并没有增加太大的编码负担，但人总归是懒惰的，忽略检查的情况也总是会出现

如果我们改造search函数返回Optional， public Optional<Student> search(Long id) ，再来重写searchName函数

public String searchName(Long id) {
    Optional<Student> student = search(id);
    return student.getName();
}

这样的代码是编译不过的，它会强制让你去检查search返回的值是否有内容

public String searchName(Long id) {
    Optional<Student> student = search(id);
    return student.map(Student::getName).orElse("UNKNOWN");
}

Optional的使用可以参考其 API文档 ，以下内容假设您已了解如何使用Optional

但是否就应该消灭null，全部使用Optional来替代，回答当然是NO，null自有它的用武之地，Optional也并不是全能的

kotlin等语言，使用 ?. 符号来解决 java 中 if...else… 或 ... ? ... : ... 的啰嗦写法，如上问题可以使用 student?.name : null ，其语义为"当studen不为null时取其name属性值，否则取null值"，kotlin的语法只是简化了编程方式，让编程变得更"爽"，但并没有解决"人们容易忽略null值检查"的情况

Stuart Marks从5个不同的角度详细讲述了如何使用Optional，这里不一一叙述，有兴趣的可以直接跳到视频去看，下面将从Stuart Marks提到的7个Optional使用规范，来讲述如何正确使用/不要滥用Optional，最后重点解释一下【 为什么Optional不能序列化 】

0x00 使用规约

Rule 1: Never, ever, user null for an Optional variable or return value.

Optional也是一个引用类型(reference type)，其本身也可以赋值为null，如果我们在使用Optional的时候还要多做一层null检查，就违背了Optional的设计初衷，所以在任何时候都不要将Optional类型的变量或返回值赋值为null，我们希望的是在遇到Optional的时候不需要关心其是否为null，只需要判断其是否有值即可

public String searchName(Long id) {
    Optional<Student> student = search(id);
    if (Objects.isNull(student)) {
      // Optional可能为null，这严重违背了Optional的设计初衷
      return null;
    }
    return student.map(Student::getName).orElse("UNKNOWN");
}

Rule 2: Never user Optional.get() unless you can prove that the Optional is present.

如果Optional是absent(不包含任何值)的时候使用Optional.get()，会抛出 NoSuchElementException 异常，该接口的设计者也承认其设计的不合理，之后的某个jdk版本中可能会将其标记为 @Deprecated ，但还没有计划将其移除

public String searchName(Long id) {
    Optional<Student> student = search(id);
    // 直接使用get()，可能会抛NoSuchElementException异常
    return student.get().getName();
}

如果确实需要在Optional无内容的时候抛出异常，也请不要使用Optional.get()方法，而要使用Optional.getOrThrow()方法，主动指定需要抛出的异常，虽然该方法并未在jdk8中设计，但已经有计划在接下来的jdk版本中加入

Rule 3: Prefer alternatives to Optional.isPresent() and Optional.get().

如果一定要使用Optional.get()，请一定要配合isPresent()，先判断Optional中是否有值

public String searchName(Long id) {
    Optional<Student> student = search(id);
    // 如果一定要使用Optional.get()，请一定要配合isPresent()
    return student.isPresent() ? student.get().getName() : "UNKNOWN";
}

Rule 4: It's generally a bad idea to create an Optional for the specific purpose of chaining methods from it to get a value.

链式语法可以让代码的处理流程看起来更加清晰，但是为了链式而去使用Optional的话，在某些情况下并不会显得有多优雅

比如，本来可以使用三目运算

String process(String s) {
  return Objects.nonNull(s) ? s : "DEFAULT";
}

如果非要硬生生地使用链式的话

String process(String s) {
  return Optional.ofNullable(s).orElse("DEFAULT");
}

比如，本来可以使用if判断值的有效性

BigDecimal first = getFirstValue();
BigDecimal second = getSecondeValue();

if (Objects.nonNull(first) && Objects.nonNull(second)) {
  return first.add(second.get());
} else {
    return Objects.isNull(first) ? second : first;
}

如果非要使用链式

Optional<BigDecimal> first = getFirstValue();
Optional<BigDecimal> second = getSecondeValue();
return Stream.of(first, second)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .reduce(BigDecimal::add);

或者

Optional<BigDecimal> first = getFirstValue();
Optional<BigDecimal> second = getSecondeValue();
return first.map(b -> second.map(b::add).orElse(b))
            .map(Optional::of)
            .orElse(second);

从可读性及可维护性上来讲并没有提升，反而会带来一丝阅读困难，并且上文说过，Optional本身为引用类型，创建的Optional会进入堆内存，如果大量的不合理的使用Optional，也会在一定程度上影响JVM的堆内存及内存回收

Rule 5: If an Optional chain has a nested Optional chain, or has an intermediate result of Optional<Optional<T>>, it's probably too complex.

在使用Optional的时候，一定要保证Optional的简洁性，即Optional运算过程中所包含的类型既是最终需要的类型值，不要出现Optional嵌套的情况

Optional<BigDecimal> first = getFirstValue();
Optional<BigDecimal> second = getSecondeValue();

if (!first.isPresent && ! sencond.isPresent()) {
  return Optional.empty();
} else {
  return Optional.of(first.orElse(ZERO).add(second.orElse(ZERO)));
}

这样的写法，会对代码的阅读带来很大的困扰

Rule 6: Avoid using Optional in fields, method parameters, and collections.

尽量避免将Optional用于类属性、方法参数及集合元素中，因为以上三种情况，完全可以使用null值来代替Optional，没有必要必须使用Optional，另外Optional本身为引用类型，大量使用Optional会出现类似(这样描述不完全准确)封箱、拆箱的操作，在一定程度上会影响JVM的堆内存及内存回收

Rule 7: Avoid using identity-sensitive operations on Optionals.

首先需要解释，什么是 identity-sensitive ，可以参考 object identity and equality in java

identity-sensitive operations包含以下三种操作

==

Optional的JavaDoc中有这样一段描述

This is a value-based class; use of identity-sensitive operations (including reference equality(==), identity hash code, or synchronization) on instances of Optional may hava unpredictable results and should be avoided.

总结下来，就是要避免使用Optional的 == equals hashCode 方法

在继续之前，需要再解释一下什么是 value type

vale type，首先像一个类(至少从编码角度来讲)，但是却没有类中identity的概念，运行的时候却又和基本类型很相似

简单来说就是编码的时候像类，运行的时候像基本类型

显然，Optional目前还不是 value type ，而是 reference type ，我们查看Optional类的 equals 及 hashCode 方法，并没有发现有什么特别之处，但是有计划在接下来的某个jdk版本中将Optional定义为 value type

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }

    if (!(obj instanceof Optional)) {
        return false;
    }

    Optional<?> other = (Optional<?>) obj;
    return Objects.equals(value, other.value);
}

@Override
public int hashCode() {
    return Objects.hashCode(value);
}

在jdk8中使用Optional的 identity-sensitive operations 其实并没有太大问题，但很难保证，在今后的后一个jdk版本中将Optional定义为 value type 时不会出问题，所以为了兼容jdk升级程序逻辑的正确性，请避免使用Optional的 identity-sensitive operations

这也引出了Optional为什么不能序列化

0x01 序列化问题

首先，需要了解jdk中序列化的一些背景

• JDK rule: forward and backword serialization compatibility across releases

• If Optional were serializable today, it would be serialized as an Object

  • it'all always be serialized as an Object, even if eventually becomes a value type
• Serialization inherently depends on object identity

• Consequencds of Optional being serializable

  • it might prevent it from being converted into a value type in the future
  • deserializing and Optional might result in a "boxed" value type

• 首先，JDK的序列化比较特殊，需要同时 向前 及 向后 兼容，如在JDK7中序列化的对象需要能够在JDK8中反序列化，同样在JDK8中序列化的对象需要能够在JDK7中能够反序列化
• 其次，序列化需要依赖于对象的 identity

有了以上两个序列化的前提条件，我们再来看Optional，上面已将说过，虽然目前Optional是 reference type 的，但其被标记为 value based class ，有计划在今后的某一个JDK版本中将其实现为 value type

如果Optional可以序列化，那现在就有两个矛盾点

• 如果Optional可以序列化，那接下来的计划中，就没办法将Optional实现为 value type ，而必须是 reference type
• 或者将 value type 加入 identity-sensitive operations ，这对于目前所有已发行的JDK版本都是相冲突的

所以，虽然现在Optional是 reference type ，但有计划将其实现为 value type ，考虑到JDK序列化的 向前 及 向后 兼容性，从一开始就将Optional定为不可序列化，应该是最合适的方案了

如果真的有在类属性上使用Optional的需求怎么办？这里有两个替代方案/讨论可以参考

• Optional Pragmatic Approach
• Nothing is better than the Optional type