4

有些任务不应该并行完成，（例如打开文件，读取，写入和关闭，有一个顺序......）

但是......有些任务更像是购物清单，我的意思是他们可以有一个理想的订单，但这不是必须的.​​.....例如通信或加载独立驱动程序等......

对于这类任务，我想知道管理异常的 Java 最佳实践或模式。

java简单的方法是：

 getUFO {
      try {
            loadSoundDriver();
            loadUsbDriver();
            loadAlienDetectorDriver();
            loadKeyboardDriver();    
  } catch (loadSoundDriverFailed) {
     doSomethingA;
  } catch (loadUsbDriverFailed) {
      doSomethingB;
  } catch (loadAlienDetectorDriverFailed) {
      doSomethingC;
  } catch (loadKeyboardDriverFailed) {
      doSomethingD;
  } 
}

但是如果在其中一个动作中出现异常但想 尝试下一个动作呢？

我想过这种方法，但似乎对异常没有很好的用途我不知道它是否有效，没关系，它真的很糟糕！

getUFO {
       Exception ex=null;
 try {
       try{  loadSoundDriver();
       }catch (Exception e)  {  ex=e; }
       try{  loadUsbDriver();
       }catch (Exception e)  {  ex=e; }
       try{ loadAlienDetectorDriver();
       }catch (Exception e)  {  ex=e; }
       try{  loadKeyboardDriver()
       }catch (Exception e)  {  ex=e; }

       if(ex!=null)
       { throw ex;
        }
  } catch (loadSoundDriverFailed) {
     doSomethingA;
  } catch (loadUsbDriverFailed) {
      doSomethingB;
  } catch (loadAlienDetectorDriverFailed) {
      doSomethingC;
  } catch (loadKeyboardDriverFailed) {
      doSomethingD;
  } 
}

找到更好的做法似乎并不复杂..我仍然没有

感谢您的建议

4

4 回答 4

5

考虑围绕 idiom 的执行。

另一种选择（实际上并没有什么不同，只是使它们更加分离）是在单独的线程中执行每个任务。

编辑：

这是我想到的那种事情：

public interface LoadableDriver {
     public String getName();
     public void loadDriver() throws DriverException;
     public void onError(Throwable e);
}

public class DriverLoader {
     private Map<String, Exception> errors = new HashMap<String, Exception>();

     public void load(LoadableDriver driver) {
        try {
           driver.loadDriver();
        } catch (DriverException e) {
           errors.put(driver.getName(), e);
           driver.onError(e);
        }
     }

    public Map<String, Exception> getErrors() { return errors; }
}

public class Main {
     public void loadDrivers() {
           DriverLoader loader = new DriverLoader();
           loader.loadDriver(new LoadableDriver(){
                public String getName() { return "SoundDriver"; }
                public void loadDriver() { loadSoundDriver(); }
                public void onError(Throwable e) { doSomethingA(); }
           });
           //etc. Or in the alternative make a real class that implements the interface for each driver.
           Map<String, Exception> errors = loader.getErrors();
           //react to any specific drivers that were not loaded and try again.
      }
 }

编辑：如果您将驱动程序实现为类，这就是干净的 Java 版本最终的样子（恕我直言，这是 Java OO 范式所期望的）。Main.loadDrivers() 方法会改变如下：

       public void loadDrivers(LoadableDriver... drivers) {
           DriverLoader loader = ...
           for(LoadableDriver driver : drivers) {
                 loader.load(driver);
           }
           //retry code if you want.
           Set<LoadableDriver> failures = loader.getErrors();
           if(failures.size() > 0 && tries++ > MAX_TRIES) {
               //log retrying and then:
               loadDrivers(drivers.toArray(new LoadableDriver[0]));
           }
       }

当然，我不再使用映射，因为对象将是自给自足的（您也可以摆脱 getName() 方法，但可能应该覆盖 toString()），因此错误只是在集合中返回以重试. 如果每个驱动程序负责知道它应该多久重试一次，那么您可以使重试代码更加简单。

Java 看起来不像做得好的 C++ 模板那么好，但这是 Java 语言设计的选择 - 更喜欢简单而不是复杂的语言功能，如果做得不好，随着时间的推移，代码很难维护。

于 2010-04-23T16:21:26.853 回答
3

尝试这个：

protected void loadDrivers() {
  loadSoundDriver();
  loadUsbDriver();
  loadAlienDetectorDriver();
  loadKeyboardDriver();    
}

然后：

protected void loadSoundDriver() {
  try {
    // original code ...
  }
  catch( Exception e ) {
    soundDriverFailed( e );
  }
}

protected void soundDriverFailed( Exception e ) {
  log( e );
}

这使子类有机会改变行为。例如，子类可以实现在单独的线程中加载每个驱动程序。主类不需要关心驱动程序是如何加载的，主类的任何用户也不需要关心。

于 2010-04-23T16:25:44.313 回答
1

IMO，对于您的情况，如果异常是“可忽略的”，最好是“loadSoundDriver”方法捕获异常并简单地返回错误。

然后在加载内容的函数中，您可以记录所有错误，并在序列结束时决定如何处理它们。[编辑] 像这样的东西：

// init
MyError soundErr = loadSoundDriver();
MyError otherErr = loadOtherDriver();

if(soundErr!=null || otherErr !=null){
 // handle the error(s)
}
于 2010-04-23T16:20:57.847 回答
0

只需用自己的 try / catch 块包围每个加载操作。

try {
  loadSoundDriver();
} catch (loadSoundDriverFailed) {
  doSomethingA;
} 

try {
  loadUsbDriver();
} catch (loadUsbDriverFailed) {
  doSomethingB;
}

  // ...

因此，您可以自行处理每个异常并继续处理 oder 操作。

于 2010-04-23T16:27:12.293 回答