是時候優雅的和NullPointException說再見了

是時候優雅的和NullPointException說再見了
☝️☝️☝️☝️☝️☝️☝️☝️☝️☝️☝️☝️☝️☝️☝️☝️
最近在參加原創投稿比賽，本篇文章如果對你有幫助的話，歡迎幫忙點擊助力下吧

NullPointException應該算是每一個碼農都很熟悉的家伙了吧？誰的代碼不曾拋過幾個空指針異常呢...

比如：你寫了段如下的代碼：

public void getCompanyFromEmployee() {
    Employee employee = getEmployee();
    Company company = employee.getTeam().getDepartment().getCompany();
    System.out.println(company);
}

private Employee getEmployee() {
    Employee employee = new Employee();
    employee.setEmployeeName("JiaGouWuDao");
    employee.setTeam(new Team("DevTeam4"));
    return employee;
}

運行程式，你可能就等不到你需要的結果，而是要喜提NullPointException了...

作為JAVA開發中最典型的異常類型，甚至可能是很多程式員入行之後收到的第一份異常大禮包類型。而NullPointException也似乎成為了一種魔咒，迫使程式員在敲出的每一行代碼的時候都需要去思考下是否需要去做一下判空操作，久而久之，代碼中便充斥著大量的null檢查邏輯。

於是呢，上面的代碼會變成下麵這樣：

public void getCompanyFromEmployee() {
    Employee employee = getEmployee();
    if (employee == null) {
        // do something here...
        return;
    }
    Team team = employee.getTeam();
    if (team == null) {
        // do something here...
        return;
    }
    Department department = team.getDepartment();
    if (department == null) {
        // do something here...
        return;
    }
    Company company = department.getCompany();
    System.out.println(company);
}

是不是大家的項目中都有見過這種寫法的？每行代碼中都流露著對NullPointException的恐懼有木有？是不是像極了一顆被深深傷害過的心在小心翼翼的保護著自己？

null的困擾

通過上面代碼示例，我們可以發現使用null可能會帶來的一系列困擾：

• 空指針異常，導致代碼運行時變得不可靠，稍不留神可能就崩了
• 使代碼膨脹，導致代碼中充斥大量的null檢查與保護，使代碼可讀性降低

此外，null還有一個明顯的弊端：

• 含義不明確，比如一個方法返回了null，調用方不清楚到底是因為邏輯有問題導致為null，還是說null其實也是一種可以接受的正常返回值類型？

所以說，一個比較好的編碼習慣，是儘量避免在程式中使用null，可以按照具體的場景分開區別對待：

• 確定是因為代碼或者邏輯層面處理錯誤導致的無值，通過throw異常的方式，強制調用方感知併進行處理對待
• 如果null代表業務上的一種正常可選值，可以考慮返回Optional來替代。

當然咯，有時候即使我們自己的代碼不返回null，也難免會遇到調用別人的介面返回null的情況，這種時候我們真的就只能不停的去判空來保護自己嗎？有沒有更優雅的應對策略來避免自己掉坑呢？下麵呢，我們一起探討下null的一些優雅應對策略。

Optional應對null處理

Optional一定比return null安全嗎

前面我們提到了說使用Optional來替代null，減少調用端的判空操作壓力，防止調用端出現空指針異常。

那麼，使用返回Optional對象就一定會比return null更靠譜嗎？

答案是：也不一定，關鍵要看怎麼用！

比如：下麵的代碼，getContent()方法返回了個Optional對象，然後testCallOptional()方法作為調用方，獲取到返回值後的操作方式：

