今天，我們將討論一個非常重要的主題-Java 中的異常處理。儘管有時可能會對此主題進行過多的討論，但並非每篇文章都包含有用且相關的資訊。

Java 中最常見的異常處理機制通常與 try-catch 塊關聯 。我們使用它來捕獲異常，然後提供在發生異常的情況下可以執行的邏輯。

的確，你不需要將所有異常都放在這些塊中。另一方面，如果你正在研究應用程式的軟體設計，則可能不需要內建的異常處理機制。在這種情況下，你可以嘗試使用替代方法-Vavr Try 結構。

在本文中，我們將探討 Java 異常處理的不同方法，並討論如何使用 Vavr Try 替代內建方法。讓我們開始吧！

處理 Java 中的異常

作為介紹，讓我們回顧一下 Java 如何允許我們處理異常。如果你不記得它，則 Java 中的異常會指出意外或意外事件，該異常在程式執行期間（即在執行時）發生，這會破壞程式指令的正常流程。Java為我們提供了上述 try-catch 捕獲異常的機制。讓我們簡要檢查一下它是如何工作的。

如果不處理異常會發生什麼？

首先，讓我們看一個非常常見的例子。這是一個包含 JDBC 程式碼的程式碼段：

Connection connection = dataSource.getConnection();
String updateNameSql = "UPDATE employees SET name=? WHERE emp_id=?";
PreparedStatement preparedStatement = connection.prepareStatement(updateNameSql);

坦白地說，你的 IDE 甚至不允許你編寫這段程式碼，而是要求用 try-catch 塊將其包圍，像這樣：

try {
    Connection connection = dataSource.getConnection();
    String updateNameSql = "UPDATE employees SET name=? WHERE emp_id=?";
    PreparedStatement preparedStatement = connection.prepareStatement(updateNameSql);
} catch (SQLException ex){
}

注：我們可以將其重構為 try-with-resources，但是稍後再討論。

那麼，為什麼我們要這樣編寫程式碼？因為 SQLException 是一個檢查異常。

如果這些異常可以由方法或建構函式的執行丟擲並傳播到方法或建構函式邊界之外，則必須在方法或建構函式的 throws 子句中宣告這些異常。SQLException 如果發生資料庫訪問錯誤，則在示例中使用的方法將丟擲 。因此，我們用一個 try-catch 塊將其包圍。

Java 在編譯過程中驗證了這些異常，這就是它們與執行時異常不同的原因。

但是你不必處理所有異常情況

但是，並非每個異常都應被一個 try-catch 塊包圍。

情況 1：執行時異常

Java 異常是 Throwable 的子類，但是其中一些是 RuntimeException 類的子類。看下面的圖，它給出了 Java 異常的層次結構：

請注意，執行時異常是特定的組。根據 Java 規範，從這些異常中還是有可能恢復的。作為示例，讓我們回想一下 ArrayIndexOutOfBoundsException。看看下面的示例程式碼片段：

int numbers[] = [1,43,51,0,9];
System.out.println(numbers[6]);

在這裡，我們有一個具有5個值（0-4位）的整數陣列。當我們嘗試檢索絕對超出範圍的值（索引= 6）時，Java 將丟擲 ArrayIndexOutOfBoundsException。

這表明我們嘗試呼叫的索引為負數，大於或等於陣列的大小。如我所說，這些異常可以修復，因此在編譯過程中不會對其進行檢查。這意味著你仍然可以編寫如下程式碼：

int numbers[] = [1,43,51,0,9];
int index = 6;
try{
    System.out.println(numbers[index]);
} catch (ArrayIndexOutOfBoundsException ex){
    System.out.println("Incorrect index!");
}

但是你不必這樣做。

情況 2：錯誤

Error 是另一個棘手的概念。再看一下上面的圖-存在錯誤，但是通常不會處理。為什麼？通常，這是由於 Java 程式無法執行任何操作來從錯誤中恢復，例如：錯誤表明嚴重的問題，而合理的應用程式甚至不應嘗試捕獲。

