Using e.printStackTrace() in Java

Question

Why does NetBeans IDE raise a flag on printing a Java stack trace?

try { 
    //try to do something there
} catch (IOException e) {
    //handle the exception 
    e.printStackTrace();
}

For some reason the printStackTrace is underlined in a squiggly line. When I Quick-Fix (Alt+Enter), NetBeans reports Throwable.printStackTrace() should be removed. What does this mean?

Hypha

Answer 1

It is just a recommendation. In eclipse it is fine - I believe it is just the IDE telling you that there are more conventional methods of doing it, like some of the other answers. I find that it is useful for debugging, and that you should tell users when a fatal error is going to occur, to use a debug mode (like a console switch -d) to collect these logs.

Grunberg

using a logging framework like log4j is one such better method. – Bluff

Answer 2

Try:

e.printStackTrace(System.out);

Ruthie

Ah, thanks @Pablo! Crazy, why does this make the warning disappear exactly? If you don't specify System.out as a parameter and leave it blank, does the JVM assume its' a debug-mode command and only outputs to the console? – Scarberry

Hack! This doesn't really resolve the problem as much as it just stops Netbeans showing it. This will still output to the default error stream. – Boesch

@Boesch System.err will print to the default error stream, not System.out. System.out represents the default output stream. – Hemihedral

Would it be better to use e.printStackTrace(System.err);? – Anorak

Answer 3

It's probably because printStackTrace() doesn't really handle the error as much as it just dumps the stack in the console. It acts as a placeholder until you replace it with proper error handling (if it is needed at all) and replace the output with a logger of some sort.

Unbidden

Answer 4

e.printStackTrace();

Is not good practice because it prints in the default ErrorStream, which most of the times is the console!

NetBeans should be warning you about that. The good practice about it, is logging the message. Follow same reference:

http://onjava.com/pub/a/onjava/2003/11/19/exceptions.html

EDIT See first comment bellow to more info.

Samirasamisen

No, it prints to the default Errorstream, which is a seperate stream, alias FileDescriptor, and can be piped to a separate file: java YourClass 1>file.out 2>file.err - the e.printStackTrace prints to 'file.err', not 'file.out'. – Edington

Not always is a good practice. This console might be a console in a web server where you can't access. Sometimes it's better to have this stack trace dumped also in the current log of the application, specially in web applications. – Weinberger

Answer 5

Just printing a stack trace is not enough. Printing the exception's stack trace in itself doesn't mean that it is completely bad practice, but printing only the stack trace when an exception occurs is an issue.

Always log exceptions(using a good logging framework), but do not expose them to the end-user. And keep ensure that showing stack traces only in development mode.

I myself use(most of the time) logger.log(Level.SEVERE, <exception>.getMessage(), <exception>);.

when netbeans suggest you to handle the exception 'Surround Statement with try-catch', if you click on this, it will generate):

try {
    //something need to be handle(exception that throw)
} catch (SQLException ex) {
    Logger.getLogger(ClassName.class.getName()).log(Level.SEVERE, null, ex);
}

Which is better than ex.printStackTrace();.

These may help:

• Best Practices for Exception Handling
• Javarevisited- logging's.
• What are the latest options in Java logging frameworks?
• Benchmarking Java logging frameworks.

Inexhaustible