标签: checked-exceptions

我正在编写将用于访问数据库的Java库.我向最终程序员抛出异常,他们使用JAR库以他/她想要的方式处理它.

我编写了一个自定义异常(下面提供)来将特定于连接的异常包装在一起,这样最终程序员就不必在代码中捕获所有这些异常.(为了方便他)

在编写Java库时,这是一个很好的做法吗？通过使用它,用户只需要在他的代码中捕获NConnectionException.

public class NConnectionException extends Exception {
private static final Logger logger = LoggerFactory.getLogger(NConnectionException.class);
public NConnectionException(Exception e) {

    if (e instanceof NullPointerException) {
        logger.error("ERROR IN READING DF");
        e.printStackTrace();
    }

    else if (e instanceof FileNotFoundException) {
        logger.error("FILE NOT FOUND");
        e.printStackTrace();

    } else if (e instanceof ParserConfigurationException)
    {
        logger.error("PARSE CONF ERR");
        e.printStackTrace();

    }
    else if (e instanceof org.xml.sax.SAXException)
    {
        logger.error("SAX ERR");
        e.printStackTrace();

    }
    else if (e instanceof IOException)
    {
        logger.error("IO ERR");
        e.printStackTrace();

    }

}

}

为什么运行时异常UnChecked是有意义的(而不是如果它们被检查)？

无需在throws子句中声明已检查的异常或在scala中的try/catch块中处理它们是我喜欢的功能.但是,当必须处理异常但被忽略时,它可能是一个问题.我正在寻找工具(可能是编译器标志/插件)来查找忽略已检查异常的方法.

编辑:这个问题只涉及Java 1.6(及以下).抱歉没有在原帖中说清楚.

这里的层次结构显示Java Exception分为两种类型:RuntimeException而不是RuntimeException:

我可能会错过一些东西,但不会更好地分成类似的东西UncheckedException而CheckedException不是吗？例如,以下语句具有相当多的已检查异常:

try {
    transaction.commit();
} catch (SecurityException e) {
} catch (IllegalStateException e) {
} catch (RollbackException e) {
} catch (HeuristicMixedException e) {
} catch (HeuristicRollbackException e) {
} catch (SystemException e) {
}

我只是真的对它是成功还是失败感兴趣所以想要将已检查的异常作为一个组来处理,而不是未经检查的异常,因为捕获意外错误不是好的做法.所以考虑到这一点,也许我可以这样做:

try {
    transaction.commit();
} catch (Exception e) {
    if (e instanceof RuntimeException) {
        // Throw unchecked exception
        throw e;
    }
    // Handle checked exception
    // ...
}

但这看起来非常糟糕.有没有更好的办法？

你能解释为什么必须从lambda表达式中捕获检查异常吗？换句话说,为什么以下代码无法编译...

public void doSomething(ObjectInputStream istream) throws IOException {
  // The read method throws an IOException.
  IntStream.range(0, 10).forEach(i -> someList.add(read(istream)));
}

但是这个会吗？

public void doSomething(ObjectInputStream istream) throws IOException {
  IntStream.range(0, 10).forEach(i -> {
    try {
      // The read method throws an IOException.
      someList.add(read(istream));
    }
    catch (IOException ioe) {
      // Callee has to handle checked exception, not caller.
    }
  });
}

看起来被调用者现在必须处理被抛出的任何已检查异常而不是调用者.

鉴于此java 8代码

public Server send(String message) {
    sessions.parallelStream()
        .map(Session::getBasicRemote)
        .forEach(basic -> {
          try {
            basic.sendText(message);
          } catch (IOException e) {
            e.printStackTrace();
          }
        });

    return this;
}

我们如何正确地将它IOException委托给方法调用的堆栈？(简而言之,如何让这个方法抛出这个IOException？)

java中的Lambdas对错误处理看起来不太友好......

我只是很好奇,除了Java之外还有其他语言使用检查异常吗？

我确实试图找到有关此信息,但找不到任何答案.

我在使用 Java 中的 Lombok 库时发现了一个名为 @SneakyThrows 的注释。正如文档所述：

@SneakyThrows 伪造了编译器。换句话说，Lombok 不会包装或替换抛出的已检查异常，而是让编译器认为它是未检查异常。

换句话说，这是一种在编译时绕过异常的方法。但在我看来，这不应该是处理异常的正确方法，因为绕过的异常会在运行时表现出奇怪的行为。

那么在哪种情况下应该使用@SneakyThrows？

我正在阅读 Java 中已检查与未检查异常以及何时使用每个异常：

这是底线：如果可以合理地期望客户端从异常中恢复，请将其设置为已检查异常。如果客户端无法从异常中恢复，请将其设为未经检查的异常。

客户端不能恢复的一个例子是除以零，他们可以恢复的东西是 FileNotFound 异常。不过我还没有看到区别。为什么您可以捕获一个并记录错误，但不能捕获另一个并记录错误？什么使某些东西可以合理恢复？您不能在所有情况下都捕获错误（从而恢复）吗？

新的 Java 程序员经常遇到如下错误：

"error: unreported exception <XXX>; must be caught or declared to be thrown" 

其中 XXX 是某个异常类的名称。

请解释：

• 编译错误消息的内容是什么，
• 此错误背后的 Java 概念，以及
• 如何修复它。