java - 包装已检查 Java 异常的标准方法

Question

我有一个相当详细的问题，关于包装已检查异常的正确方法，以及 Guava 的处理方式。 (抱歉太长了，但我想把我的思考过程记下来)

---

标准的 Runnable 接口(interface)是这样的:

public interface Runnable
{
   public void run();
}

其中 run() 无法抛出已检查的异常。

因此，如果我想要一个 Runnable 用于包装抛出已检查异常的任务，并且我打算拥有调用 Runnable.run() 的东西处理这些异常，而不是在 Runnable.run() 本身中，我必须将异常包装在未经检查的异常中。

所以有一段时间我在使用:

Runnable r = new Runnable {
   @Override public void run()
   {
       try {
          doNastyStuff();
       }
       catch (NastyException e)
       {
          throw new RuntimeException(e);
       }
   }      
};

然后我可以在上层处理 RuntimeException。但后来我想，我真正想要的是单独处理一个包装的异常，因为我知道它的语义是包装一个检查的异常，所以我写了这个帮助类:

/**
 * Wrapped exception: the purpose of this is just to wrap another exception,
 * and indicate that it is a wrapped exception
 */
public class WrappedException extends RuntimeException
{
    /**
     * @param t any throwable
     */
    public WrappedException(Throwable t)
    {
        super(t);
    }
}

然后我可以这样做:

/* place that produces the exception */
...
catch (NastyException e)
{
   throw new WrappedException(e);
}

...
/* upper level code that calls Runnable.run() */
try
{
   ...
   SomeOtherNastyCode();
   r.run();
   ...
}
catch (SomeOtherNastyException e)
{
   logError(e);
}
catch (WrappedException e)
{
   logError(e.getCause());
}

而且看起来效果很好。

但现在我在想，好吧，如果我想在库中使用它以及使用该库的应用程序，现在它们都依赖于 WrappedException，所以它真的应该是在我可以随处包含的基础库中。

这让我想到，也许 Guava 在某处有一个标准的 WrappedException 类，因为我现在默认将 Guava 作为依赖项包含在内。所以我可以做

throw new WrappedException(e);

或

throw Exceptions.wrap(e);

或

Exceptions.rethrow(e);

我只是在 Guava 中环顾四周，发现 Throwables其中有 Throwables.propagate()看起来很相似，但它只是将已检查的异常包装在 RuntimeException 中，而不是 RuntimeException 的特殊子类。

哪种方法更好？与 RuntimeException 相比，我是否应该使用特殊的 WrappedException？我的顶层代码想知道增加信息值(value)的最顶层异常。

如果我有一个 RuntimeException 包装一个 NastyException 包装一个 NullPointerException，包装 RuntimeException 不会不添加信息值，我不关心它，所以我记录的错误将是 NastyException。

如果我有一个包含 NastyException 的 IllegalArgumentException，IllegalArgumentException 通常会添加信息值。

所以在我做错误记录的顶级代码中，我必须做这样的事情:

catch (RuntimeException re)
{
   logError(getTheOutermostUsefulException(re));
}

/** 
 * heuristics to tease out whether an exception
 * is wrapped just for the heck of it, or whether
 * it has informational value
 */
Throwable getTheOutermostUsefulException(RuntimeException re)
{        
   // subclasses of RuntimeException should be used as is
   if (re.getClass() != RuntimeException)
      return re;
   // if a runtime exception has a message, it's probably useful
   else if (re.getMessage() != null)
      return re;
   // if a runtime exception has no cause, it's certainly
   // going to be more useful than null
   else if (re.getCause() == null)
      return re;
   else
      return re.getCause();
}

这个理念对我来说是正确的，但实现起来却很糟糕。有没有更好的方法来处理包装异常？

---

相关问题:

• How do I use Throwables.propagateIfInstanceOf() from Google Guava?
• Wrapping a checked exception into an unchecked exception in Java?

Answer 1

Spring 是我所知道的唯一具有相对相似功能的库。它们有嵌套的异常:NestedRuntimeException和 NestedCheckedException .这些异常具有有用的方法，例如 getMostSpecificCause() 或 contains(Class exType)。他们的 getMessage() 方法返回原因的消息(如果包装异常已经有消息，则附加它)。

它用于Spring 的数据访问异常层次结构。这个想法是每个数据库供应商在他们的 JDBC 驱动程序中公开不同的异常。 Spring 捕获这些并将它们翻译成更通用的 DataAccessExceptions .这样做的另一个好处是检查异常会自动转换为运行时异常。

也就是说，这不是很复杂的代码，我相信您可以在您的代码库中执行类似的操作。无需为此添加 Spring 依赖项。

如果我是你，我不会过早地“展开”异常，除非你真的可以当场处理它们。我会让它们冒泡(包装或不包装)，使用一个全局 ExceptionHandler 来查看它们的因果链，找到第一个“有意义的”异常，并提取智能错误消息。当无法这样做时，我会打印“技术错误”并将整个堆栈跟踪添加到错误消息的详细信息或某种日志中，以用于错误报告目的。然后，您将修复错误和/或抛出更有意义的异常。

Guava 的 Throwables.getCausalChain()也可能对简化异常处理感兴趣:

Iterables.filter(Throwables.getCausalChain(e), IOException.class));

---

编辑:

我对你的问题进行了更多思考，我认为你真的不应该担心用特定的“WrapperException”类型包装你的异常。您应该使用最有意义的方法来包装它们:一个简单的 RuntimeException(Guava 的 Throwables.propagate() 可能在那里很有用)，一个 RuntimeException 附加错误消息，或在适当时使用更有意义的异常类型。

Java 的因果链机制无论如何都会让您找到根本原因。您不必担心代码中到处都是异常包装。编写一个全局异常处理程序来管理它，并在其他任何地方使用标准异常冒泡。