【引】不要再使用!=null判空了！

如下文章來源於Hollis ，做者上帝愛吃蘋果

對於Java程序員來講，null是使人頭痛的東西。時常會受到空指針異常（NPE）的騷擾。連Java的發明者都認可這是他的一項巨大失誤。

那麼，有什麼辦法能夠避免在代碼中寫大量的判空語句呢？

有人說能夠使用 JDK8提供的 Optional 來避免判空，可是用起來仍是有些麻煩。

做者在平常工做中，封裝了一個工具，能夠能夠鏈式調用對象成員而無需判空，相比原有的if null邏輯 和 JDK8提供的 Optional 更加優雅易用，在工程實踐中大大提升了編碼效率，也讓代碼更加的精準和優雅。

不優雅的判空調用

我想從事Java開發的小夥伴確定有遇到過下面這種讓人難受的判空邏輯：如今有一個User類，School 是它的成員變量

/**

* @author Axin

* @since 2020-09-20

* @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 , 通常的處理方式：

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 工具

/**

* @author Axin

* @since 2020-09-10

* @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 <T>
     * @return

     */

    public static <T> OptionalBean<T> of(T value) {

        return new OptionalBean<>;(value);

    }

    /**

     * 包裝一個可能爲空的 bean

     * @param value

     * @param <T>     * @return

     */

    public static <T> OptionalBean<T> ofNullable(T value) {

        return value == null ? empty() : of(value);

    }

    /**

     * 取出具體的值

     * @param fn

     * @param <R>     * @return

     */

    public T get() {

        return Objects.isNull(value) ? null : value;

    }

    /**

     * 取出一個可能爲空的對象

     * @param fn

     * @param <R>     * @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 <X>     * @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 <T>     * @return

     */

    public static <T> OptionalBean<T> empty() {

        @SuppressWarnings("unchecked")

        OptionalBean<T> none = (OptionalBean<T>) EMPTY;

        return none;

    }

}

工具設計主要參考了 Optional 的實現，再加上對鏈式調用的擴展就是上述的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一下：

總結設計了一種能夠鏈式調用對象成員而無需判空的工具讓代碼更加的精準和優雅，若是本文設計的工具知足了恰好解決你的困擾，那就在項目中使用吧！