求求你，不要再使用!=null判空了！

本文来自作者投稿，原作者：上帝爱吃苹果

对于Java程序员来说，null是令人头痛的东西。时常会受到空指针异常(NPE)的骚扰。连Java的发明者都承认这是他的一项巨大失误。

那么，有什么办法可以避免在代码中写大量的判空语句呢?

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

作者在日常工作中，封装了一个工具，可以可以链式调用对象成员而无需判空，相比原有的if null逻辑 和 JDK8提供的 Optional 更加优雅易用，在工程实践中大大提高了编码效率，也让代码更加的精准和优雅。

不优雅的判空调用

我想从事Java开发的小伙伴肯定有遇到过下面这种让人难受的判空逻辑：现在有一个User类，School 是它的成员变量

 
 
@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 , 一般的处理方式：

public static void main(String[] args) { 
 
    User axin = new User(); 
 
    User.School school = new User.School(); 
 
    axin.setName("hello"); 
 
    if (Objects.nonNull(axin) && Objects.nonNull(axin.getSchool())) { 
 
        User.School userSc = axin.getSchool(); 
 
        System.out.println(userSc.getAdress()); 
 
    } 
 
} 

获取adress时要对School进行判空，虽然有些麻烦，到也能用，通过 JDK8 提供的 Optional 工具也是可以，但还是有些麻烦。

而下文的 OptionalBean 提供一种可以链式不断地调用成员变量而无需判空的方法，直接链式调用到你想要获取的目标变量，而无需担心空指针的问题。

链式调用成员变量

如果用了本文设计的工具 OptionalBean ，那么上述的调用可以简化成这样：

public static void main(String[] args) { 
 
    User axin = new User(); 
 
    User.School school = new User.School(); 
 
    axin.setName("hello"); 
 
    // 1. 基本调用 
 
    String value1 = OptionalBean.ofNullable(axin) 
 
            .getBean(User::getSchool) 
 
            .getBean(User.School::getAdress).get(); 
 
    System.out.println(value1); 
 
} 

执行结果：

其中User的school变量为空，可以看到代码并没有空指针，而是返回了null。这个工具怎么实现的呢?

OptionalBean 工具

 
 
public final class OptionalBean<T> { 
 
    private static final OptionalBean<?> EMPTY = new OptionalBean<>(); 
 
    private final T value; 
 
    private OptionalBean() { 
 
        this.value = null; 
 
    } 
 
     
 
    private OptionalBean(T value) { 
 
        this.value = Objects.requireNonNull(value); 
 
    } 
 
     
 
    public static <T> OptionalBean<T> of(T value) { 
 
        return new OptionalBean<>(value); 
 
    } 
 
     
 
    public static <T> OptionalBean<T> ofNullable(T value) { 
 
        return value == null ? empty() : of(value); 
 
    } 
 
     
 
    public T get() { 
 
        return Objects.isNull(value) ? null : value; 
 
    } 
 
     
 
    public <R> OptionalBean<R> getBean(Function<? super T, ? extends R> fn) { 
 
        return Objects.isNull(value) ? OptionalBean.empty() : OptionalBean.ofNullable(fn.apply(value)); 
 
    } 
 
     
 
    public T orElse(T other) { 
 
        return value != null ? value : other; 
 
    } 
 
     
 
    public T orElseGet(Supplier<? extends T> other) { 
 
        return value != null ? value : other.get(); 
 
    } 
 
     
 
    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); 
 
    } 
 
     
 
    public static<T> OptionalBean<T> empty() { 
 
        @SuppressWarnings("unchecked") 
 
        OptionalBean<T> none = (OptionalBean<T>) EMPTY; 
 
        return none; 
 
    } 
 
} 

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

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

使用手册

可以看到代码中也提供了和 Optional 一样的扩展方法，如 ifPresent()、orElse()等等：

public static void main(String[] args) { 
 
    User axin = new User(); 
 
    User.School school = new User.School(); 
 
    axin.setName("hello"); 
 
    // 1. 基本调用 
 
    String value1 = OptionalBean.ofNullable(axin) 
 
            .getBean(User::getSchool) 
 
            .getBean(User.School::getAdress).get(); 
 
    System.out.println(value1); 
 
    // 2. 扩展的 isPresent方法 用法与 Optional 一样 
 
    boolean present = OptionalBean.ofNullable(axin) 
 
            .getBean(User::getSchool) 
 
            .getBean(User.School::getAdress).isPresent(); 
 
    System.out.println(present); 
 
    // 3. 扩展的 ifPresent 方法 
 
    OptionalBean.ofNullable(axin) 
 
            .getBean(User::getSchool) 
 
            .getBean(User.School::getAdress) 
 
            .ifPresent(adress -> System.out.println(String.format("地址存在:%s", adress))); 
 
    // 4. 扩展的 orElse 
 
    String value2 = OptionalBean.ofNullable(axin) 
 
            .getBean(User::getSchool) 
 
            .getBean(User.School::getAdress).orElse("家里蹲"); 
 
    System.out.println(value2); 
 
    // 5. 扩展的 orElseThrow 
 
    try { 
 
        String value3 = OptionalBean.ofNullable(axin) 
 
                .getBean(User::getSchool) 
 
                .getBean(User.School::getAdress).orElseThrow(() -> new RuntimeException("空指针了")); 
 
    } catch (Exception e) { 
 
        System.out.println(e.getMessage()); 
 
    } 
 
} 

run一下：

总结

设计了一种可以链式调用对象成员而无需判空的工具让代码更加的精准和优雅，如果本文设计的工具满足了刚好解决你的困扰，那就在项目中使用吧!

如果您有更的设计或者文中有错误，还请留言一起讨论，互相进步!

【本文是51CTO专栏作者Hollis的原创文章，作者微信公众号Hollis(ID：hollischuang)】

戳这里，看该作者更多好文