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

En Java, las variables finales estáticas son constantes y la convención es que deberían estar en mayúsculas. Sin embargo, he visto que la mayoría de las personas declara a los madereros en minúsculas, lo que se considera una violación en PMD .

p.ej:

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

Simplemente busque en google o SO "logger final estático" y verá esto por sí mismo.

¿Deberíamos usar LOGGER en su lugar?

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

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

private static final double MY_CONSTANT = 0.0;

Para agregar más valor a la respuesta de crunchdog, la Guía de estilo de codificación de Java establece esto en el párrafo 3.3.

Los nombres de los campos que se usan como constantes deben estar en mayúsculas, con guiones bajos que separan las palabras. Los siguientes se consideran constantes:

1. Todos static finallos tipos primitivos (recuerde que todos los campos de la interfaz son inherentemente static final).
2. Todos los static finaltipos de referencia de objeto que nunca son seguidos por " ." (punto).
3. Todas static final matrices que nunca van seguidas de " [" (corchete de apertura).

Ejemplos:

MIN_VALUE, MAX_BUFFER_SIZE, OPTIONS_FILE_NAME

Siguiendo esta convención, loggeres una static finalreferencia de objeto como se indica en el punto 2, pero debido a que es seguido por " ." cada vez que lo utilice, no se puede considerar como una constante y por lo tanto debe estar en minúsculas.

De java efectivo, 2da ed.,

La única excepción a la regla anterior se refiere a "campos constantes", cuyos nombres deben consistir en una o más palabras en mayúscula 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 referenciado es inmutable.

En resumen, constante == final estático, 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 log4j logger también es mutable. Para ser correcto, si está utilizando log4j o JUL, debería ser "logger", y si está utilizando slf4j, debería ser LOGGER.

Tenga en cuenta que la página slf4j javadocs vinculada anteriormente tiene un ejemplo en el que usan "logger", no "LOGGER".

Por supuesto, estas son solo convenciones y no reglas. Si está utilizando slf4j y desea utilizar "logger" porque está acostumbrado a eso desde otros marcos, o si es más fácil de escribir, o para facilitar la lectura, continúe.

Me gusta la versión de Google ( Google Java Style )

Cada constante es un campo final estático, pero no todos los campos finales estáticos son constantes. Antes de elegir un 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. La simple intención de 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"};

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 tendría sentido invocar métodos con la esperanza de que algo suceda); No existe un estándar específico para los campos finales no constantes.

Si googleas esto, es posible que en algunos casos, los registradores no estén definidos como estáticos finales. Agregue un poco de copiar y pegar a esto, y esto podría explicarlo.

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

Incluso vamos más allá, aprovechando la estricta convención de nomenclatura 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á comentado, ya que inicialmente 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 plantillas más que lo usan.

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

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 en el uso en loggerlugar de LOGGER. Pero si vas a ser estrictamente pedante, entonces úsalo LOGGER.

No olvides que PMD respetará un comentario con

// NOPMD

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

Por lo general, las constantes están en mayúsculas.

Sin embargo, los registradores no deben ser estáticos, sino que deben buscar cada "nuevo" de la clase que los contiene si se usa la fachada slf4j. Esto evita algunos problemas desagradables del cargador de clases en contenedores web, además, permite que el marco del registrador haga cosas especiales dependiendo del contexto de invocación.

Prefiero 'logger', es decir, la minúscula. La razón no es que sea una constante o no una constante (mutable o inmutable). Si usáramos ese razonamiento, tendríamos que cambiar el nombre de la variable si cambiamos el marco de registro (o si el marco cambia la mutabilidad de los registradores).

Para mí, otras razones son más importantes.

1. Un registrador es un objeto sombra en la clase y no debe ser muy prominente ya que no implementa la lógica principal. Si usamos 'LOGGER', es un punto de atracción en el código que atrae demasiada atención.

2. A veces, los registradores se declaran a nivel de instancia (es decir, no como estáticos) e incluso se inyectan como una dependencia. No me gustaría cambiar mi código si decido cambiar la forma en que obtengo el registrador. El código de estabilidad wrt. Este cambio (hipotético en muchos casos) es la otra razón por la que prefiero la minúscula.

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

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

Por cierto: prefiero "LOGGER" ;-)