¿Cuál es la forma correcta de usar un registrador en una clase Serializable de Java?

Question

Tengo la siguiente (adulterada) clase en un sistema en el que estoy trabajando y Findbugs está generando una advertencia SE_BAD_FIELD y estoy tratando de entender por qué diría eso antes de que lo solucione de la manera en que pensé haría. La razón por la que estoy confundido es porque la descripción parece indicar que no he usado otros campos de instancia no serializables en la clase, pero bar.model.Foo tampoco es serializable y se usa de la misma manera (en la medida en que se puede decir) pero Findbugs no genera ninguna advertencia.

import bar.model.Foo; 

import java.io.File; 
import java.io.Serializable; 
import java.util.List; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 

public class Demo implements Serializable { 

    private final Logger logger = LoggerFactory.getLogger(this.getClass()); 
    private final File file; 
    private final List<Foo> originalFoos; 
    private Integer count; 
    private int primitive = 0; 

    public Demo() { 
     for (Foo foo : originalFoos) { 
      this.logger.debug(...); 
     } 
    } 

    ... 

} 

Mi rubor inicial a una solución es conseguir una referencia registrador de la fábrica de la derecha como lo uso:

public DispositionFile() { 
    Logger logger = LoggerFactory.getLogger(this.getClass()); 
    for (Foo foo : originalFoos) { 
     this.logger.debug(...); 
    } 
} 

que no parece particularmente eficiente, sin embargo.

¿Pensamientos?

Answer 1

En primer lugar, no optimice prematuramente. Puede ser que LoggerFactory.getLogger() sea lo suficientemente rápido y no genere una sobrecarga significativa en el tiempo de ejecución. Si tiene dudas, perfúlelo.

En segundo lugar, la razón de que findbugs no se queja sobre el uso de Foo es porque la clase no tiene un campo de tipo Foo, que tiene un campo de tipo List. Los genéricos se borran en el momento de la compilación, no existe una referencia real al Foo en la clase, en lo que respecta a la definición del campo. En tiempo de ejecución, el hecho de que Foo no sea serializable provocaría una excepción si intentara serializar una instancia de la clase Demo, pero findbugs no puede saber esto.

Mi primera reacción sería hacer que el Logger sea un campo estático, en lugar de un campo de instancia. Debería funcionar bien en esta situación.

public class Demo implements Serializable { 
    private static final Logger logger = LoggerFactory.getLogger(Demo.class); 

    // .. other stuff 
} 

Answer 2

No quiero que las cosas despeguen en una tangente, pero ¿ha considerado la inicialización convencional de los registradores?

private static final Logger logger = LoggerFactory.getLogger(Demo.class); 

Si realmente no necesita diferentes registradores para cada instancia (lo cual es inusual), el problema desaparecería.

Por cierto, el author de SL4J dijo (en una critique de envoltorios Log4J como commons-logging),

Más a menudo que no, estas envolturas son de dudosa calidad tal que el costo de las declaraciones inactivas (o deshabilitadas) de registro se multiplican por un factor de 1'000 (mil) en comparación con uso directo de log4j. El error más común en las clases contenedoras es la invocación del método Logger.getLogger en cada solicitud de registro. Esto es garantizado para causar estragos en el rendimiento de su aplicación . ¡¡¡De Verdad!!!

Eso sugeriría que su idea alternativa de obtener el registrador cada vez que la necesite no es recomendable.

Answer 3

FindBugs le está engañando en este caso particular porque la interfaz org.slf4j.Logger es no marcada como java.io.Serializable. Sin embargo, las implementaciones de registrador SLF4J que se incluyen con SLF4J son compatibles con la serialización lista para usar. Intentalo. Verás que funciona.

Aquí es un extracto de la AYUDA SLF4J:

Contrariamente a las variables estáticas, variables de instancia son serializados por defecto. A partir de SLF4J versión 1.5.3, las instancias del registrador sobreviven a la serialización. Por lo tanto, la serialización de la clase de host no requiere más acción especial, , incluso cuando los registradores se declaran como variables de instancia . En versiones anteriores de , las instancias de registrador necesarias para se declaran como transitorias en la clase de host .

Ver también http://slf4j.org/faq.html#declared_static

Answer 4

Mi reacción inicial es preguntarse si es que tiene sentido para serializar una instancia Logger en su objeto. Cuando lo deserializa más tarde, ¿es realmente justo esperar que el entorno del Registrador sea el correcto? Creo que preferiría ir con esto y lo llaman un día:

private transient Logger logger = LoggerFactory.getLogger(this.getClass());