讓我們考慮一下記憶體錯誤– java.lang.VirtualMachineError。此錯誤表明 JVM 已損壞或已經用盡了繼續執行所必需的資源。換句話說，如果應用程式的記憶體不足，則它根本無法分配額外的記憶體資源。

當然，如果由於持有大量應釋放的記憶體而導致失敗，則異常處理程式可以嘗試釋放它（不是直接釋放它本身，而是可以呼叫JVM來釋放它）。並且，儘管這樣的處理程式在這種情況下可能有用，但是這樣的嘗試可能不會成功。

Try-Catch 塊的變體

上述編寫 try-catch 語句的方法並不是 Java 中唯一可用的方法。還有其他方法：try-with-resources，try-catch-finally 和多個 catch 塊。讓我們快速瀏覽這些不同的方法。

方法 1：Try-With-Resources

try-with-resources 塊在 Java 7 中引入的，並允許開發者在程式執行到此結束後必須關閉宣告的資源。我們可以在實現該 AutoCloseable 介面（即特定標記介面）的任何類中包含資源。我們可以像這樣重構所提到的 JDBC 程式碼：

try (Connection connection = dataSource.getConnection){
    String updateNameSql = "UPDATE employees SET name=? WHERE emp_id=?";
    PreparedStatement preparedStatement = connection.prepareStatement(updateNameSql);
} catch (SQLException ex){
//..
}

Java 確保我們 Connection 在執行程式碼後將其關閉。在進行此構建之前，我們必須顯式地關閉 finally 塊中的資源。

方法 2：Try + Finally

finally 塊在任何情況下都將執行。例如在成功情況下或在異常情況下。在其中，你需要放置將在之後執行的程式碼：

FileReader reader = null;
try {
    reader = new FileReader("/text.txt");
    int i=0;
    while(i != -1){
        i = reader.read();
        System.out.println((char) i);
    }
} catch(IOException ex1){
//...
} finally{
    if(reader != null){
       try {
         reader.close();
       } catch (IOException ex2) {
       //...
       }
    }
}

請注意，此方法有一個缺點：如果在 finally 塊內引發異常 ，則會使其中斷。因此，我們必須正常處理異常。將 try-with-resources 與可關閉的資源一起使用，避免在 finally 塊內關閉資源 。

方法 3：多 Catch 塊

最後，Java 允許我們使用一個 try-catch 塊多次捕獲異常。當方法丟擲幾種型別的異常並且您想區分每種情況的邏輯時，這很有用。舉個例子，讓這個虛構的類使用丟擲多個異常的方法：

class Repository{
    void insert(Car car) throws DatabaseAccessException, InvalidInputException {
    //...
    }
}
//...
try {
    repository.insert(car);
} catch (DatabaseAccessException dae){
    System.out.println("Database is down!");
} catch (InvalidInputException iie){
    System.out.println("Invalid format of car!");
}

在這裡需要記住什麼？通常，我們假設在此程式碼中，這些異常處於同一級別。但是你必須從最具體到最一般的順序排序 catch 塊。例如，捕獲 ArithmeticException 異常必須在 捕獲 Exception 異常之前。

到這裡，我們已經回顧瞭如何使用內建方法處理 Java 中的異常。現在，讓我們看一下如何使用 Vavr 庫執行此操作。

Vavr Try

我們回顧了捕獲 Java 異常的標準方法。另一種方法是使用 Vavr Try 類，Vavr 是 Java 8+ 中一個函式式庫，提供了一些不可變資料型別及函式式控制結構。首先，新增 Vavr 庫依賴項：

<dependency>
   <groupId>io.vavr</groupId>
   <artifactId>vavr</artifactId>
   <version>0.10.2</version>
</dependency>

Try 容器

Vavr 包含的 Try 類是 monadic 容器型別，它表示可能導致異常或返回成功計算出的值的計算。此結果可以採用 Success 或 Failure。看下面這段程式碼：

