Java 优雅判空的方法

为了避免 NullPointerException 出现，我们经常会进行如下操作。

if (object != null) {
    object.do();
}

那么每次使用一个不确定的对象，都需要进行一次判空。so:

可能你会想，项目中肯定不止你一个人会这样一顿操作，然后按下 Ctrl+Shift+F，真相就在眼前：

What，我们有接近一万行的代码都是在判空？

那么我们不禁会想有什么办法可以避免在代码中写大量的判空语句呢？

当然我们可以使用 JDK8 提供的 Optional 来避免判空，但是用起来还是有些麻烦。

进入正题，这里将依托于一个小需求来介绍一个封装工具类，可以实现链式调用对象成员而无需判空，相比原有的if null 逻辑 和 JDK8 提供的 Optional 更加优雅易用，在工程实践中大大提高了编码效率，也让代码更加的精准和优雅。

需求介绍

我们有一个 User 类，里面有成员变量 School 类，School 类有字符串类型的成员变量 scName

而我们的需求就是通过 User 对象，获取其内的 School 对象的 scName 学校名称值。此时我们势必要判断 User 对象和其内的 School 对象是否为空，才能直接获取 scName 值。

/**
* @author cjh
* @date Created on 2020/10/29
* @summary 一个 User 类定义
* （Ps：Data 是lombok组件提供的注解，简化了get set等等的约定代码）
*/
@Data
public class User {

    private String name;

    private String gender;

    private School school;
}

@Data
public static class School {

    private String scName;

    private String adress;
}

不优雅的判空调用

现在想要获得School的成员变量 adress , 一般的处理方式：

/**
 * @author cjh
 * @date Created on 2020/10/21
 * @summary 获取 User 类的 School 对象的校名值
 */
public class Test {
    public static void main(String[] args) throws Exception {
        User cjh = new User();
        School school = new School();
        cjh.setSchool(school);
        school.setAdress("林伟华中学");

        if (Objects.nonNull(cjh) && Objects.nonNull(cjh.getSchool())) {
            School cjhSc = cjh.getSchool();
            System.out.println(userSc.getAdress());
        }
    }
}

OptionalBean 工具类

/**
* @author cjh
* @since 2020-10-29
* @summary 链式调用 bean 中 value 的方法
*/
public final class OptionalBean<T> {
	
    private static final OptionalBean<?> EMPTY = new OptionalBean<>();

    private final T value;

    private OptionalBean() {
        this.value = null;
    }

    /**
     * 空值会抛出空指针
     * @param value
     */
    private OptionalBean(T value) {
        this.value = Objects.requireNonNull(value);
    }

    /**
     * 包装一个不能为空的 bean
     * @param value
     * @param 
     * @return
     */
    public static <T> OptionalBean<T> of(T value) {
        return new OptionalBean<>(value);
    }

    /**
     * 包装一个可能为空的 bean
     * @param value
     * @param 
     * @return
     */
    public static <T> OptionalBean<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    /**
     * 取出具体的值
     * @param fn
     * @param 
     * @return
     */
    public T get() {
        return Objects.isNull(value) ? null : value;
    }

    /**
     * 取出一个可能为空的对象
     * @param fn
     * @param 
     * @return
     */
    public <R> OptionalBean<R> getBean(Function<? super T, ? extends R> fn) {
        return Objects.isNull(value) ? OptionalBean.empty() : OptionalBean.ofNullable(fn.apply(value));
    }

    /**
     * 如果目标值为空 获取一个默认值
     * @param other
     * @return
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

    /**
     * 如果目标值为空 通过lambda表达式获取一个值
     * @param other
     * @return
     */
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    /**
     * 如果目标值为空 抛出一个异常
     * @param exceptionSupplier
     * @param 
     * @return
     * @throws X
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

    public boolean isPresent() {
        return value != null;
    }

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

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

    /**
     * 空值常量
     * @param 
     * @return
     */
    public static<T> OptionalBean<T> empty() {
        @SuppressWarnings("unchecked")
        OptionalBean<T> none = (OptionalBean<T>) EMPTY;
        return none;
    }

}

工具设计主要参考了 Optional 的实现，再加上对链式调用的扩展就是上述的OptionalBean。

getBean 其实是当变量为空时返回了一个 包装空值的 OptionalBean 对象，同时泛型的使用让工具更加易用。

链式调用成员变量：

public static void main(String[] args) {
    User cjh = new User();
    School school = new School();
    cjh.setSchool(school);
    school.setAdress("林伟华中学");

    // 1. 基本调用
    String value1 = OptionalBean.ofNullable(cjh)
            .getBean(User::getSchool)
            .getBean(School::getAdress)
            .get();
    System.out.println(value1);

    // 2. 扩展的 isPresent方法 用法与 Optional 一样
    boolean present = OptionalBean.ofNullable(cjh)
            .getBean(User::getSchool)
            .getBean(School::getAdress)
            .isPresent();
    System.out.println(present);

    // 3. 扩展的 ifPresent 方法
    OptionalBean.ofNullable(cjh)
            .getBean(User::getSchool)
            .getBean(School::getAdress)
            .ifPresent(address -> System.out.println(String.format("地址存在:%s", address)));

    // 4. 扩展的 orElse
    String value2 = OptionalBean.ofNullable(cjh)
            .getBean(User::getSchool)
            .getBean(School::getAdress)
            .orElse("搬砖打工");
    System.out.println(value2);

    // 5. 扩展的 orElseThrow
    try {
        String value3 = OptionalBean.ofNullable(cjh)
                .getBean(User::getSchool)
                .getBean(School::getAdress)
                .orElseThrow(() -> new RuntimeException("空指针了"));
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}