原文： https://howtodoinjava.com/java7/java-suppressed-exceptions/

顾名思义， 被抑制的异常是在代码中引发的异常，但是以某种方式被忽略了。 如果您记得try-catch-finally块的执行顺序以及它们如何返回任何值或异常，那么您会记得，如果try中引发了异常，则也将抑制finally块中引发的异常。

在 Java 7 之前的版本中，您通过记录日志了解了这些异常（如果已实现），但是一旦finally块结束，您就无法控制这些类型的异常。

好吧，借助 Java 7 中的新特性，您还可以控制这些受抑制的异常。

  1. Table of contents
  3. 1\. What are suppressed exceptions?
  4. 2\. Suppressed exception example
  5. 3\. Demonstration in different scenarios

1. 什么是禁止的异常？

在 Java 7 中，遇到抑制异常的最常见用例是 try-with-resources 语句。 当我们在try块中遇到异常时，应用程序将尝试关闭资源。 如果它遇到关闭AutoCloseable资源时可能发生的多个异常，则会将其他异常作为抑制的异常附加到主要异常上。

为了支持抑制的异常，在 JDK 7 中向Throwable类（Exception和Error类的父级）添加了新的构造器和两个新方法。

  1. Throwable.getSupressed(); // Returns Throwable[]
  2. Throwable.addSupressed(aThrowable);

2. 抑制异常的例子

例如，在写入输出流时，可以从try块引发一个异常，当try-with-resources语句尝试关闭流时，可以从该异常中引发最多两个异常。

如果从try块引发一个异常，并且从try-with-resources语句引发一个或多个异常，则将从try-with-resources语句引发的那些异常抑制，并且由该块引发的异常由closeStream()方法抛出。

您可以通过从try块引发的异常中调用Throwable.getSuppressed()方法来检索这些受抑制的异常。

3. 在不同情况下的示例

例如，我正在编写一个自动关闭的资源（即DirtyResource.java），无论我们尝试访问它还是关闭它，它都会引发异常。 这样，当以不同方式访问时，我们将能够看到不同的行为。

  1. public class DirtyResource implements AutoCloseable
  2. {
  3.     /**
  4.      * Need to call this method if you want to access this resource
  5.      * @throws RuntimeException no matter how you call this method
  6.      * */
  7.     public void accessResource()
  8.     {
  9.         throw new RuntimeException("I wanted to access this resource. Bad luck. Its dirty resource !!!");
  10.     }
  12.     /**
  13.      * The overridden closure method from AutoCloseable interface
  14.      * @throws Exception which is thrown during closure of this dirty resource
  15.      * */
  16.     @Override
  17.     public void close() throws Exception
  18.     {
  19.         throw new NullPointerException("Remember me. I am your worst nightmare !! I am Null pointer exception !!");
  20.     }
  21. }

3.1 抑制异常之前的特性

  1. package com.howtodoinjava.demo.core;
  3. import static java.lang.System.err;
  5. public class SuppressedExceptionDemoWithTryFinallyPrevious
  6. {
  7.     /**
  8.     * Executable member function demonstrating suppressed exceptions
  9.     * One exception is lost if not added in suppressed exceptions list
  10.     */
  11.     public static void memberFunction() throws Exception
  12.     {
  13.         DirtyResource resource= new DirtyResource();
  14.         try
  15.         {
  16.               resource.accessResource();
  17.         }
  18.         finally
  19.         {
  20.             resource.close();
  21.         }
  22.     }
  24.     public static void main(String[] arguments) throws Exception
  25.    {
  26.       try
  27.       {
  28.           memberFunction();
  29.       }
  30.       catch(Exception ex)
  31.       {
  32.           err.println("Exception encountered: " + ex.toString());
  33.           final Throwable[] suppressedExceptions = ex.getSuppressed();
  34.           final int numSuppressed = suppressedExceptions.length;
  35.           if (numSuppressed > 0)
  36.           {
  37.               err.println("tThere are " + numSuppressed + " suppressed exceptions:");
  38.               for (final Throwable exception : suppressedExceptions)
  39.               {
  40.                   err.println("tt" + exception.toString());
  41.               }
  42.           }
  43.       }
  44.    }
  45. }
  47. Output:
  49. Exception encountered: java.lang.NullPointerException: Remember me. I am your worst nightmare !! I am Null pointer exception !!

如您所见，仅捕获了一个异常，而第二个RuntimeException被抑制。

