Un "Logger finale statico" deve essere dichiarato in MAIUSCOLO?

In Java, le variabili finali statiche sono costanti e la convenzione è che dovrebbero essere in maiuscolo. Tuttavia, ho visto che molte persone dichiarano i logger in minuscolo, il che costituisce una violazione di PMD .

per esempio:

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

Basta cercare su Google o SO "logger finale statico" e lo vedrai da solo.

Dovremmo usare invece LOGGER?

Il riferimento del logger non è una costante, ma un riferimento finale e NON deve essere maiuscolo. Un valore costante deve essere in maiuscolo.

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

private static final double MY_CONSTANT = 0.0;

Per aggiungere più valore alla risposta di crunchdog, la Guida allo stile di codifica Java lo afferma nel paragrafo 3.3 Denominazione dei campi

I nomi dei campi utilizzati come costanti devono essere tutti in maiuscolo, con caratteri di sottolineatura che separano le parole. Sono considerate costanti:

1. Tutti static finali tipi primitivi (Ricorda che tutti i campi dell'interfaccia sono intrinsecamente static final).
2. Tutti i static finaltipi di riferimento oggetto che non sono mai seguiti da " ." (punto).
3. Tutti gli static finalarray che non sono mai seguiti da " [" (parentesi quadra aperta).

Esempi:

MIN_VALUE, MAX_BUFFER_SIZE, OPTIONS_FILE_NAME

In base a questa convenzione, si loggerfa static finalriferimento a un oggetto come indicato al punto 2, ma poiché è seguito da " ." ogni volta che lo si utilizza, non può essere considerato come una costante e quindi dovrebbe essere minuscolo.

Dall'efficace java, 2a edizione,

L'unica eccezione alla regola precedente riguarda i "campi costanti", i cui nomi devono essere costituiti da una o più parole maiuscole separate dal carattere di sottolineatura, ad esempio VALUES o NEGATIVE_INFINITY. Un campo costante è un campo finale statico il cui valore è immutabile . Se un campo finale statico ha un tipo primitivo o un tipo di riferimento immutabile (elemento 15), allora è un campo costante. Ad esempio, le costanti enum sono campi costanti. Se un campo finale statico ha un tipo di riferimento modificabile, può comunque essere un campo costante se l'oggetto a cui si fa riferimento è immutabile.

In sintesi, costante == finale statico, più se si tratta di un riferimento (rispetto a un tipo semplice), immutabilità.

Guardando il logger slf4j, http://www.slf4j.org/api/org/slf4j/Logger.html

È immutabile D'altra parte, il logger JUL è modificabile. Anche il logger log4j è modificabile. Quindi, per essere corretti, se stai usando log4j o JUL, dovrebbe essere "logger", e se stai usando slf4j, dovrebbe essere LOGGER.

Si noti che la pagina javadocs slf4j collegata sopra ha un esempio in cui usano "logger", non "LOGGER".

Queste sono ovviamente solo convenzioni e non regole. Se ti capita di usare slf4j e vuoi usare "logger" perché sei abituato a farlo da altri framework, o se è più facile da scrivere, o per leggibilità, vai avanti.

Mi piace la versione di Google ( Google Java Style )

Ogni costante è un campo finale statico, ma non tutti i campi finali statici sono costanti. Prima di scegliere il caso costante, considera se il campo sembra davvero una costante. Ad esempio, se uno qualsiasi degli stati osservabili di quell'istanza può cambiare, quasi sicuramente non è una costante. La sola intenzione di non mutare mai l'oggetto non è generalmente sufficiente.

Esempi:

// 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 si utilizza uno strumento automatizzato per verificare gli standard di codifica e viola tali standard, è necessario fissarli. Se si utilizza uno standard esterno, correggere il codice.

La convenzione in Sun Java è maiuscola per le costanti statiche pubbliche. Ovviamente un logger non è costante, ma rappresenta una cosa mutevole (altrimenti non avrebbe senso chiamare metodi su di esso nella speranza che accada qualcosa); non esiste uno standard specifico per i campi finali non costanti.

Se lo cerchi su Google, potresti scoprire che in alcuni casi i logger non sono definiti come final statici. Aggiungi un po 'di copia e incolla a questo, e questo potrebbe spiegarlo.

Usiamo LOGGER in tutto il nostro codice e questo corrisponde alla nostra convenzione di denominazione (e il nostro CheckStyle ne è soddisfatto).

Andiamo anche oltre, sfruttando la rigida convenzione di denominazione in Eclipse. Creiamo una nuova classe con un modello di codice di:

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

Il logger è commentato, poiché inizialmente non ne abbiamo bisogno. Ma dovremmo averne bisogno in un secondo momento, lo decommentiamo.

Quindi, nel codice, utilizziamo modelli di codice che prevedono che questo logger sia presente. Esempio con il modello try-catch:

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

Abbiamo alcuni altri modelli che lo usano.

La rigorosa convenzione ci consente di essere più produttivi e coerenti con i modelli di codice .

Personalmente penso che sia davvero grande in maiuscolo. Inoltre, dal momento che è una classe che non è direttamente correlata al comportamento della classe, non vedo un grosso problema nell'uso loggerinvece di LOGGER. Ma se stai per essere rigorosamente pedante, allora usa LOGGER.

Non dimenticare che PMD rispetterà un commento con

// NOPMD

dentro. Questo farà sì che PMD salti la linea dai suoi controlli, questo ti permetterà di scegliere lo stile che desideri.

Di solito le costanti sono in maiuscolo.

I logger, tuttavia, non dovrebbero essere statici ma cercare ogni "nuovo" della classe contenente se si utilizza la facciata slf4j. Ciò evita alcuni fastidiosi problemi con il classloader in particolare i container web, inoltre consente al framework logger di fare cose speciali a seconda del contesto di invocazione.

Preferisco il "logger", ovvero il minuscolo. Il motivo non è che è una costante o non una costante (mutabile o immutabile). Se utilizzassimo tale ragionamento, dovremmo rinominare la variabile se cambiamo il framework di registrazione (o se il framework cambia la mutabilità dei logger).

Per me, altri motivi sono più importanti.

1. Un logger è un oggetto ombra nella classe e non dovrebbe essere molto importante in quanto non implementa la logica principale. Se usiamo 'LOGGER', è un elemento che attira l'attenzione nel codice che attira troppa attenzione.

2. A volte i logger sono dichiarati a livello di istanza (cioè non come statici) e persino iniettati come dipendenza. Non vorrei cambiare il mio codice se decido di cambiare il modo in cui ottengo il logger. La stabilità del codice wrt. questo (ipotetico cambiamento in molti casi) è l'altro motivo per cui preferisco il minuscolo.

Se i tuoi standard di codifica, se ne hai, dicono che dovrebbe essere maiuscolo allora sì.

Non vedo alcun motivo rigoroso per un modo o per l'altro. Penso che dipenda totalmente dalle tue preferenze personali. gli standard di codifica della tua azienda.

A proposito: preferisco "LOGGER" ;-)