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

Question

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

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

对于这类任务,我想知道一个用于管理异常的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;
  } 
}

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

谢谢你的建议

Answer 1

考虑围绕习语的执行.

另一个选项(实际上并非完全不同,它只是将它们分离出来)是在一个单独的线程中完成每个任务.

编辑:

这是我的想法:

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语言设计的选择 - 更喜欢简单而不是复杂的语言特性,如果不能正确完成,可能会使代码难以维护.