¿Debería declararse un "Registrador final estático" en MAYÚSCULAS?

Question

En Java, las variables finales estáticas son constantes y la convención es que deben estar en mayúsculas. Sin embargo, he visto que la mayoría de la gente declara los registradores en minúsculas, que aparece como una infracción en PMD.

por ejemplo:

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

Sólo la búsqueda google o SO para "registrador static final" y verá esto por sí mismo.

¿Deberíamos estar usando LOGGER en su lugar?

Answer 1

La referencia del registrador no es una constante, sino una referencia final, y NO debe estar en mayúsculas. Un VALOR constante debe estar en mayúscula.

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

private static final double MY_CONSTANT = 0.0; 

Answer 2

Personalmente creo que se ve muy grande en mayúsculas. Además, dado que es una clase que no está directamente relacionada con el comportamiento de la clase, no veo un problema importante al usar logger en lugar de LOGGER. Pero si vas a ser estrictamente pedante, entonces usa LOGGER.

Answer 3

No necesariamente. Lea esto - Naming Conventions

RESUMEN: Los nombres de las variables constantes de clase declarados y de ANSI constantes deben estar en mayúsculas con palabras separadas por guiones bajos ("_").

Answer 4

Si está utilizando una herramienta automatizada para verificar sus estándares de codificación y viola dichos estándares, entonces o los estándares deben ser reparados. Si está utilizando un estándar externo, arregle el código.

La convención en Sun Java es mayúscula para las constantes estáticas públicas. Obviamente, un registrador no es constante, pero representa una cosa mutable (de lo contrario no habría ningún método de invocación de puntos en él con la esperanza de que algo suceda); no hay un estándar específico para campos finales no constantes.

Answer 5

Si busca en Google esto, puede encontrar que, en algunos casos, los registradores no se definen como estáticos finales. Agregue un poco de copiar y pegar rápido a esto, y esto podría explicarlo.

Utilizamos LOGGER en todo nuestro código, y esto corresponde a nuestra convención de nomenclatura (y nuestro CheckStyle está contento con él).

---

Incluso vamos más allá, aprovechando la estricta convención de nombres en Eclipse. creamos una nueva clase con una plantilla de código de:

// private static final Logger LOGGER = Logger.getLogger(${enclosing_type}.class); 

El registrador está comentada, como en un principio que no lo necesitamos. Pero si lo necesitamos más tarde, simplemente lo descomentamos.

Luego, en el código, usamos plantillas de código que esperan que este registrador esté presente.Ejemplo con la plantilla try-catch:

try { 
     ${cursor} or some other template 
    } catch (Exception t) { 
     LOGGER.error("${methodName} ${method parameters}", t); 
    } 

tenemos algunas más plantillas que lo utilizan.

La estricta convención nos permite ser más productivos y coherentes con las plantillas de código.

Answer 6

Normalmente las constantes están en mayúsculas.

Los madereros, sin embargo, no deberían ser estáticos sino que buscaron cada "nuevo" de la clase que los contenía si usaban la fachada slf4j. Esto evita algunos problemas desagradables del cargador de clases en contenedores notablemente web, además permite que el marco del registrador haga cosas especiales dependiendo del contexto de invocación.

Answer 7

Si sus estándares de codificación, si tiene alguno, diga que debería estar en mayúsculas, entonces sí.

No veo ninguna razón estricta para una forma u otra. Creo que depende totalmente de tus gustos personales resp. los estándares de codificación de su empresa.

Por cierto: yo prefiero "Logger" ;-)

Answer 8

No se olvide que el PMD respetar un comentario con

// NOPMD 

en ella. Esto hará que PMD omita la línea de sus cheques, esto le permitirá elegir el estilo que desee.

Answer 9

desde Java efectiva, 2ª ed.,

La única excepción a las anteriores preocupaciones de reglas “campos constante”, cuyos nombres deben consistir en una o más palabras en mayúsculas separadas por el carácter de subrayado, por ejemplo, VALUES o NEGATIVE_INFINITY. Un campo constante es un campo final estático cuyo valor es inmutable. Si un campo final estático tiene un tipo primitivo o un tipo de referencia inmutable (Elemento 15), entonces es un campo constante. Por ejemplo, las constantes enum son campos constantes. Si un campo final estático tiene un tipo de referencia mutable , aún puede ser un campo constante si el objeto al que se hace referencia es inmutable.

En resumen, constante == static final, más si es una referencia (frente a un tipo simple), inmutabilidad.

Mirando el registrador slf4j, http://www.slf4j.org/api/org/slf4j/Logger.html

es inmutable. Por otro lado, el registrador JUL es mutable. El registrador log4j también es mutable. Entonces, para ser correcto, si está usando log4j o JUL, debería ser "logger", y si está usando slf4j, debería ser LOGGER.

Tenga en cuenta que la página slf4j javadocs vinculada anteriormente tiene un ejemplo donde usan "registrador", no "REGISTRADOR".

Estas son, por supuesto, solo convenciones y no reglas. Si está usando slf4j y quiere usar "logger" porque está acostumbrado a eso de otros frameworks, o si es más fácil de escribir, o de legibilidad, siga adelante.

Answer 10

Para añadir más valor a la respuesta de crunchdog, Java Coding Style Guide Los estados esta en el párrafo 3.3 de nomenclatura de campos

Los nombres de los campos que se utiliza como constantes debe ser todo en mayúsculas, subrayado con la separación de palabras. Los siguientes son considerados como constantes:

1. Todos static final tipos primitivos (Recuerde que todos los campos de interfaz son inherentemente static final).
2. Todos los tipos de referencia de objeto static final que nunca son seguidos por "." (punto).
3. Todas las matrices static final que nunca son seguidas por "[" (punto).

Ejemplos:

MIN_VALUE, MAX_BUFFER_SIZE, OPTIONS_FILE_NAME 

Siguiendo esta convención, logger es una referencia static final objeto como se indica en el punto 2, pero debido a que es seguido de "." cada vez que se utiliza, no se puede considerar como una constante y, por lo tanto, debe ser minúscula.

Answer 11

me gusta tomar de Google en él (Google Java Style)

Cada constante es un campo static final, pero no todos los campos estáticos finales son constantes. Antes de elegir el caso constante, considere si el campo realmente se siente como una constante. Por ejemplo, si cualquiera de los estados observables de esa instancia puede cambiar, es casi seguro que no es una constante. Simplemente, intentar nunca mutar el objeto generalmente no es suficiente.

Ejemplos:

// Constants 
static final int NUMBER = 5; 
static final ImmutableList<String> NAMES = ImmutableList.of("Ed", "Ann"); 
static final Joiner COMMA_JOINER = Joiner.on(','); // because Joiner is immutable 
static final SomeMutableType[] EMPTY_ARRAY = {}; 
enum SomeEnum { ENUM_CONSTANT } 

// Not constants 
static String nonFinal = "non-final"; 
final String nonStatic = "non-static"; 
static final Set<String> mutableCollection = new HashSet<String>(); 
static final ImmutableSet<SomeMutableType> mutableElements = ImmutableSet.of(mutable); 
static final Logger logger = Logger.getLogger(MyClass.getName()); 
static final String[] nonEmptyArray = {"these", "can", "change"};