Why catch throwable

As I said before in Java Exception best practices post, Ideally you should never catch Throwable or in particular Error. There are several reasons why catching an instance of java. Throwable is a bad idea because in order to catch them you have to declare at your method signature e.

When you do this, nobody knows what kind of Error this method is going to throw, and until you know what is the problem, how can you resolve that. The main purpose of providing Exception handling mechanism is to handle error situation properly, but you can't a provide a solution which can solve all problems. That's why we have specific Exception classes e. So if you don't know how to resolve or handle the error, there is no point catching Throwable , all it make your code hard to read and comprehend.

Some programmer catches Throwable and re-throw it by wrapping it into RuntimeException. Catching and re-throwing Exception after logging is OK but you must not rewrap the exception in a RuntimeException, and if you do make sure to preserve actual cause and stack-trace. Share to Twitter Share to Facebook. Labels: best of javarevisited , core java , core java interview question , error and exception. Martin said February 28, at PM javin paul said February 28, at PM Nick Stolwijk said October 28, at AM Anonymous said Newer Post Older Post Home.

Subscribe to: Post Comments Atom. Subscribe for Discounts and Updates Follow. Search This Blog. Stateless or javax. Stateful annotation to the class. Stateless beans must have a dependent scope while a stateful session bean can have any scope. By default they are transactional, but you can use the transaction attribute annotation.

There is no need to make any distinction when injecting one into the other. Again, the different scopes are handled by CDI through the use of proxying. One exception to this is that CDI does not support the injection of remote EJBs but that can be implemented by writing a simple producer method for it. The javax. Named annotation as well as any Qualifiers can be used on an EJB to match it to an injection point. In general, you should use CDI beans unless you need the advanced functionality available in the EJBs such as transactional functions.

If you are stuck in a servlet container and are using CDI, then either hand written transactions or your own transaction interceptor is the only option without EJBs. Please note that at the moment of writing this is not supported by all browsers, you probably need to transpile your code with babel or something similar.

Check that the JavaFX dependencies have been downloaded to your local m2 repository. Back on NetBeans, right click in the Dependencies folder and select Download Sources see the task progress in the bottom right taskbar , and then Download Javadoc see the task progress. Note that this fix has to be done only once, the rest of your Maven projects should pick JavaDoc and Sources. You could however catch only runtime exceptions thrown off the swing event dispatching thread using a proxy See this page for more information, copied code from there :.

Why catch Exceptions in Java, when you can catch Throwables? Asked 6 Months ago Answers: 5 Viewed 23 times. So, why would you want to catch Exceptions, when you can catch Throwables?

Please try again later or use one of the other support options on this page. Is this a good idea? As all of you know, Throwable is a generic superclass for all exception and errors in Java. As exceptions are meant to be caught, errors in most cases are not.

If we take a look at the Error class JavaDoc we will read the following:,An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Get in touch:. This is the ThreadDeath error. Recently, a bug report states that when you try to restart RAP sessions press F5 in a browser with the login dialog opened, the application freezes.

My first reaction was that this is another Throwable catch in the user code that prevents the propagation of the ThreadDeath error. Unfortunately, I was wrong. The javax. LoginContext class, responsible for authentication, uses reflection to execute the actual login method. It depends on what you're doing with the exception—why you're catching it.

A good example of why you would want to catch Throwable is to provide some sort of cleanup if there is any error. For example in JDBC, if an error occurs during a transaction, you would want to roll back the transaction:.

But as a general policy, catching Throwable because you don't have a reason and are too lazy to see which specific exceptions are being thrown is poor form and a bad idea. If there is any specific exception that you can possibly react on in a meaningful way, you could catch it first and do so. If there isn't and you're sure you will do the same thing for all exceptions and errors for example exit with an error-message , than it is not problem to catch the throwable.

Usually the first case holds and you wouldn't catch the throwable. But there still are plenty of cases where catching it works fine. Although it is described as a very bad practice, you may sometimes find rare cases that it not only useful but also mandatory.

Here are two examples. In a web application where you must show a meaning full error page to user. As another example, consider you have a service class which serves fund transfer business. Now imaging you get a List of fund transfers from user and you must use above service to do them all. But what will happen if any exception happens?

You should not stop, as one transfer may have been success and one may not, you should keep go on through all user List , and show the result to each transfer.

So you end up with this code. You can browse lots of open source projects to see that the throwable is really cached and handled. For example here is a search of tomcat , struts2 and primefaces :. Generally speaking you want to avoid catching Error s but I can think of at least two specific cases where it's appropriate to do so:. Throwable is the superclass of all the errors and excetions. If you use Throwable in a catch clause, it will not only catch all exceptions, it will also catch all errors.

Errors are thrown by the JVM to indicate serious problems that are not intended to be handled by an application. So you shouldn't catch Throwables unless your are pretty confident that it will only be an exception reside inside Throwable. The difference between an Exception and an Error is that an Exception is a state that has to be expected, while an Error is an unexpected state, which is usually fatal.

Errors usually cannot be recovered from and require resetting major parts of the program or even the whole JVM. Catching Exceptions is something you should always do to handle states that are likely to happen, which is why it is enforced by the JVM. Your code needs to be prepared to handle those situations as they can commonly occur.

How you handle those is up to you, there is no need to recover from everything, but your application should not boot back to desktop just because a web-server took a little longer to answer. Catching Errors is something you should do only if it is really necessary.

Generally you cannot recover from Errors and should not try to, unless you have a good reason to. Reasons to catch Errors are to close critical resources that would otherwise be left open, or if you i. Other reasons are to log additional information that might help to debug that error later, in which case you of course should rethrow it to make sure the application terminates properly.

Therefore use catch Throwable t only in such really important situation, otherwise stick to catch Exception e.