java - org - ¿Cuál es la sobrecarga de crear un registrador SLF4J en contextos estáticos y no estáticos?
slf4j example (2)
Siempre he usado el siguiente patrón para construir (SLF4J) registradores:
private static final Logger log = LoggerFactory.getLogger(MyClass.class);
Esto ha funcionado hasta ahora, pero me preguntaba sobre el contexto static en algún momento y la necesidad de pasar el literal de la clase concreta todo el tiempo en lugar de usar un registrador no estático como
private final Logger log = LoggerFactory.getLogger(getClass());
Básicamente, esto se ha preguntado (y se ha respondido) aquí para LOG4J
El registrador debe ser privado estático o no
y aquí
¿Debe ser logger siempre final y estático?
Me doy cuenta de que el final es básicamente obligatorio, por lo que me pregunto qué tan alto es el costo de usar SLF4J en un contexto no estático.
Q:
¿Hay alguna sobrecarga práctica significativa de uso
private final Logger log = LoggerFactory.getLogger(getClass());
terminado
private static final Logger log = LoggerFactory.getLogger(MyClass.class);
en la aplicación promedio (web)? (No hay necesidad de "discutir" aplicaciones web de alto rendimiento y carga pesada aquí)
Tenga en cuenta que, en última instancia, estoy planeando utilizar un enfoque aún mejor utilizando CDI para obtener un registrador SLF4J como
@Inject private final Logger log;
como se describe aquí http://www.seamframework.org/Weld/PortableExtensionsPackage#H-TtLoggerttInjection , pero primero necesito saber sobre el almacenamiento en caché del registrador.
Pregunta secundaria: ¿es posible usarla ?:
@Inject private static final Logger log;
(comenzando con CDI para ser honesto)
La sobrecarga para las variables del registrador no estático (instancia) debe ser despreciable, a menos que se produzcan instancias, digamos 10000 o más. La palabra clave aquí es despreciable. Si se crea una instancia de muchos (> 10000) objetos, el impacto probablemente será medible pero aún así será bajo.
Más específicamente, un registrador de instancias aumenta la huella de memoria en una referencia (64 bits) por instancia de objeto. En el lado de la CPU, el costo es un hash de búsqueda por instancia, es decir, el costo de buscar el registrador adecuado en una tabla de hash (pequeña). Nuevamente, ambos costos deben ser despreciables a menos que se creen muchos objetos.
Esta pregunta también se discute en las preguntas frecuentes de SLF4J .
No estoy seguro de la sobrecarga exacta al usar LoggerFactory, pero dudo que afecte el rendimiento de su aplicación. Así que simplemente use estática o no estática como mejor le parezca.
¿Cuál debería ser el beneficio de usar @Inject. El LoggerFactory ya proporciona una abstracción de la implementación concreta. En cualquier caso, será mucho más lento que el LoggerFactory.
La sintaxis es más concisa cuando usa @Inject que es verdadero. Pero imagina que usas la clase en una prueba. Luego tienes que configurar la inyección para obtener el registro. Con el LoggerFactory normal, también funciona bien en las pruebas. Si Java tuviera un mecanismo genérico para @Inject, funcionaría muy bien, pero como es la configuración es más difícil.