Verwenden Sie System.out.println nicht im serverseitigen Code

Es ist eine schlechte Praxis, denn wenn Sie Ihre Anwendung in der Produktion, Sie können nicht separate Anwendung, die logs von server-logs.

Prod teams wollen, dass Sie getrennt von Protokollen, die von Ihrer Anwendung aus dem app-server (tomcat, websphere, etc...) : Sie wollen in der Lage sein monitor die app-server diffrently machen von der Anwendung selbst.

Darüber hinaus mit dem System.aus, können Sie nicht definieren, das log-level : in der Produktion, die Sie nicht drucken möchten, die debug-Informationen.

InformationsquelleAutor der Antwort Jean-Philippe Briend

Ist es als schlecht, weil System.out.println(); frisst mehr cpu-und so-Ausgabe kommt langsam bedeutet schmerzt die Leistung. (Eigentlich jeder I/O-Betrieb frisst cpu).

InformationsquelleAutor der Antwort Harry Joy

Zum einen, dass mehrere Anfragen auf Ihre server und drucken Sie das Protokoll auf System.out ist nicht gute Praxis.

1. Alle Protokolle gedruckt werden auf dem Bildschirm (file descriptor). Es gibt keine Möglichkeit, Blättern Sie zurück und Lesen Sie das Protokoll.
2. System.out ist nicht synchronisiert. Es muss eine Parallelität verwalten drucken über System.out
3. Sie nicht feststellen können log-Stufen durch System.out. Sie können nicht trennen Sie Ihre log-Level auf separate Ausgänge auf die Fliegen.

Ich hoffe, das hilft.

InformationsquelleAutor der Antwort Buhake Sindi

Ein weiterer Grund ist, dass System.out und err sind PrintStreams, die verbrauchen alle zugrunde liegenden IOExceptions. Sehen Sie diese Methoden von PrintStreams:

/**
 * Writes the specified byte to this stream.  If the byte is a newline and
 * automatic flushing is enabled then the <code>flush</code> method will be
 * invoked.
 *
 * <p> Note that the byte is written as given; to write a character that
 * will be translated according to the platform's default character
 * encoding, use the <code>print(char)</code> or <code>println(char)</code>
 * methods.
 *
 * @param  b  The byte to be written
 * @see #print(char)
 * @see #println(char)
 */
public void write(int b) {
    try {
        synchronized (this) {
            ensureOpen();
            out.write(b);
            if ((b == '\n') && autoFlush)
                out.flush();
        }
    }
    catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    }
    catch (IOException x) {
        trouble = true;
    }
}

/**
 * Flushes the stream and checks its error state. The internal error state
 * is set to <code>true</code> when the underlying output stream throws an
 * <code>IOException</code> other than <code>InterruptedIOException</code>,
 * and when the <code>setError</code> method is invoked.  If an operation
 * on the underlying output stream throws an
 * <code>InterruptedIOException</code>, then the <code>PrintStream</code>
 * converts the exception back into an interrupt by doing:
 * <pre>
 *     Thread.currentThread().interrupt();
 * </pre>
 * or the equivalent.
 *
 * @return <code>true</code> if and only if this stream has encountered an
 *         <code>IOException</code> other than
 *         <code>InterruptedIOException</code>, or the
 *         <code>setError</code> method has been invoked
 */
public boolean checkError() {
    if (out != null)
        flush();
    if (out instanceof java.io.PrintStream) {
        PrintStream ps = (PrintStream) out;
        return ps.checkError();
    }
    return trouble;
}

Also eine IOException aus, die aus der zugrunde liegenden Strom wird IMMER verbraucht, und in der Regel die Menschen rufen niemals checkError auf dem System aus, so dass Sie nicht einmal wissen, dass etwas passiert ist.

InformationsquelleAutor der Antwort Gábor Lipták