通过策略模式处理Java异常？

我编写了一个类

ExceptionHandler

（见下文），以消除一些（我认为是）样板代码，这些代码会使实际实现变得混乱，同时如果将来需要，仍然为显式异常处理提供一个钩子。在大多数情况下，在我的应用程序中（基本上是一个科学计算），没有从异常中恢复这样的事情——我需要一个问题日志，这样我就可以修复它，否则，一旦问题得到纠正，我将重新运行

其他人会这样做吗（至少在我的特定应用情况下）？这样做是愚蠢的吗（如果是的话，解释一下为什么会很好）

例外处理程序：

public abstract class ExceptionHandler<ExceptionType extends Exception,OptionalReturn> {
 public abstract OptionalReturn handle(ExceptionType e);

//assorted boilerplate ExceptionHandling, e.g.:

 public static <ET extends Exception> ExceptionHandler<ET, ?> swallower(final boolean printStackTrace, final String string) {
  return new ExceptionHandler<ET,Object>() {
   @Override public Object handle(ET e) {
    if(printStackTrace) { e.printStackTrace(); }
    if(string!=null && !string.isEmpty()) { System.err.println(string); }
    return null;
   }
  };
 }

 public static <ET extends Exception> ExceptionHandler<ET, ?> swallower() { return swallower(false,null); }

}

公共抽象类异常处理程序{
公共摘要可选返回句柄（e型除外）；
//分类样板例外处理，例如：
公共静态异常处理程序吞咽器（最终布尔printStackTrace，最终字符串）{
返回新的ExceptionHandler（）{
@重写公共对象句柄（ET e）{
if（printStackTrace）{e.printStackTrace（）；}
if（string！=null&&！string.isEmpty（））{System.err.println（string）；}
返回null；
}
};
}
公共静态异常处理程序吞咽器（）{返回吞咽器（false，null）；}
}

示例使用（我正在进行删减，所以我实际上没有写太多）：

公共类Getter实现函数IEH；
私人例外处理人EEH；
public static final ExceptionHandler IEH_snowner=ExceptionHandler.snowner（true，“返回null”）；
public static final ExceptionHandler EEH_snowner=ExceptionHandler.snowner（true，“返回null”）；
private Getter（）{this（EEH_燕子，EEH_燕子）；}
私有Getter（ExceptionHandler IEH，ExceptionHandler EEH）{
this.IEH=IEH；
this.EEH=EEH；
}
公共静态Getter make（）{返回新Getter（）；}
公共静态Getter生成（ExceptionHandler IEH，ExceptionHandler EEH）{
返回新的Getter（IEH，EEH）；
}
@从应用覆盖公共（未来IEH，例外处理程序EEH）{
尝试{return src.get（）；}
catch（InterruptedException e）{IEH.handle（e）；}
catch（ExecutionException e）{EEH.handle（e）；}
返回null；
}
}

---

它与库一起用于执行一些令人尴尬的并行计算，并将Futures的实际Iterable转换为类似Iterables.transform（futureCollection，Getter.make（）），而不是复杂的内部类和异常处理。

我发现代码很难理解。它充满了

静态

，这在面向对象设计中通常是一个不好的标志，并且很难使用泛型

像这样简单的工作不是也可以吗

private static <T> T getter(Future<T> src) {
    try { return src.get(); }
     catch (InterruptedException e) { handle( "some text"); }
     catch (ExecutionException e) { handle( e ) }
     return null;
    }

此解决方案的

越少，这通常也是一个好迹象

但我可能遗漏了一点，因为您发布的代码只是整个代码的摘录

看看这个问题，这也是相关的：

编辑

如果我上面提出的解决方案过于简单，无法满足您的需要，那么以下是两种其他方法：

public class AbstractGetter<From> implements Function<Future<? extends From>, From> {

private abstract handleInterrupt( Exception e );
private abstract handleExecution( Exception e );

private static <T> T getter(Future<T> src ) {
    try { return src.get(); }
    catch (InterruptedException e) { handleInterrupt(e) }
    catch (ExecutionException e) { handleExecution(e) }
    return null;
    }
}

公共类AbstractGetter实现函数我认为这是一个很好的解决方案，但它可以从ExceptionHandlerFactory和一些xml文件中获益。
啊，静态主要是为了避免使用泛型参数（例如，Getter bar=new Getter（）vs.Getter bar=Getter.make（））进行大量构造函数调用。私有方法是静态的，主要是为了提醒所有Getter都做相同的事情，因此它们可以使用一个方法，但是需要一些委托来处理泛型/继承。是的。我说的更多的是与异常处理相关的泛型。re:edit：这似乎与我目前所做的非常相似-ExceptionHandler是一种处理特定类型异常的策略。在我的示例中，默认策略是在基类中指定的，在构建该类时可以选择提供特定的策略。当然，找到正确的平衡是一个问题。我只是觉得你的代码太复杂了，不能理解，可以简化一点（我仍然不明白在
ExceptionHandler
中第二个泛型参数的必要性，我真的被所有
静态的
搞糊涂了，尤其是
这个.IEE和
这个.EEH，它们是大写字母，但不是静态的，一眼就看不清名字）。你已经发布了反馈代码，我建议了3种在我看来更简单的选择——那就看你了。我敢不同意。添加更多的东西很少是一个解决方案——特别是需要解析的XML文件，等等。艺术是让事情变得简单，而不是复杂……在神话中，（1）什么颜色和（2）性情通常会出现吗？不过，是的，我确实考虑过“为什么要烦恼”。解决方案。然而，代码的受众是科学家，而不是开发人员。对95%的人来说，适当的异常处理会分散他们的注意力，但对替代处理感兴趣的5%的人不应该觉得我的实现过于繁重。至少，这是计划。你能不能把示例代码缩进一点？它看起来很有趣，但是很难读。
handle( String msg )
handle( Exception e )
handle( Exception e, String msg )

public class AbstractGetter<From> implements Function<Future<? extends From>, From> {

private abstract handleInterrupt( Exception e );
private abstract handleExecution( Exception e );

private static <T> T getter(Future<T> src ) {
    try { return src.get(); }
    catch (InterruptedException e) { handleInterrupt(e) }
    catch (ExecutionException e) { handleExecution(e) }
    return null;
    }
}

  public interface ErrorStrategy
  {
        public void handleInterrupt(Exception e);
        public void handleExecution(Exception e);
  }

  public class Getter<From> implements Function<Future<? extends From>, From> {

  ErrorStrategy handler = new DefaultErrorStrategy(). // default one

  public Getter<From>()
  {
  }

  public Getter<From>( ErrorStrategy h )
  {
      this.handler = h.
  }

  private static <T> T getter(Future<T> src ) {
    try { return src.get(); }
    catch (InterruptedException e) { handler.handleInterrupt(e) }
    catch (ExecutionException e) { handler.handleExecution(e) }
    return null;
    }
 }