Java函数式编程之Optional

前提

java.util.Optional是JDK8中引入的类,它是JDK从著名的Java工具包Guava中移植过来。本文编写的时候使用的是JDK11。Optional是一个包含了NULL值或者非NULL值的对象容器,它常用作明确表明没有结果(其实明确表明存在结果也可以用Optional表示)的方法返回类型,这样可以避免NULL值带来的可能的异常(一般是NullPointerException)。也就是说,一个方法的返回值类型是Optional,则应该避免返回NULL,而应该让返回值指向一个包含NULL对象的Optional实例。Optional的出现为NULL判断、过滤操作、映射操作等提供了函数式适配入口,它算是Java引入函数式编程的一个重要的里程碑。

本文新增一个Asciidoc的预览模式,可以体验一下Spring官方文档的感觉:

Optional各个方法源码分析和使用场景

Optional的源码比较简单,归根于它是一个简单的对象容器。下面会结合源码分析它的所有构造、属性、方法和对应的使用场景。

Optional属性和构造

Optional的属性和构造如下:

public final class Optional<T> {

// 这个是通用的代表NULL值的Optional实例
private static final Optional<?> EMPTY = new Optional<>();

// 泛型类型的对象实例
private final T value;

// 实例化Optional,注意是私有修饰符,value置为NULL
private Optional() {
this.value = null;
}

// 直接返回内部的EMPTY实例
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}

// 通过value实例化Optional,如果value为NULL则抛出NPE
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}

// 通过value实例化Optional,如果value为NULL则抛出NPE,实际上就是使用Optional(T value)
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}

// 如果value为NULL则返回EMPTY实例,否则调用Optional#of(value)
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}

// 暂时省略其他代码
}

如果明确一个对象实例不为NULL的时候,应该使用Optional#of(),例如:

Order o = selectByOrderId(orderId);
assert null != o
Optional op = Optional.of(o);

如果无法明确一个对象实例是否为NULL的时候,应该使用Optional#ofNullable(),例如:

Optional op = Optional.ofNullable(selectByOrderId(orderId));

明确表示一个持有NULL值的Optional实例可以使用Optional.empty()

get()方法

// 如果value为空,则抛出NPE,否则直接返回value
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}

get()方法一般是需要明确value不为NULL的时候使用,它做了先验value的存在性。例如:

Order o = selectByOrderId(orderId);
assert null != o
Optional op = Optional.of(o);
Order value = op.get();

isPresent()方法

// 判断value是否存在,不为NULL则返回true,如果为NULL则返回false
public boolean isPresent() {
return value != null;
}

举个例子:

Order o = selectByOrderId(orderId);
boolean existed = Optional.ofNullable(o).isPresent();

isEmpty()方法

isEmpty()是JDK11引入的方法,是isPresent()的反向判断:

// 判断value是否存在,为NULL则返回true,为非NULL则返回false
public boolean isEmpty() {
return value == null;
}

ifPresent()方法

ifPresent()方法的作用是:如果value不为NULL,则使用value调用消费者函数式接口的消费方法Consumer#accept()

public void ifPresent(Consumer<? super T> action) {
if (value != null) {
action.accept(value);
}
}

例如:

Optional.ofNullable(selectByOrderId(orderId)).ifPresent(o-> LOGGER.info("订单ID:{}",o.getOrderId());

ifPresentOrElse()方法

ifPresentOrElse()方法是JDK9新增的方法,它是ifPresent()方法的加强版,如果value不为NULL,则使用value调用消费者函数式接口的消费方法Consumer#accept(),如果valueNULL则执行Runnable#run()

public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
if (value != null) {
action.accept(value);
} else {
emptyAction.run();
}
}

例如:

String orderId = "xxxx"; 
Optional.ofNullable(selectByOrderId(orderId)).ifPresentOrElse(o-> LOGGER.info("订单ID:{}",o.getOrderId()), ()-> LOGGER.info("订单{}不存在",o.getOrderId()));

filter()方法

public Optional<T> filter(Predicate<? super T> predicate) {
// 判断predicate不能为NULL
Objects.requireNonNull(predicate);
// value为NULL,说明是空实例,则直接返回自身
if (!isPresent()) {
return this;
} else {
// value不为NULL,则通过predicate判断,命中返回自身,不命中则返回空实例empty
return predicate.test(value) ? this : empty();
}
}