3.2 在 Java 7 中抑制异常之后

  1. package com.howtodoinjava.demo.core;
  3. import static java.lang.System.err;
  5. public class SuppressedExceptionDemoWithTryFinallyNew
  6. {
  7.     /**
  8.     * Executable member function demonstrating suppressed exceptions
  9.     * Suppressed expression is added back in primary exception
  10.     */
  11.     public static void memberFunction() throws Exception
  12.     {
  13.         Throwable th = null;
  14.         DirtyResource resource= new DirtyResource();
  15.         try
  16.         {
  17.               resource.accessResource();
  18.         }
  19.         catch(Exception e)
  20.         {
  21.             th = e;
  22.         }
  23.         finally
  24.         {
  25.             try
  26.             {
  27.                 resource.close();
  28.             }
  29.             catch(Exception e)
  30.             {
  31.                 if(th != null)
  32.                 {
  33.                     e.addSuppressed(th); //Add to primary exception
  34.                     throw e;
  35.                 }
  36.             }
  37.         }
  38.     }
  39.    /**
  40.     * Executable function demonstrating suppressed exceptions.
  41.     */
  42.    public static void main(String[] arguments) throws Exception
  43.    {
  44.       try
  45.       {
  46.           memberFunction();
  47.       }
  48.       catch(Exception ex)
  49.       {
  50.           err.println("Exception encountered: " + ex.toString());
  51.           final Throwable[] suppressedExceptions = ex.getSuppressed();
  52.           final int numSuppressed = suppressedExceptions.length;
  53.           if (numSuppressed > 0)
  54.           {
  55.               err.println("tThere are " + numSuppressed + " suppressed exceptions:");
  56.               for (final Throwable exception : suppressedExceptions)
  57.               {
  58.                   err.println("tt" + exception.toString());
  59.               }
  60.           }
  61.       }
  62.    }
  63. }
  65. Output:
  67. Exception encountered: java.lang.NullPointerException: Remember me. I am your worst nightmare !! I am Null pointer exception !!
  68.     There are 1 suppressed exceptions:
  69.         java.lang.RuntimeException: I wanted to access this resource. Bad luck. Its dirty resource !!!

在这里，在catch块中，我们可以访问两个异常。 一个作为主要异常，第二个作为受抑制异常。

3.3 成员函数中的try-with-resource块并捕获异常

  1. package com.howtodoinjava.demo.core;
  3. import static java.lang.System.err;
  5. public class SuppressedExceptionDemoWithTryCatch
  6. {
  7.     public static void memberFunction() throws Exception
  8.     {
  9.         try (DirtyResource resource= new DirtyResource())
  10.           {
  11.               resource.accessResource();
  12.           }
  13.     }
  14.    /**
  15.     * Executable member function demonstrating suppressed exceptions using try-with-resources
  16.     */
  17.    public static void main(String[] arguments) throws Exception
  18.    {
  19.       try
  20.       {
  21.           memberFunction();
  22.       }
  23.       catch(Exception ex)
  24.       {
  25.           err.println("Exception encountered: " + ex.toString());
  26.           final Throwable[] suppressedExceptions = ex.getSuppressed();
  27.           final int numSuppressed = suppressedExceptions.length;
  28.           if (numSuppressed > 0)
  29.           {
  30.               err.println("tThere are " + numSuppressed + " suppressed exceptions:");
  31.               for (final Throwable exception : suppressedExceptions)
  32.               {
  33.                   err.println("tt" + exception.toString());
  34.               }
  35.           }
  36.       }
  37.    }
  38. }
  40. Output:
  42. Exception encountered: java.lang.RuntimeException: I wanted to access this resource. Bad luck. Its dirty resource !!!
  43.     There are 1 suppressed exceptions:
  44.         java.lang.NullPointerException: Remember me. I am your worst nightmare !! I am Null pointer exception !!

太好了！ 在成员函数中使用try-with-resource时，我们能够看到这两种异常。

3.4 默认try-with-resource块

  1. package com.howtodoinjava.demo.core;
  3. public class SuppressedExceptionDemoWithTryWithResource
  4. {
  5.    /**
  6.     * Demonstrating suppressed exceptions using try-with-resources
  7.     */
  8.    public static void main(String[] arguments) throws Exception
  9.    {
  10.       try (DirtyResource resource= new DirtyResource())
  11.       {
  12.           resource.accessResource();
  13.       }
  14.    }
  15. }
  17. Output:
  19. Exception in thread "main" java.lang.RuntimeException: I wanted to access this resource. Bad luck. Its dirty resource !!!
  20.     at DirtyResource.accessResource(DirtyResource.java:9)
  21.     at SuppressedExceptionDemoWithTryWithResource.main(SuppressedExceptionDemoWithTryWithResource.java:12)
  22.     Suppressed: java.lang.NullPointerException: Remember me. I am your worst nightmare !! I am Null pointer exception !!
  23.         at DirtyResource.close(DirtyResource.java:19)
  24.         at SuppressedExceptionDemoWithTryWithResource.main(SuppressedExceptionDemoWithTryWithResource.java:13)

好吧，非常高兴看到包含抑制异常的完整信息的输出。

学习愉快！