Messaggio di errore di controllo null come "è null" o "è null"

Question

Quando si effettuano controlli nulli con il codice Java e si lancia espulsioni illeglargument per valori null, che tipo di modello di messaggi usi?

Tendiamo a usare qualcosa di simile

public User getUser(String username){
   if (username == null){
     throw new IllegalArgumentException("username is null");   
   }
   // ...
}

Cosa è meglio: "è nullo" o "è nullo", e perché?

Per me "è null" sembra più naturale.

Answer 1

Dal Exception viene lanciato a causa di un controllo preliminare fallito, penso piuttosto che semplicemente indicare un fatto, dovresti dichiarare il Requisiti che è stato violato.

Cioè, invece di dire "username is null", dire "username should not be null".

---

Usando le librerie per i controlli precondizionati

Come consiglio, puoi utilizzare una delle molte librerie progettate per facilitare i controlli precondizionari. Molti code in usi di guava com.google.common.base.Preconditions

Semplici metodi statici da chiamare all'inizio dei propri metodi per verificare gli argomenti e lo stato corretti. Ciò consente costrutti come

 if (count <= 0) {
   throw new IllegalArgumentException("must be positive: " + count);
 }

da sostituire con il più compatto

 checkArgument(count > 0, "must be positive: %s", count);

Più direttamente rilevante qui è che lo ha fatto checkNotNull, che ti consente di scrivere semplicemente:

  checkNotNull(username, "username should not be null");

Nota quanto naturalmente legge il codice sopra, con il messaggio dettagliato che indica esplicitamente il Requisiti che è stato violato.

L'alternativa di dichiarare fatti è più imbarazzante:

 // Awkward!
 checkArgument(count > 0, "is negative or zero: %s", count);
 checkNotNull(username, "username is null");

Inoltre, questo è anche potenzialmente meno utile, poiché il cliente potrebbe già essere consapevole del fatto e l'eccezione non li aiuta a capire quale sia l'effettivo requisiti sono.

---

SU IllegalArgumentException vs NullPointerException

Mentre il tuo codice originale lancia IllegalArgumentException Su null argomenti, guava Preconditions.checkNotNull lancia NullPointerException invece.

Ciò è conforme alle linee guida impostate dall'API:

NullPointerException: Le applicazioni dovrebbero lanciare istanze di questa classe per indicare altri usi illegali del null oggetto.

Inoltre, ecco una citazione da Efficace Java 2nd Edition: Articolo 60: favorisce l'uso delle eccezioni standard:

Probabilmente, tutte le invocazioni del metodo errate si riducono a un argomento illegale o a uno stato illegale, ma altre eccezioni sono standard utilizzate per certi tipi di argomenti e stati illegali. Se un chiamante passa null In alcuni parametri per i quali sono vietati i valori null, la convenzione lo determina NullPointerException essere lanciato piuttosto che IllegalArgumentException.

Answer 2

è zero, poiché l'argomento è ancora nullo ..

Tuttavia, perché non semplicemente lanciare un nullpointerException senza un messaggio?

Answer 3

Suggerirei di dire

  if (userName == null) {
     throw new IllegalArgumentException("username == null");
   }

Poiché questo è così fatale che un programmatore deve comunque guardarlo. Facendo riferimento allo snippet del codice offensivo nel messaggio di eccezione è la cosa più concis più che posso immaginare.

Answer 4

Sarei propenso a scrivere questo:

public User getUser(String username) {
   if (username.length() == 0) {
       throw new IllegalArgumentException("username is empty");   
   }
   // ...
}

Questo uccide due uccelli con una pietra. Innanzitutto, rileva il caso in cui il nome utente è una stringa vuota, che (per motivi di argomento) suppongo sia un errore. Secondo, se il parametro è null tentando di inviare il length la chiamata darà un NullPointerException.

Per il record, il previsto eccezione da lanciare per un inaspettato null è NullPointerException. Se il tuo motivo principale per non usarlo è che NPE in genere non ha un messaggio, codifica in questo modo:

public User getUser(String username){
   if (username == null){
       throw new NullPointerException("username is null");   
   }
   if (username.length() == 0) {
       throw new IllegalArgumentException("username is empty");   
   }
   // ...
}

Perché usare NPE è qui? Perché NPE indica quasi sempre un diverso tipo di problema a un altro tipo di errore di validazione dell'argomento; Ad esempio una cella di campo o array che non è stata inizializzata o un valore "opzionale" che non viene gestito correttamente.

Finalmente alla domanda:

Cos'è meglio : "is null" o "was null", e perché?

Questa è una questione di opinione, ma scriverei "is null".

• Perché il messaggio sta segnalando lo stato quando è stata lanciata l'eccezione.
• Perché è convenzionale farlo in questo modo.