非顺序任务中的 Java 异常处理(模式/良好实践)

Question

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

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

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

java简单的方法是:

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

但是如果其中一个 Action 有异常但又想尝试下一个？？

我想过这种方法，但似乎不太适合用于异常不知道能不能行，没关系，真的很烂!!

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;
  } 
}

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

谢谢你的建议

Answer 1

考虑 execute around 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 OO 范式所期望的)，这就是干净的 Java 版本最终的样子。 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 语言的设计选择 - 更喜欢简单而不是复杂的语言功能，如果做得不好，复杂的语言功能会使代码随着时间的推移难以维护。