class CarsRepository{
    Car insert(Car car) throws DatabaseAccessException {
        //...
    }
    Car find (String id) throws DatabaseAccessException {
        //..
    }
    void update (Car car) throws DatabaseAccessException {
        //..
    }
    void remove (String id) throws DatabaseAccessException {
        //..
    }
}

在呼叫此程式碼時，我們將使用這些 try-catch 塊來處理 DatabaseAccessException。但是另一個解決方案是使用 Vavr 對其進行重構。檢視以下程式碼片段：

class CarsVavrRepository{
    Try<Car> insert(Car car) {
        System.out.println("Insert a car...");
        return Try.success(car);
    }
    Try<Car> find (String id) {
        System.out.println("Finding a car...");
        System.out.println("..something wrong with database!");
        return Try.failure(new DatabaseAccessException());
    }
    Try<Car> update (Car car) {
        System.out.println("Updating a car...");
        return Try.success(car);
    }
    Try<Void> remove (String id) {
        System.out.println("Removing a car...");
        System.out.println("..something wrong with database!");
        return Try.failure(new DatabaseAccessException());
    }
}

現在，我們可以使用 Vavr 處理資料庫問題。

處理成功

當我們收到成功計算的結果時，我們會收到 Success：

@Test
void successTest(){
    CarsVavrRepository repository = new CarsVavrRepository();
    Car skoda = new Car("skoda", "9T4 4242", "black");
    Car result = repository.insert(skoda).getOrElse(new Car("volkswagen", "3E2 1222", "red"));
    Assertions.assertEquals(skoda.getColor(), result.getColor());
    Assertions.assertEquals(skoda.getId(), result.getId());
}

請注意，Vavr.Try 相較於 Vavr.Option，為我們提供了一種方便的 getOrElse 方法，在發生故障的情況下我們可以使用預設值，我們可以將這種邏輯與有問題的方法結合使用，例如與 find 一起使用。

處理失敗

在另一種情況下，我們將處理 Failure：

@Test
void failureTest(){
    CarsVavrRepository repository = new CarsVavrRepository();
        // desired car
    Car bmw = new Car("bmw", "4A1 2019", "white");
        // failure car
    Car failureCar = new Car("seat", "1A1 3112", "yellow");
    Car result = repository.find("4A1 2019").getOrElse(failureCar);
    Assertions.assertEquals(bmw.getColor(), result.getColor());
    Assertions.assertEquals(bmw.getId(), result.getId());
}

執行此程式碼。由於斷言錯誤，該測試將失敗：

org.opentest4j.AssertionFailedError: 
Expected :white
Actual   :yellow

這意味著因為我們在 find 方法中對失敗進行了硬編碼 ，所以我們收到了預設值。除了返回預設值之外，我們還可以在發生錯誤的情況下執行其他操作並生成結果。你可以使用連結函式 Option 來使您的程式碼更具功能性：

repository.insert(bmw).andThen(car -> {
    System.out.println("Car is found "+car.getId());
}).andFinally(()->{
    System.out.println("Finishing");
});

或者，你可以使用收到的異常執行程式碼，如下所示：

repository.find("1A9 4312").orElseRun(error->{
    //...
});

一般來說，Vavr Try 是一個功能豐富的解決方案，可用於以更實用的方式轉換程式碼庫。毫無疑問，它與其他 Vavr 類（如 Option 或 Collections）結合後，才可以釋放出真正的力量。但是， 如果您想編寫更多的功能樣式的程式碼，即使沒有它們，Vavr Try 對於 Java 的 try-catch 塊來說也是一個的正確的替代選擇。

總結

Java 中的異常處理機制通常與 try-catch 塊關聯， 以便捕獲異常並提供發生異常時將要執行的邏輯。同樣，我們確實不需要將所有異常都放入這些塊中。在本文中，我們探討了如何使用 Vavr 庫執行此操作。