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

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

Answer 2

试试这个：

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

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

Answer 3

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

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

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

if(soundErr!=null || otherErr !=null){
 // handle the error(s)
}

Answer 4

使用自己的try / catch块围绕每个加载操作。

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

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

  // ...

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

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

4 个答案: