java - ¿Se debe declarar un "Registrador final estático" en MAYÚSCULAS?

static naming-conventions

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 las personas declaran registradores en minúsculas, lo que aparece como 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 estar utilizando LOGGER en su lugar?

Answer 1

De java efectivo, 2ª ed.,

La única excepción a la regla anterior se refiere a los "campos constantes", cuyos nombres deben constar de 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 (Artículo 15), entonces es un campo constante. Por ejemplo, las constantes de enumeración 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 == final estático, más si es una referencia (vs. un tipo simple), inmutabilidad.

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

Es inmutable. Por otro lado, el logger JUL es mutable. El logger 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 enlazada anteriormente tiene un ejemplo donde usan "logger", no "LOGGER".

Estas son, por supuesto, sólo las convenciones y no las reglas. Si estás usando slf4j y quieres usar "logger" porque estás acostumbrado a eso de otros marcos, o si es más fácil de escribir, o para facilitar la lectura, adelante.

Answer 2

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úsculas.

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

Answer 3

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 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. La mera 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"};

Answer 4

No olvides que PMD respetará un comentario con

// NOPMD

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

Answer 5

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

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

1. Todos los tipos primitivos static final (recuerde que todos los campos de la interfaz son inherentemente static final ).
2. Todos static final tipos de referencia de objetos 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, el logger es una referencia de objeto static final como se indica en el punto 2, pero como va seguido de " . " Cada vez que lo usa, no puede considerarse una constante y, por lo tanto, debe estar en minúscula.

Answer 6

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

Answer 7

Si busca en Google esto, puede encontrar que en algunos casos, los registradores no están definidos como final estático. Agregue un poco de copiar y pegar rápidamente a esto, y esto podría explicarlo.

Usamos LOGGER en todo nuestro código, y esto corresponde a nuestra convención de nombres (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 utilizan.

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

Answer 8

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

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

Answer 9

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

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

BTW: prefiero "LOGGER" ;-)

Answer 10

Usualmente las constantes están en mayúsculas.

Los madereros, sin embargo, no deben ser estáticos, sino que buscan cada "nueva" clase contenedora si usan la fachada slf4j. Esto evita algunos problemas desagradables en el cargador de clases, especialmente en los contenedores web, además de permitir que el marco del registrador realice tareas especiales dependiendo del contexto de invocación.