这个方法的功能是简单的过滤功能,容器持有对象valueNULL会做一次判断,决定返回自身实例还是empty()。例如:

Optional.ofNullable(selectByOrderId(orderId)).filter(o -> o.getStatus() == 1).ifPresent(o-> LOGGER.info("订单{}的状态为1",o.getOrderId));

map()方法

map()是简单的值映射操作:

public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
// 判断mapper不能为NULL
Objects.requireNonNull(mapper);
// value为NULL,说明是空实例,则直接返回empty()
if (!isPresent()) {
return empty();
} else {
// value不为NULL,通过mapper转换类型,重新封装为可空的Optional实例
return Optional.ofNullable(mapper.apply(value));
}
}

API注释里面的一个例子:

List<URI> uris = ...;
// 找到URI列表中未处理的URI对应的路径
Optional<Path> p = uris.stream().filter(uri -> !isProcessedYet(uri)).findFirst().map(Paths::get);

flatMap()方法

flatMap()方法也是一个映射操作,不过映射的Optional类型返回值直接由外部决定,不需要通过值重新封装为Optional实例:

public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
// mapper存在性判断
Objects.requireNonNull(mapper);
// value为NULL,说明是空实例,则直接返回empty()
if (!isPresent()) {
return empty();
} else {
// value不为NULL,通过mapper转换,直接返回mapper的返回值,做一次空判断
@SuppressWarnings("unchecked")
Optional<U> r = (Optional<U>) mapper.apply(value);
return Objects.requireNonNull(r);
}
}

例如:

class OptionalOrderFactory{

static Optional<Order> create(String id){
//省略...
}
}

String orderId = "xxx";
Optional<Order> op = Optional.of(orderId).flatMap(id -> OptionalOrderFactory.create(id));

or()方法

public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
// supplier存在性判断
Objects.requireNonNull(supplier);
// value不为NULL,则直接返回自身
if (isPresent()) {
return this;
} else {
// value为NULL,则返回supplier提供的Optional实例,做一次空判断
@SuppressWarnings("unchecked")
Optional<T> r = (Optional<T>) supplier.get();
return Objects.requireNonNull(r);
}
}

例如:

Order a = null;
Order b = select();
// 拿到的就是b订单实例包装的Optional
Optional<Order> op = Optional.ofNullable(a).or(b);

stream()方法

// 对value做NULL判断,转换为Stream类型
public Stream<T> stream() {
if (!isPresent()) {
return Stream.empty();
} else {
return Stream.of(value);
}
}

orElse()方法

// 值不为NULL则直接返回value,否则返回other
public T orElse(T other) {
return value != null ? value : other;
}

orElse()就是常见的提供默认值兜底的方法,例如:

String v1 = null;
String v2 = "default";
// 拿到的就是v2对应的"default"值
String value = Optional.ofNullable(v1).orElse(v2);

orElseGet()方法

// 值不为NULL则直接返回value,否则返回Supplier#get()
public T orElseGet(Supplier<? extends T> supplier) {
return value != null ? value : supplier.get();
}

orElseGet()只是orElse()方法的升级版,例如:

String v1 = null;
Supplier<String> v2 = () -> "default";
// 拿到的就是v2对应的"default"值
String value = Optional.ofNullable(v1).orElseGet(v2);

orElseThrow()方法

// 如果值为NULL,则抛出NoSuchElementException,否则直接返回value
public T orElseThrow() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}

// 如果值不为NULL,则直接返回value,否则返回Supplier#get()提供的异常实例
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}

例如:

Optional.ofNullable(orderInfoVo.getAmount()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId())));

equals()和hashCode()方法

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);
}

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

这两个方法都是比较value,说明了Optional实例如果使用于HashMap的KEY,只要value相同,对于HashMap就是同一个KEY。如:

Map<Optional,Boolean> map = new HashMap<>();
Optional<String> op1 = Optional.of("throwable");
map.put(op1, true);
Optional<String> op2 = Optional.of("throwable");
map.put(op2, false);
// 输出false
System.out.println(map.get(op1));

Optional实战

下面展示一下Optional的一些常见的使用场景。

空判断

空判断主要是用于不知道当前对象是否为NULL的时候,需要设置对象的属性。不使用Optional时候的代码如下:

if(null != order){
order.setAmount(orderInfoVo.getAmount());
}

使用Optional时候的代码如下:

