Um "Logger final estático" deve ser declarado em MAIÚSCULAS?

Em Java, as variáveis ​​finais estáticas são constantes e a convenção é que elas devem estar em maiúsculas. No entanto, vi que a maioria das pessoas declara loggers em letras minúsculas, o que aparece como uma violação no PMD .

por exemplo:

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

Basta pesquisar no google ou no SO por "logger final estático" e você verá isso por si mesmo.

Em vez disso, deveríamos estar usando LOGGER?

A referência do criador de logs não é uma constante, mas uma referência final e NÃO deve estar em maiúsculas. Um valor constante deve estar em maiúsculas.

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

private static final double MY_CONSTANT = 0.0;

Para adicionar mais valor à resposta do crunchdog, o Java Coding Style Guide declara isso no parágrafo 3.3 Nomeação de campo

Os nomes dos campos usados ​​como constantes devem estar em maiúsculas, com sublinhados separando as palavras. As seguintes são consideradas constantes:

1. Todos static finalos tipos primitivos (lembre-se de que todos os campos da interface são inerentemente static final).
2. Todos static finalos tipos de referência de objeto que nunca são seguidos por " ." (ponto).
3. Todas as static finalmatrizes que nunca são seguidas por " [" (colchete de abertura).

Exemplos:

MIN_VALUE, MAX_BUFFER_SIZE, OPTIONS_FILE_NAME

Após esta convenção, loggeré uma static finalreferência a objeto, como indicado no ponto 2, mas, como é " ." seguido sempre que você a usa, ela não pode ser considerada uma constante e, portanto, deve ser minúscula.

De java eficaz, 2ª ed.,

A única exceção à regra anterior refere-se a "campos constantes", cujos nomes devem consistir em uma ou mais palavras em maiúsculas separadas pelo caractere sublinhado, por exemplo, VALUES ou NEGATIVE_INFINITY. Um campo constante é um campo final estático cujo valor é imutável . Se um campo final estático tiver um tipo primitivo ou um tipo de referência imutável (Item 15), será um campo constante. Por exemplo, constantes enum são campos constantes. Se um campo final estático tiver um tipo de referência mutável, ainda poderá ser um campo constante se o objeto referenciado for imutável.

Em resumo, constante == estática final, mais se for uma referência (versus um tipo simples), imutabilidade.

Olhando para o slf4j logger, http://www.slf4j.org/api/org/slf4j/Logger.html

É imutável. Por outro lado, o registrador JUL é mutável. O log4j logger também é mutável. Portanto, para ser correto, se você estiver usando log4j ou JUL, deve ser "logger" e, se estiver usando slf4j, deve ser LOGGER.

Observe que a página slf4j javadocs vinculada acima tem um exemplo em que eles usam "logger", não "LOGGER".

Naturalmente, essas são apenas convenções e não regras. Se você estiver usando o slf4j e quiser usar o "logger" porque está acostumado a isso em outras estruturas, ou se é mais fácil digitar ou para facilitar a leitura, vá em frente.

Gosto da opinião do Google ( Google Java Style )

Toda constante é um campo final estático, mas nem todos os campos finais estáticos são constantes. Antes de escolher um caso constante, considere se o campo realmente parece uma constante. Por exemplo, se qualquer estado observável dessa instância puder mudar, quase certamente não é uma constante. Apenas a intenção de nunca alterar o objeto geralmente não é suficiente.

Exemplos:

// 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"};

Se você estiver usando uma ferramenta automatizada para verificar seus padrões de codificação e violar os padrões, então ele ou os padrões devem ser corrigidos. Se você estiver usando um padrão externo, corrija o código.

A convenção no Sun Java é maiúscula para constantes estáticas públicas. Obviamente, um criador de logs não é constante, mas representa uma coisa mutável (caso contrário, não faria sentido chamar métodos na esperança de que algo aconteça); não existe um padrão específico para campos finais não constantes.

Se você pesquisar no Google, poderá descobrir que, em alguns casos, os registradores não são definidos como estáticos finais. Adicione uma cópia-e-colar rápida a isso, e isso pode explicar.

Usamos LOGGER em todo o nosso código, e isso corresponde à nossa convenção de nomenclatura (e nosso CheckStyle está satisfeito com isso).

Vamos ainda mais longe, aproveitando a convenção estrita de nomenclatura no Eclipse. Criamos uma nova classe com um modelo de código de:

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

O logger é comentado, pois inicialmente não precisamos dele. Mas, se precisarmos mais tarde, apenas descomentamos.

Em seguida, no código, usamos modelos de código que esperam que esse criador de logs esteja presente. Exemplo com o modelo try-catch:

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

Temos mais alguns modelos que o utilizam.

A convenção estrita nos permite ser mais produtivos e coerentes com os modelos de código .

Pessoalmente, acho que parece muito grande em maiúsculas. Além disso, como é uma classe que não está diretamente relacionada ao comportamento da classe, não vejo um grande problema em usar em loggervez de LOGGER. Mas se você for estritamente pedante, use LOGGER.

Não esqueça que o PMD respeitará um comentário com

// NOPMD

iniciar. Isso fará com que o PMD pule a linha de suas verificações, permitindo que você escolha o estilo que desejar.

Normalmente, as constantes estão em maiúsculas.

Os criadores de logs, no entanto, não devem ser estáticos, mas consultados para cada "novo" da classe que contém, se estiverem usando a fachada slf4j. Isso evita alguns problemas desagradáveis ​​do carregador de classes em contêineres da Web, além de permitir que a estrutura do criador de logs faça coisas especiais, dependendo do contexto da chamada.

Eu prefiro 'logger', ou seja, minúsculas. O motivo não é que seja uma constante ou não (mutável ou imutável). Se usarmos esse raciocínio, teremos que renomear a variável se alterarmos a estrutura de log (ou se a estrutura alterar a mutabilidade dos loggers).

Para mim, outros motivos são mais importantes.

1. Um criador de logs é um objeto de sombra na classe e não deve ser muito importante, pois não implementa a lógica principal. Se usarmos 'LOGGER', é atraente no código que atrai muita atenção.

2. Às vezes, os loggers são declarados no nível da instância (ou seja, não são estáticos) e até são injetados como uma dependência. Não gostaria de alterar meu código se decidir alterar a maneira de obter o logger. A estabilidade do código wrt. essa mudança (hipotética em muitos casos) é a outra razão pela qual prefiro a minúscula.

Se os seus padrões de codificação - se você tiver algum - dizem que devem estar em maiúsculas, então sim.

Não vejo nenhuma razão estrita de uma maneira ou de outra. Eu acho que depende totalmente de seus gostos pessoais resp. padrões de codificação da sua empresa.

BTW: eu prefiro "LOGGER" ;-)