开源项目中的 Java 异常处理示例

朱雀 2024-03-27 13:00 78阅读 0赞

## 开源项目中的 Java 异常处理示例 ##

*本文译自：[Java Exception Handling Examples in Open Source Projects][]*

![在这里插入图片描述][20ed291445ec479fa70e7c5d1db861b4.jpeg_pic_center]

在“ [Effective Java][] ”中，Joshua Bloch 写了关于如何在 Java 中处理异常的 9 个技巧。这些技巧已经成为 Java 异常处理的事实标准。在这篇文章中，我列出了一些开源项目中的 Java 异常处理示例，并按照异常处理的 9 个技巧来评论用法。

关于 Java 异常处理的 9 个技巧是：

1.  仅在异常情况下使用异常
2.  对可恢复条件使用检查异常，对编程错误使用运行时异常
3.  避免不必要地使用检查异常
4.  支持使用标准异常
5.  抛出适合抽象的异常
6.  记录每个方法抛出的所有异常
7.  在详细消息中包含故障捕获信息
8.  争取失败的原子性
9.  不要忽视异常

### 1. 仅在异常情况下使用异常 ###

这一项主要是关于避免对普通控制流使用异常。

例如，不使用异常来终止循环控制流：

try{
        
      Iterator<Foo> iter = ...;
      while(true) {
        
        Foo foo = i.next();
        ...
      }
    } catch (NoSuchElementException e){
        
    }

应该使用对集合的定期迭代：

for(Iterator<Foo> iter = ...; i.hasNext();){
        
      Foo foo = i.next();
      ...
    }

我没有找到任何将异常用于常规控制流的示例。

### 2. 对可恢复条件使用检查异常，对编程错误使用运行时异常 ###

在大多数情况下，如果调用者可以恢复异常，那么应该使用已检查的异常。如果不是，则应使用运行时异常。运行时异常表示可以通过检查一些先决条件（例如数组边界和空性检查）来防止的编程错误。

在下面的方法中，IllegalArgumentException 是一个RuntimeException，其用法表示编程错误。通常可以通过检查前提条件来避免编程错误。所以这是一个基于此提示的错误示例。可以通过检查前提条件来避免异常，即这里的“hasNext()”方法。（[链接][Link 1]到源代码）

/**
     * Convert a tag string into a tag map.
     *
     * @param tagString a space-delimited string of key-value pairs. For example, {@code "key1=value1 key_n=value_n"}
     * @return a tag {@link Map}
     * @throws IllegalArgumentException if the tag string is corrupted.
     */
    public static Map<String, String> parseTags(final String tagString) throws IllegalArgumentException {
        
        // delimit by whitespace or '='
        Scanner scanner = new Scanner(tagString).useDelimiter("\\s+|=");
     
        Map<String, String> tagMap = new HashMap<String, String>();
        try {
        
            while (scanner.hasNext()) {
        
                String tagName = scanner.next();
                String tagValue = scanner.next();
                tagMap.put(tagName, tagValue);
            }
        } catch (NoSuchElementException e) {
        
            // The tag string is corrupted.
            throw new IllegalArgumentException("Invalid tag string '" + tagString + "'");
        } finally {
        
            scanner.close();
        }
     
        return tagMap;
    }

### 3. 避免不必要地使用检查异常 ###

检查异常迫使调用者处理异常情况，因为如果不处理，编译器会报错。过度使用已检查的异常会给调用者处理异常情况带来负担。所以必要时应该使用检查异常。使用已检查异常的经验法则是，当无法通过检查先决条件来避免异常时，调用者可以采取一些有用的操作来处理异常。

常用的运行时异常本身就是不过度使用已检查异常的示例。常见的[运行时异常][Link 2]有：ArithmeticException、ClassCastException、IllegalArgumentException、IllegalStateException、IndexOutOfBoundExceptions、NoSuchElementException 和 NullPointerException。

在下面的方法中（[链接][Link 3]到源代码），当 propertyName 不是目标情况之一时，调用者无能为力，因此抛出运行时异常。

@Override
    public Object get(String propertyName) {
        
      switch (propertyName.hashCode()) {
        
        case 842855857:  // marketDataName
          return marketDataName;
        case -1169106440:  // parameterMetadata
          return parameterMetadata;
        case 106006350:  // order
          return order;
        case 575402001:  // currency
          return currency;
        case 564403871:  // sensitivity
          return sensitivity;
        default:
          throw new NoSuchElementException("Unknown property: " + propertyName);
      }
    }

### 4. 支持使用标准异常 ###

最常被重用的 Java 异常类如下。[您可以在此处][Link 4]查看完整列表。

1. java.io.IOException
    2. java.io.FileNotFoundException
    3. java.io.UnsupportedEncodingException
    4. java.lang.reflect.InvocationTargetException
    5. java.security.NoSuchAlgorithmException
    6. java.net.MalformedURLException
    7. java.text.ParseException
    8. java.net.URISyntaxException
    9. java.util.concurrent.ExecutionException
    10. java.net.UnknownHostException

前 10 个都不是书中显示的最常用的。但注意这些是按项目计算的，即如果一个类在一个项目中被使用，那么无论项目中有多少方法使用它，它都只被计算一次。所以这是按项目数计算的，但是按代码中出现的次数计算的。

### 5. 抛出适合抽象的异常 ###

抛出的异常应该与调用者执行的任务有关。本项目介绍异常事务（捕获一个异常并抛出另一个）和异常链接（将一个异常包装在一个新的异常中以保持异常的因果链）。

private void serializeBillingDetails(BillingResult billingResult,
            BillingDetailsType billingDetails) {
        
     
        try {
        
            final JAXBContext context = JAXBContext
                    .newInstance(BillingdataType.class);
            final ByteArrayOutputStream out = new ByteArrayOutputStream();
            final Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty("jaxb.formatted.output", Boolean.FALSE);
            final BillingdataType billingdataType = new BillingdataType();
            billingdataType.getBillingDetails().add(billingDetails);
            marshaller.marshal(factory.createBillingdata(billingdataType), out);
            final String xml = new String(out.toByteArray(), "UTF-8");
            billingResult.setResultXML(xml.substring(
                    xml.indexOf("<Billingdata>") + 13,
                    xml.indexOf("</Billingdata>")).trim());
            billingResult.setGrossAmount(billingDetails.getOverallCosts()
                    .getGrossAmount());
            billingResult.setNetAmount(billingDetails.getOverallCosts()
                    .getNetAmount());
        } catch (JAXBException | UnsupportedEncodingException ex) {
        
            throw new BillingRunFailed(ex);
        }
    }

上述方法捕获 JAXBException 和 UnsupportedEncodingException，并重新抛出适合该方法抽象级别的新异常。新的 BillingRunFailed 异常包装了原始异常。所以这是异常链的一个很好的例子。异常链接的好处是保留有助于调试问题的较低级别的异常。（[链接][Link 5]到源代码）

### 6. 记录每个方法抛出的所有异常 ###

这是严重未充分利用的。大多数公共 API 都缺少 @throws Java 文档来解释抛出的异常。

这是一个很好的例子。（[链接][Link 6]到源代码）

