Buenos ejemplos con java.util.logging

[java.util.logging][1] te evita tener que cargar un archivo jar más con tu aplicación, y funciona bien con un buen Formato.

En general, en la parte superior de cada clase, deberías tener:

private static final Logger LOGGER = Logger.getLogger( ClassName.class.getName() );

Entonces, puedes usar varias facilidades de la clase [Logger][2].

Use Nivel.MULTA para cualquier cosa que esté depurando en el nivel superior del flujo de ejecución:

LOGGER.log( Level.FINE, "processing {0} entries in loop", list.size() );

Usa "Level.FINER" / "Level.FINEST" dentro de los bucles y en lugares donde no siempre necesites ver tantos detalles cuando depures problemas básicos de flujo:

LOGGER.log( Level.FINER, "processing[{0}]: {1}", new Object[]{ i, list.get(i) } );

Usar las versiones parametrizadas de las instalaciones de registro para evitar la generación de toneladas de basura de concatenación de cadenas que la CG tendrá que mantener. Objeto[] como arriba es barato, en la asignación de la pila generalmente.

Con el manejo de excepciones, siempre registra los detalles completos de la excepción:

try {
    ...something that can throw an ignorable exception
} catch( Exception ex ) {
    LOGGER.log( Level.SEVERE, ex.toString(), ex );
}

Siempre paso ex.toString() como el mensaje aquí, porque entonces cuando "grep -n" para "Exception"; en los archivos de registro, puedo ver el mensaje también. De lo contrario, va a estar en la siguiente línea de salida generada por el volcado de pila, y tienes que tener un RegEx más avanzado para coincidir con esa línea también, lo que a menudo te da más salida de la que necesitas mirar.

[1]: http://docs.oracle.com/javase/7/docs/api/java/util/logging/package-summary.html [2]: http://docs.oracle.com/javase/7/docs/api/java/util/logging/Logger.html

Debería declarar al leñador así:

private final static Logger LOGGER = Logger.getLogger(MyClass.class.getName());

así que si refactorizas el nombre de tu clase, sigue.

Escribí un artículo sobre java logger con [ejemplos aquí][1].

[1]: http://hanoo.org/index.php?article=how-to-generate-logs-in-java

Hay muchos ejemplos y también de diferentes tipos para el registro. Echa un vistazo al paquete java.util.logging.

Código de ejemplo:

import java.util.logging.Logger;

public class Main {

  private static Logger LOGGER = Logger.getLogger("InfoLogging");

  public static void main(String[] args) {
    LOGGER.info("Logging an INFO-level message");
  }
}

Sin codificar el nombre de la clase:

import java.util.logging.Logger;

public class Main {
  private static final Logger LOGGER = Logger.getLogger(
    Thread.currentThread().getStackTrace()[0].getClassName() );

  public static void main(String[] args) {
    LOGGER.info("Logging an INFO-level message");
  }
}

SLF4J es una fachada de registro mejor que Apache Commons Logging (ACL). Tiene puentes a otros marcos de registro, haciendo que las llamadas directas a ACL, Log4J, o Java Util Logging pasen por SLF4J, de modo que usted puede dirigir toda la salida a un archivo de registro si lo desea, con un solo archivo de configuración de registro. ¿Por qué su aplicación utiliza varios marcos de registro? Porque las bibliotecas de terceros que utiliza, especialmente las más antiguas, probablemente lo hacen.

SLF4J soporta varias implementaciones de registro. Puede enviar todo a standard-out, usar Log4J, o Logback (recomendado sobre Log4J).

http://www.slf4j.org/

http://logback.qos.ch/

Usaría [minlog][1], personalmente. Es extremadamente simple, ya que la clase de registro es de unos pocos cientos de líneas de código.

[1]: https://github.com/EsotericSoftware/minlog

Le sugiero que utilice la utilidad de registro de Apache's commons. Es altamente escalable y soporta archivos de registro separados para diferentes registradores. Ver aquí.