当前位置:天才代写 > tutorial > JAVA 教程 > 打破Java异常处理惩罚法则

打破Java异常处理惩罚法则

2017-11-11 08:00 星期六 所属: JAVA 教程 浏览:640

副标题#e#

Q: 我在我的应用措施中挪用了外部要领而且想捕捉它大概抛出的异常。我能捕捉java.lang.Exception吗?

A: 通过一个给定的要领去处理惩罚所有运行时和检测异常对付防范外部错误是不充实的。

你可以去读今朝 JavaWorld文章 – “Java Tip 134: When Catching Exception, Don’t Cast Your Net Too Wide”。这篇文章告诫了捕捉java.lang.Exception和java.lang.Throable是欠好的。捕捉你能指定的异常对付代码的可维护性是十分重要的。然而这个法则依赖于非凡的情况。假如你不规划你的措施瓦解而且保存你的数据布局的安详异常,那么你必需捕捉被抛出的真正的异常。

举个例子,想象你有一个加载了这个接口的处事器应用:

public interface IFoo
{
  /**
  * This method can't throw any checked exceptions...or can it?
  */
  void bar ();
} // End of interface

对付给出参数的来由是让我们通知你这样的处事在什么处所,而且差异的IFoo实现可以或许从外部资源加载上。你写如下代码:

try
{
  IFoo foo = ... // get an IFoo implementation
  foo.bar ();
}
catch (RuntimeException ioe)
{
  // Handle 'ioe' ...
}
catch (Error e)
{
  // Handle or re-throw 'e' ...
}

而且你在这个里处理惩罚了所有大概的异常。你不需要在这里加上任何捕捉java.io.IOException的异常,因为IFoo实现没有从IFoo.bar()中抛出它,对吗?(事实上,假如你加上了捕捉java.io.IOException异常块,编译器大概会把它作为不行达到的异常而扬弃)

错误。在我写的EvilFoo类中bar()要领证明白将抛出你通报给类结构器的任何异常:

public void bar ()
{
  EvilThrow.throwThrowable (m_throwthis);
}

运行Main要领:

public class Main
{
  public static void main (final String[] args)
  {
   // This try/catch block appears to intercept all exceptions that
   // IFoo.bar() can throw; however, this is not true
   try
   {
    IFoo foo = new EvilFoo (new java.io.IOException ("SURPRISE!"));
    foo.bar ();
   }
   catch (RuntimeException ioe)
   {
    // Ignore ioe
   }
   catch (Error e)
   {
    // Ignore e
   }
  }
} // End of class

你将看到从bar()要领抛出的java.io.IOException异常实例而且没有任何捕捉块:

>java -cp classes Main
Exception in thread "main" java.io.IOException: SURPRISE!
at Main.main(Main.java:23)


#p#副标题#e#

在这里产生了什么?

主要的调查是凡是针对检测异常的Java法则仅仅在编译的时候被执行。在运行的时候,一个JVM不能担保被一个要领抛出的异常是否和在这个要领中声明的抛出异常相匹配。因为挪用要领的职责是捕捉和处理惩罚所有从挪用要领抛出的异常。任何没有被挪用要领声明的异常将不予答理而且拒绝挪用栈。

假如正常行为是编译器执行,那么我怎么建设EvilFoo的?至少有两个要领可以去建设抛出没有声明的异常的Java要领:

Thread.stop(Throwable)在一些时候不被赞成利用,可是它仍然被利用而且通报一个Throwable给被挪用的Thread。

别离编译:你能在编译EvilFoo时候不去编译真正声明bar()要领抛出检测异常的IFoo姑且版本。

我用后一种选择:我编译开始界说的EvilThrow类:

public abstract class EvilThrow
{
  public static void throwThrowable (Throwable throwable)
  throws Throwable
  {
   throw throwable;
  }
}

接下来,我用Byte Code Engineering Library(BCEL)的JasminVisitor解析功效,在汇编代码中删除throwThrowable()要领Throwable的声明,而且用Jasmin assembler 编译新的版本。

假如你编写捕捉异常的结构器,那么它应该老是捕捉java.lang.Throwable而不只仅只捕捉java.lang.Exception。这个法则适合你开拓打点运行时的应用措施和必需执行大概包括错误甚至恶意代码的外部组件。你要确保捕捉Throwable而且过滤掉错误信息。

下面示例说明白假如你没有遵循这个发起将产生什么。

Example: Breaking SwingUtilities.invokeAndWait()

javax.swing.SwingUtilities.invokeAndWait()是在AWT上执行一个线程的有用要领。当一个应用措施线程必需更新图形用户接口而且听从所有Swing线程法则的时候这个要领将被挪用。一个没有捕捉Runnable.run()抛出的异常将被捕捉而且被封装在一个InvocationTragetException中从头抛出。

Sun的J2SE1.4.1假设这样一个未捕捉的异常仅仅是java.lang.Exception的子类。这里是一个SwingUtilities.invokeAndWait()挪用java.awt.event.InvocationEvent的一个阐明:

#p#分页标题#e#

public void dispatch() {
  if (catchExceptions) {
   try {
    runnable.run();
   }
   catch (Exception e) {
    exception = e;
   }
  }
  else {
   runnable.run();
  }
  if (notifier != null) {
   synchronized (notifier) {
    notifier.notifyAll();
   }
  }
}

这段代码的问题是假如runnable.run()抛出一个Throwable,捕捉块又没有而且notifier.notifyAll()从来不会被执行。然后挪用应用线程将期待在java.awt.EventQueue.invokeAndWait()里的一个非民众锁工具(lock.wait()将从未执行):

public static void invokeAndWait(Runnable runnable)
throws InterruptedException, InvocationTargetException {
  class AWTInvocationLock {}
  Object lock = new AWTInvocationLock();
  InvocationEvent event =new InvocationEvent(Toolkit.getDefaultToolkit(), runnable, lock,
true);
  synchronized (lock) {
   Toolkit.getEventQueue().postEvent(event);
   lock.wait();
  }
  Exception eventException = event.getException();
  if (eventException != null) {
   throw new InvocationTargetException(eventException);
  }
}

让EvilFoo实现Runnable接口:

public void run ()
{
  bar ();
}

然后,在Main中挪用它:

SwingUtilities.invokeAndWait (new EvilFoo (new Throwable ("SURPRISE!")));

正如你看到的,未受信任代码使你的代码进入你没有筹备处理惩罚的执行路径中的异常被掩护起来。

 

    关键字:

[contact-form-7 id="17097" title="form2"]天才代写-代写联系方式