Question

我对这段代码完全不熟悉，并开始质疑原始开发人员的设计选择。

我有一个多线程Java应用程序，可以处理许多任务。我的工作是修复代码中的异常处理，以便在发生RuntimeException时（iBatis和/或NullPointerException）执行其余任务而不是线程终止。我想知道下面处理异常处理的最佳方法是什么：

public  List<WorkUnit> performModule(List<WorkUnit> listOfInputs)
            throws ModuleException {

        List<WorkUnit> listOfOutputs = new ArrayList<WorkUnit>();
        for (WorkUnit mi : listOfInputs) {
            WorkUnit mo=null;
            try {
                if (mi instanceof BulkOrder) {
                    mo = performModuleOperation(...);
                } else if (mi instanceof Order) {
                    mo = performModuleOperation(...);
                } else if (mi instanceof PreReleaseLoad) { 
                    mo = performModuleOperation(...);
                } else if (mi instanceof Load) {
                    mo = performModuleOperation(...);
                }
                listOfOutputs.add(mo);
            } catch (OMSException e) {
                  if (e.shouldProcessFurther()) {
                      listOfOutputs.add((mo!=null) ? mo : mi);
                  } 
                 //save error to database - code was removed
                  if ( e.getExceptionType().equals(ExceptionType.TECHNICAL)) {
                        if ( e instanceof ModuleException ) {
                            throw (ModuleException) e;
                        } else {
                        throw new ModuleException(e);   
                        }
                  } 
            } catch (Throwable th) {
                ModuleException me = new ModuleException(th);
                ExceptionHandler.logException(me, (WorkUnit)mi,orderDelegate);
                throw me;
            }

        }
        return listOfOutputs ;
    }

我有两个主要问题。 1）Throwable对象的捕获。我知道他们想要捕获已检查的异常和未经检查的异常。我猜他们也想检查错误，但是异常处理的Sun文档明确指出这是强烈建议的。如果您遇到一个非常严重的错误，例如JVM内存不足，您可能无法恢复。这可以在日志文件中捕获，我不同意需要处理它。就个人而言，如果您正在跟踪技术和应用程序异常错误，那么您可能会像其他任何异常一样监视错误。我错了......

2）目前尚不清楚如何处理异常。在下面的代码中，异常抛出上面的代码，它包装了一个常规异常，它被检查或取消选中到一个自定义异常中并抛出它。上面的代码查找OMSException，它是整个应用程序中每个自定义异常的父级。这是一个很好的设计吗？您可以看到它们在自定义异常对象中包含ExceptionType的位置。似乎已经在Java的现有异常处理中内置了一个功能。如果它是应用程序异常，则抛出自定义异常。如果它是一个技术异常，当它不是假设或数据库连接问题时，某些东西是null，然后从Java捕获未经检查的异常并做出相应的反应。整件事似乎令人困惑。我只想知道其他人对整个事情的想法。

public Order performModuleOperation(Order order)
            throws ModuleException {                                

        try {   
            Map<String, Rule> rules = ...                       

         }      
        catch (InductException ie) {
            throw ie;
        }
        catch (Exception e) {       
            e.printStackTrace();
            throw new InductException(e.toString(),e);
        }
        return order;
    }

Answer 1

有两种方法可以处理与未经检查的异常一起退出的线程。第一个选项是在try-catch块中运行线程，捕获所有错误和异常：

Thread t = new MyThread();
try {
  lauchThreadHere(t);
} catch (Throwable e) {
  // log `e` or re-launch thread `t` or do something else.
}

另一种方法是实施Thread.UncaughtExceptionHandler：

public class MyUeh implements Thread.UncaughtExceptionHandler {
    public void uncaughtException(Thread t, Throwable e) {
         // log `e` or re-launch thread `t` or do something else.
    }
}

Thread t = new MyThread();
t.setUncaughtExceptionHandler(new MyUeh());
lauchThreadHere(t);

在Java中处理运行时异常的正确方法

1 个答案: