标签: throwable

我想知道Java中处理和未处理的异常之间的区别.哪一个我应该使用try/catch块,当我必须扩展throwables.

另外,如果我扩展throwables,我是否总是要在一个单独的类中处理异常？

如果要在单独的类中处理异常,我可以创建自定义功能(例如,调用另一个方法或中断循环)而不是仅使用自定义消息覆盖超级构造函数吗？

简短版本: 如何捕获java.lang.Error特定代码段中的所有内容以便记录它们,并且还允许它们传播调用堆栈,就好像我根本没有捕获它们一样？

长版......

在一段代码中,我想要捕获所有内容java.lang.Error以便记录它们.但是我也想让Error继续在调用堆栈中继续工作,这样行为就像我根本没有抓住它一样.

另外,我想捕获并记录所有java.lang.Exceptions,然后让它们也传播调用堆栈.

我试过这个......

    } catch (Throwable e) {
        e.printStackTrace();
        throw e;
    } 

...但问题是我必须修改调用堆栈中更高的每个方法来抛出Throwable,并且其中一些方法不是我要修改的(我的方法是由第三方框架中的方法调用的).

我会对某种包装技术感到满意,我会把它放在Throwable别的东西上扔掉,但是我更愿意以java.lang.Error自然的方式让任何一个传播,就像我根本没有抓住它们一样.

建议？

编辑: 有人问:"为什么我要这样做？".我认为这是一个很好的问题,我将澄清:这是我公司使用的框架.它取决于jar中包含的其他框架,系统管理员可能忘记包含它们.在这种情况下,代码中的某些位置存在NoClassDefFoundError.但只有用户在浏览器中看到此错误,在服务器日志中找不到它.我想记录它,以便系统管理员可以知道发生了这个错误,因为他将有处理它的指令.

我需要获取引发异常的类名和方法名.我怎样才能做到这一点？提前致谢.

我的代码:

private void setErrorDetails(final Throwable cause) {
    for (final StackTraceElement ste : cause.getStackTrace()) {
        System.out.println(ste.getClassName()); 
        System.out.println(ste.getMethodName()); 
    }
}

通过这段代码,我可以得到一个类名和方法名列表.其中,我怎样才能得到抛出异常的方法和类名

我也尝试过这个.

 final StackTraceElement[] stackTrace = cause.getStackTrace();
    if ((stackTrace != null) && (stackTrace.length > 1)) {
                    final StackTraceElement stElement = stackTrace[0];

                    this.className = stElement.getClassName();
                    this.methodName = stElement.getMethodName();}

这是打印的堆栈跟踪.

16:01:24,093 INFO  [stdout] (http-localhost-127.0.0.1-8080-2) ????????????????????org.hibernate.ejb.Ejb3Configuration$Ejb3EntityNotFoundDelegate>>>Ejb3Configuration.java

16:01:24,094 INFO  [stdout] (http-localhost-127.0.0.1-8080-2) ????????????????????org.hibernate.event.internal.DefaultLoadEventListener>>>DefaultLoadEventListener.java

16:01:24,095 INFO  [stdout] (http-localhost-127.0.0.1-8080-2) ????????????????????org.hibernate.event.internal.DefaultLoadEventListener>>>DefaultLoadEventListener.java

16:01:24,096 INFO  [stdout] (http-localhost-127.0.0.1-8080-2) ????????????????????org.hibernate.event.internal.DefaultLoadEventListener>>>DefaultLoadEventListener.java

16:01:24,097 INFO  [stdout] (http-localhost-127.0.0.1-8080-2) ????????????????????org.hibernate.internal.SessionImpl>>>SessionImpl.java

16:01:24,097 INFO  [stdout] (http-localhost-127.0.0.1-8080-2) ????????????????????org.hibernate.internal.SessionImpl>>>SessionImpl.java

16:01:24,098 INFO  [stdout] …

我是JAVA的新手我准备我的OCP JP认证.

我对异常处理有这个疑问

try{
        assert(false):"HI";
    }
catch(Throwable e){}

我知道断言不应该被处理,但我只是用它来举例.从我所知的Object-> Throwable - >异常和错误

如果我在catch块中有Throwable或Exception或Error它可以工作但是当我有一个超类的对象时,eclipse会显示编译时错误.

任何我无法在catch块中拥有Object的原因？

假设我有一个名为BugException的类，该类从扩展而来，RuntimeException 并且BugException具有一个采用Throwable的副本构造函数。

这段代码编译和类型检查：

Throwable e = ...;
if (e instanceof BugException) {
   throw new BugException(e);
}

为什么会这样：

Throwable e = ...;
if (e instanceof BugException) {
   throw e;
}

不编译并给出错误消息：未处理的异常。java.lang.Throwable。？

为什么需要这种不必要的包装来满足类型检查器？

在Scala中，模式匹配在异常处理中的典型用法（至少对于像this和this这样的源而言）如下所示：

Try(...) match {
  case Success(_) => println("success")
  case Failure(exc) => println(s"caught: $exc")
}

但是，该模式也可以捕获块中Exception Throwable抛出的所有非变量try：

Try(throw new AssertionError("assertion error")) match {
  case Success(_) => println("success")
  case Failure(exc) => println(s"caught: $exc")
}

caught: java.lang.AssertionError: assertion error

至少在Java中，至少在Throwable没有令人信服的理由的情况下进行捕获通常被认为是一种反模式。（此消息源为Scala提供了相同的建议。）

避免无声捕获的一种选择Throwable是捕获并重新抛出它：

Try(throw new AssertionError("assertion error")) match {
  case Success(_) => println("success")
  case Failure(exc : Exception) => println(s"caught: $exc")
  case Failure(th) => throw th
}

但是，似乎很奇怪，必须进行额外的重新抛出来避免捕获非Exception Throwables（通常认为是不可恢复的），并且必须明确实现Throwable …

我正在编辑别人的代码,并且方法有"投掷可扔".我把它关掉了,所以eclipse会让我只添加它需要抛出的异常类型...但是我对一个调用超类(我目前没有访问权限)的方法有一个错误,上面写着"未处理的异常类型Throwable ".

基于我所知道的并基于我在这个鳕鱼中看到的东西,我的猜测是,这是不应该做的......但是有人可以证实吗？

是否有任何好的函数收集字符串中的异常的所有原因？该方法printStackTrace()使用StackTraces收集它们:

   HighLevelException: MidLevelException: LowLevelException
           at Junk.a(Junk.java:13)
           at Junk.main(Junk.java:4)
   Caused by: MidLevelException: LowLevelException
           at Junk.c(Junk.java:23)
           at Junk.b(Junk.java:17)
           at Junk.a(Junk.java:11)
           ... 1 more
   Caused by: LowLevelException
           at Junk.e(Junk.java:30)
           at Junk.d(Junk.java:27)
           at Junk.c(Junk.java:21)
           ... 3 more

但我只是想知道getMessage()原因:

   HighLevelException: MidLevelException: LowLevelException
   Caused by: MidLevelException: LowLevelException
   Caused by: LowLevelException

我应该写自己的功能吗？

当我编译以下代码时,一切正常,输出正如预期:

class Propogate {
    public static void main(String[] args) {
        Propogate obj = new Propogate();
        try {
            obj.reverse("");
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        } finally {
            System.out.println("That's all folks");
        }
    }
    String reverse(String s) {
        if(s.length() == 00) {
            throw new IllegalArgumentException();
        }
        String reversed = "";
        for(int i=s.length() - 1; i >= 0; --i) {
            reversed += s.charAt(i);
        }
        return reversed;
    }
}

计划结果:

java.lang.IllegalArgumentException
That's all folks

但是,当我运行完全相同的代码但更改异常类型时

IllegalArgumentException to plain old exception all I get is:Propogate.java:14: …

所以,我有这个类,我想打印调用哪些方法.当我运行它时,它只打印trace和main,但不打印method1和method2.如何更改它以便打印method1和method2,从main调用的方法？

public class SomeClass
{
    public void method1() {}
    public void method2() {}

    public static void main(String args[]) throws Throwable 
    {
        SomeClass c = new SomeClass();
        c.method1();
        c.method2();
        SomeClass.trace();
    }

    public static void trace() throws Throwable
    {
        Throwable t = new Throwable();
        StackTraceElement[] stack = t.getStackTrace();
        for(StackTraceElement s : stack)
        System.out.println(s.getMethodName());
    }
}

任何人都可以帮助我将这段代码转换为 lambda 表达式，我对此感到震惊

Observable.create(new OnSubscribe<User>() {
        @Override
        public void call(Subscriber<? super User> arg0) {
            User updatedUser = userService.updateuser(usermapper.userdtotoentity(user));
            arg0.onNext(updatedUser);
        }
    }).subscribe(new Action1<User>() {
        @Override
        public void call(User user) {
            if (user != null) {
                response.resume(user);
            } else
                response.resume(Response.status(Status.NOT_FOUND).build());
        }
    }, new Action1<Throwable>() {
        @Override
        public void call(Throwable t) {
            logger.debug("User with email_id:" + email_id + " is not present");
            response.resume(t);
        }
    });

如何从Throwable获取错误代码

public void onFailure(Throwable exception) {

   }

我看到我们可以获取错误消息,LocalizedMessage等

什么是内置基类来处理Java中的所有异常？它是例外还是可以投掷？

两个内置类有什么区别,有人可以解释一下.