...
     *
     * @throws MalformedURLException The formal system identifier of a
     * subordinate catalog cannot be turned into a valid URL.
     * @throws IOException Error reading subordinate catalog file.
     */
    public String resolveSystem(String systemId)
      throws MalformedURLException, IOException {
        
    ...

这是一个缺乏关于在什么情况下抛出异常的信息的坏例子。

* @throws Exception exception
     */
    public void startServer() throws Exception {
        
        if (!externalDatabaseHost) {

### 7. 在详细消息中包含故障捕获信息 ###

private OutputStream openOutputStream(File file) throws IOException {
        
        if (file.exists()) {
        
            if (file.isDirectory()) {
        
                throw new IOException("File '" + file + "' exists but is a directory");
            }
            if (!file.canWrite()) {
        
                throw new IOException("File '" + file + "' cannot be written to");
            }
        } else {
        
            final File parent = file.getParentFile();
            if (parent != null) {
        
                if (!parent.mkdirs() && !parent.isDirectory()) {
        
                    throw new IOException("Directory '" + parent + "' could not be created");
                }
            }
        }
        return new FileOutputStream(file, false);
    }

在此方法中，IOException 使用不同的字符串来传递不同的失败捕获信息。

### 8. 争取失败的原子性 ###

第 8 项是关于失败的。一般规则是失败的方法不应更改方法中对象的状态。为了尽早失败，一种方法是在执行操作之前检查参数的有效性。以下是遵循此提示的一个很好的示例。

/**
     * Assigns a new int value to location index of the buffer instance.
     * @param index int
     * @param newValue int
     */
    public void modifyEntry(int index, int newValue) {
        
            if (index < 0 || index > size - 1) {
        
                throw new IndexOutOfBoundsException();
            }
     
    //        ((int[]) bufferArrayList.get((int) (index / pageSize)))[index % pageSize] =
            ((int[]) bufferArrayList.get((index >> exp)))[index & r] =
                newValue;
    }

### 9. 不要忽视异常 ###

public static Bundle decodeUrl(String s) {
        
        Bundle params = new Bundle();
        if (s != null) {
        
            String array[] = s.split("&");
            for (String parameter : array) {
        
                String v[] = parameter.split("=");
                try {
        
                    params.putString(URLDecoder.decode(v[0], "UTF-8"), URLDecoder.decode(v[1], "UTF-8"));
                } catch (UnsupportedEncodingException e) {
        
                    e.printStackTrace();
                }
            }
        }
        return params;
    }

在生产代码中几乎总是应该避免打印堆栈跟踪。这与忽略异常一样糟糕。这将写入标准错误流，这不是日志使用日志记录框架的地方。（[链接][Link 7]到源代码）

您可能想[在 StackOverflow 上查看关于 Java 异常的前 10 个问题][StackOverflow _ Java _ 10]。

[Java Exception Handling Examples in Open Source Projects]: https://www.programcreek.com/2016/12/java-exception-handling-in-open-source-projects/
[20ed291445ec479fa70e7c5d1db861b4.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/b647fc7245b340908297b8f1bf22d6a3.png
[Effective Java]: https://amzn.to/34rS6qj
[Link 1]: https://www.programcreek.com/java-api-examples/?code=sps%2Fmetrics-opentsdb%2Fmetrics-opentsdb-master%2Fsrc%2Fmain%2Fjava%2Fcom%2Fgithub%2Fsps%2Fmetrics%2Fopentsdb%2FOpenTsdbMetric.java
[Link 2]: https://www.programcreek.com/2009/02/diagram-for-hierarchy-of-exception-classes/
[Link 3]: https://www.programcreek.com/java-api-examples/?code=OpenGamma%2FStrata%2FStrata-master%2Fmodules%2Fmarket%2Fsrc%2Fmain%2Fjava%2Fcom%2Fopengamma%2Fstrata%2Fmarket%2Fparam%2FCrossGammaParameterSensitivity.java
[Link 4]: https://www.programcreek.com/java-api-examples/index.php?action=search&ClassName=Exception&submit=Search
[Link 5]: https://www.programcreek.com/java-api-examples/?code=servicecatalog%2Fdevelopment%2Fdevelopment-master%2Foscm-billing%2Fjavasrc%2Forg%2Foscm%2Fbillingservice%2Fbusiness%2Fcalculation%2Frevenue%2FRevenueCalculatorBean.java
[Link 6]: https://www.programcreek.com/java-api-examples/?code=raysonfang%2Fjdk1.8-source-analysis%2Fjdk1.8-source-analysis-master%2Fsrc%2Fcom%2Fsun%2Forg%2Fapache%2Fxml%2Finternal%2Fresolver%2FCatalog.java
[Link 7]: https://www.programcreek.com/java-api-examples/?code=andforce%2FiBeebo%2FiBeebo-master%2Fapp%2Fsrc%2Fmain%2Fjava%2Forg%2Fzarroboogs%2Fweibo%2Fsupport%2Futils%2FUtility.java
[StackOverflow _ Java _ 10]: https://www.programcreek.com/2013/10/top-10-questions-about-java-exceptions/