public void testCallOptional() {
    Optional<Content> optional = getContent();
    System.out.println("-------下麵代碼會報異常--------");
    try {
        // 【錯誤用法】直接從Optional對象中get()實際參數，這種效果與返回null對象然後直接調用是一樣的效果
        Content content = optional.get();
        System.out.println(content);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("-------上面代碼會報異常--------");
}

private Optional<Content> getContent() {
    return Optional.ofNullable(null);
}

上述代碼運行之後會發現報錯了：

-------下麵代碼會報異常--------
java.util.NoSuchElementException: No value present
	at java.util.Optional.get(Optional.java:135)
	at com.veezean.skills.optional.OptionalService.testCallOptional(OptionalService.java:47)
	at com.veezean.skills.optional.OptionalService.main(OptionalService.java:58)
-------上面代碼會報異常--------

既然直接調用Optional.get()報錯，那就是調用前加個判斷就好咯？

public void testCallOptional2() {
    Optional<Content> optional = getContent();
    // 使用前先判斷下元素是否存在
    if (optional.isPresent()) {
        Content content = optional.get();
        System.out.println(content);
    }
}

執行一下，果然不報錯了。但是，這樣真的就是解決方法嗎？這樣跟直接返回null然後使用前判空（下麵的寫法）其實也沒啥區別，也並不會讓調用方使用起來更加的優雅與靠譜：

public void testNullReturn2() {
    Content content = getContent2();
    if (content != null) {
        System.out.println(content.getValue());
    }
}

那怎麼樣才是正確的使用方式呢，下麵一起來看下。

全面認識下Optional

創建Optional對象

Optional<T>對象，可以用來表示一個T類型對象的封裝，或者也可以表示不是任何對象。Optional類提供了幾個靜態方法供對象的構建：

在項目中，我們可以選擇使用上面的方法，實現Optional對象的封裝：

public void testCreateOptional() {
    // 使用Optional.of構造出具體對象的封裝Optional對象
    System.out.println(Optional.of(new Content("111","JiaGouWuDao")));
    // 使用Optional.empty構造一個不代表任何對象的空Optional值
    System.out.println(Optional.empty());
    System.out.println(Optional.ofNullable(null));
    System.out.println(Optional.ofNullable(new Content("222","JiaGouWuDao22")));
}

輸出結果：

Optional[Content{id='111', value='JiaGouWuDao'}]
Optional.empty
Optional.empty
Optional[Content{id='222', value='JiaGouWuDao22'}]

這裡需要註意下of方法如果傳入null會拋空指針異常，所以比較建議大家使用ofNullable方法，可以省去調用前的額外判空操作，也可以避免無意中觸發空指針問題：

Optional常用方法理解

在具體討論應該如何正確使用Optional的方法前，先來瞭解下Optional提供的一些方法：

看到這裡的map與flatMap方法，不知道大家會不會聯想到Stream流對象操作的時候也有這兩個方法的身影呢（不瞭解的同學可以戳這個鏈接抓緊補補課：吃透JAVA的Stream流操作）？的確，它們的作用也是類似的，都是用來將一個對象處理轉換為另一個對象類型的：

對於Optional而言,map與flatMap最終的實現效果其實都是一樣的，僅僅只是入參的要求不一樣，也即兩種不同寫法，兩者區別點可以通過下圖來理解：

實際使用的時候，可以根據需要選擇使用map或者flatMap：

public void testMapAndFlatMap() {
    Optional<User> userOptional = getUser();
    Optional<Employee> employeeOptional = userOptional.map(user -> {
        Employee employee = new Employee();
        employee.setEmployeeName(user.getUserName());
        // map與flatMap的區別點：此處return的是具體對象類型
        return employee;
    });
    System.out.println(employeeOptional);

    Optional<Employee> employeeOptional2 = userOptional.flatMap(user -> {
        Employee employee = new Employee();
        employee.setEmployeeName(user.getUserName());
        // map與flatMap的區別點：此處return的是具體對象的Optional封裝類型
        return Optional.of(employee);
    });
    System.out.println(employeeOptional2);
}

從輸出結果可以看出，兩種不同的寫法，實現是相同的效果：

Optional[Employee(employeeName=JiaGouWuDao)]
Optional[Employee(employeeName=JiaGouWuDao)]

Optional使用場景

減少繁瑣的判空操作

再回到本篇文章最開始的那段代碼例子，如果我們代碼裡面不去逐個做判空保護的話，我們可以如何來實現呢？看下麵的實現思路：

public void getCompanyFromEmployeeTest() {
    Employee employeeDetail = getEmployee();
    String companyName = Optional.ofNullable(employeeDetail)
            .map(employee -> employee.getTeam())
            .map(team -> team.getDepartment())
            .map(department -> department.getCompany())
            .map(company -> company.getCompanyName())
            .orElse("No Company");
    System.out.println(companyName);
}

先通過map的方式一層一層的去進行類型轉換，最後使用orElse去獲取Optional中最終處理後的值，並給定了數據缺失場景的預設值。是不是看著比一堆if判空操作要舒服多了？