通过运行时异常用注释包装异常

Question

有没有办法注释一个方法，以便所有抛出的异常都会自动转换为运行时异常？

@MagicAnnotation
// no throws clause!
void foo()
{
  throw new Exception("bar")'
}

Answer 1

Project Lombok 的 @SneakyThrows 可能就是您正在寻找的。 并没有真正包装您的异常（因为在很多情况下它可能是一个问题），它只是在编译期间不会抛出错误。

@SneakyThrows
void foo() {
    throw new Exception("bar")'
}

Answer 2

您可以使用 AspectJ 来完成此操作。 您声明一个连接点（在本例中调用方法 foo）并“软化”异常。

编辑对此进行详细说明：

假设您有以下类Bar：

public class Bar {

    public void foo() throws Exception {
    }
}

...并且您有这样的测试：

import junit.framework.TestCase;

public class BarTest extends TestCase {

    public void testTestFoo() {
        new Bar().foo();
    }
}

那么显然该测试不会编译。 它将给出一个错误：

Unhandled exception type Exception  BarTest.java(line 6)

现在要使用 AspectJ 克服这个问题，您可以编写一个非常简单的方面：

public aspect SoftenExceptionsInTestCode {

    pointcut inTestCode() : execution(void *Test.test*());

    declare soft : Exception : inTestCode();
}

该方面基本上表示测试中的任何代码（即：在以“Test”结尾的类中以“test”开头的方法） " 并返回 'void') 抛出异常应该被 AspectJ 编译器接受。 如果发生异常，AspectJ 编译器会将其包装并作为 RuntimeException 抛出。

事实上，如果您从 Eclipse（安装了 AJDT）中将这个测试作为 AspectJ 项目的一部分运行，那么测试将会成功，而如果没有该方面，它甚至无法编译。

Answer 3

没办法做到这一点，至少现在我使用这样的解决方法（简化）：

@SuppressWarnings({"rawtypes", "unchecked"})
public class Unchecked {
    public static interface UncheckedDefinitions{
        InputStream openStream();
        String readLine();
            ...
    }

  private static Class proxyClass = Proxy.getProxyClass(Unchecked.class.getClassLoader(), UncheckedDefinitions.class);

    public static UncheckedDefinitions unchecked(final Object target){
        try{
            return (UncheckedDefinitions) proxyClass.getConstructor(InvocationHandler.class).newInstance(new InvocationHandler(){
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if (target instanceof Class){
                        return MethodUtils.invokeExactStaticMethod((Class) target, method.getName(), args);
                    }

                  return MethodUtils.invokeExactMethod(target, method.getName(), args);
                }
            });
        }
        catch(Exception e){
            throw new RuntimeException(e);
        }
    }
}

用法看起来像：

import static ....Unchecked.*;

...

Writer w = ...;
unchecked(w).write(str, off, len);

诀窍是接口“从未完成”，每次我在某处需要未经检查的方法时，我都会将该对象包装到取消选中并让 IDE 在接口中生成方法签名。

然后实现是通用的（反射性和“慢”，但通常足够快）

有一些代码后处理器和字节码编织器，但这对于我当前的项目来说是不可能的（甚至aop或其他基于jvm的语言），所以这是“发明”。

Answer 4

我认为通过字节码重新设计、定制编译器或者面向方面的编程¹是可能的。 与 Java 不同，C# 仅有未经检查的异常²。

请问为什么要抑制已检查的异常？

¹ 根据 Maarten Winkels 的说法，这是可能的。
² 根据第 9 频道的一些视频，他们正在考虑引入经过检查的产品。

编辑：对于这个问题：从某种意义上说，您可以注释您的方法以将它们标记为检查异常抑制的候选者。 然后，您使用一些编译时或运行时技巧来应用实际的抑制/包装。

但是，由于我没有看到您的情况周围的环境，因此以这些方式包装异常可能会使该方法的客户端感到困惑 - 他们可能不准备处理 RuntimeException。 例如：该方法抛出 IOException，并且您的客户端将其捕获为 FileNotFoundException 以显示错误对话框。 但是，如果将异常包装到 RuntimeException 中，则错误对话框永远不会显示，并且可能还会杀死调用者线程。 （恕我直言）。

Answer 5

检查的异常是方法实现的责任。
非常非常仔细地对待这个事实。 如果可以的话，不要使用类似的解决方法工件。

Answer 6

在任何情况下，您都可以通过以下事实来做到这一点：Class.newInstance 不会将无参数构造函数抛出的 Exception 包装在InvokingTargetException； 相反，它默默地抛出它：

class ExUtil {
  public static void throwSilent(Exception e) { //NOTICE NO THROWS CLAUSE
      tl.set(e);
      SilentThrower.class.newInstance(); //throws silently
  }

  private static ThreadLocal<Exception> tl = new ThreadLocal<Exception>();
  private static class SilentThrower {
      SilentThrower() throws Exception {
          Exception e = tl.get();
          tl.remove();
          throw e;
      }
  }
}

然后你可以在任何地方使用这个实用程序：

ExUtil.throwSilent(new Exception());
//or
try {
  ioMethod();
} catch (IOException e) { ExUtil.throwSilent(e); }

顺便说一句，这是一个非常糟糕的主意:-)

Answer 7

我使用 Eclipse 的完成/模板系统来轻松包装任何代码块。

这是我的模板：

try { // Wrapp exceptions

${line_selection}${cursor}

} catch (RuntimeException e) { // Forward runtime exception
throw e;
} catch (Exception e) { // Wrap into runtime exception
throw new RuntimeException(
    "Exception wrapped in #${enclosing_method}", 
    e); 
}