Optional.ofNullable(order).ifPresent(o -> o.setAmount(orderInfoVo.getAmount()));

// 如果判断空的对象是OrderInfoVo如下
Order o = select();
OrderInfoVo vo = ...
Optional.ofNullable(vo).ifPresent(v -> o.setAmount(v.getAmount()));

使用Optional实现空判断的好处是只有一个属性设值的时候可以压缩代码为一行,这样做的话,代码会相对简洁。

断言

在维护一些老旧的系统的时候,很多情况下外部的传参没有做空判断,因此需要写一些断言代码如:

if (null == orderInfoVo.getAmount()){
throw new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId()));
}
if (StringUtils.isBlank(orderInfoVo.getAddress()){
throw new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId()));
}

使用Optional后的断言代码如下:

Optional.ofNullable(orderInfoVo.getAmount()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId())));
Optional.ofNullable(orderInfoVo.getAddress()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId())));

综合仿真案例

下面是一个仿真案例,模拟的步骤如下:

  • 给出客户ID列表查询客户列表。
  • 基于存在的客户列表中的客户ID查询订单列表。
  • 基于订单列表转换为订单DTO视图列表。
@Data
static class Customer {

private Long id;
}

@Data
static class Order {

private Long id;
private String orderId;
private Long customerId;
}

@Data
static class OrderDto {

private String orderId;
}

// 模拟客户查询
private static List<Customer> selectCustomers(List<Long> ids) {
return null;
}

// 模拟订单查询
private static List<Order> selectOrders(List<Long> customerIds) {
return null;
}

// main方法
public static void main(String[] args) throws Exception {
List<Long> ids = new ArrayList<>();
List<OrderDto> view = Optional.ofNullable(selectCustomers(ids))
.filter(cs -> !cs.isEmpty())
.map(cs -> selectOrders(cs.stream().map(Customer::getId).collect(Collectors.toList())))
.map(orders -> {
List<OrderDto> dtoList = new ArrayList<>();
orders.forEach(o -> {
OrderDto dto = new OrderDto();
dto.setOrderId(o.getOrderId());
dtoList.add(dto);
});
return dtoList;
}).orElse(Collections.emptyList());
}

小结

Optional本质是一个对象容器,它的特征如下:

  1. Optional作为一个容器承载对象,提供方法适配部分函数式接口,结合部分函数式接口提供方法实现NULL判断、过滤操作、安全取值、映射操作等等。
  2. Optional一般使用场景是用于方法返回值的包装,当然也可以作为临时变量从而享受函数式接口的便捷功能。
  3. Optional只是一个简化操作的工具,可以解决多层嵌套代码的节点空判断问题(例如简化箭头型代码)。
  4. Optional并非银弹。

这里提到箭头型代码,下面尝试用常规方法和Optional分别解决:

// 假设VO有多个层级,每个层级都不知道父节点是否为NULL,如下
// - OrderInfoVo
// - UserInfoVo
// - AddressInfoVo
// - address(属性)
// 假设我要为address属性赋值,那么就会产生箭头型代码。


// 常规方法
String address = "xxx";
OrderInfoVo o = ...;
if(null != o){
UserInfoVo uiv = o.getUserInfoVo();
if (null != uiv){
AddressInfoVo aiv = uiv.getAddressInfoVo();
if (null != aiv){
aiv.setAddress(address);
}
}
}

// 使用Optional
String address = "xxx";
OrderInfoVo o = null;
Optional.ofNullable(o)
.map(OrderInfoVo::getUserInfoVo)
.map(UserInfoVo::getAddressInfoVo)
.ifPresent(a -> a.setAddress(address));

使用Optional解决箭头型代码,通过映射操作map()能减少大量的ifNULL判断分支,使得代码更加简洁。

有些开发者提议把DAO方法的返回值类型定义为Optional,笔者对此持中立态度,原因是:

  1. Optional是JDK1.8引入,低版本的JDK并不能使用,不是所有的系统都能平滑迁移到JDK1.8+。
  2. 并不是所有人都热衷于函数式编程,因为它带来了便捷的同时转变了代码的阅读逻辑(有些人甚至会认为降低了代码的可读性)。

附件

(本文完 c-2-d e-a-20190805 by throwable)

文章作者: throwable
文章链接: http://www.throwable.club/2019/08/07/java-functional-programming-optional/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Throwable
❤支付宝打赏❤
❤微信打赏❤