È meglio usare assert o IllegalArgumentException per i parametri del metodo richiesti?

In Java, che è più raccomandato, e perché? Entrambi i tipi genereranno eccezioni, quindi a questo proposito gestirli è lo stesso. assertè leggermente più corto, ma non sono sicuro di quanto sia importante.

public void doStuff(Object obj) {
    assert obj != null;
    ...
}

vs

public void doStuff(Object obj) {
    if (obj == null) {
        throw new IllegalArgumentException("object was null");
    }
    ...
}

ATTENZIONE!

Le asserzioni vengono rimosse in fase di esecuzione a meno che non si specifichi esplicitamente di "abilitare asserzioni" durante la compilazione del codice. Le asserzioni Java non devono essere utilizzate sul codice di produzione e devono essere limitate ai metodi privati (vedere Eccezione vs Asserzione ), poiché si prevede che i metodi privati ​​siano conosciuti e utilizzati solo dagli sviluppatori. Inoltre, assertverrà generato AssertionError che Errornon si estende Exceptione che normalmente indica un errore molto anomalo (come "OutOfMemoryError" da cui è difficile recuperare, non è vero?) Che non ci si aspetta che sia in grado di trattare.

Rimuovi il flag "abilita asserzioni" e verifica con un debugger e vedrai che non passerai alla chiamata di lancio IllegalArgumentException ... poiché questo codice non è stato compilato (di nuovo, quando "ea" viene rimosso)

È meglio usare la seconda costruzione per metodi pubblici / protetti, e se vuoi qualcosa che viene fatto in una riga di codice, c'è almeno un modo che conosco. Io personalmente uso lo Spring Framework 's Assertclasse che ha un paio di metodi per il controllo di argomenti e che tiro 'IllegalArgumentException' in caso di fallimento. Fondamentalmente, quello che fai è:

Assert.notNull(obj, "object was null");

... Che infatti eseguirà esattamente lo stesso codice che hai scritto nel tuo secondo esempio. Ci sono alcuni altri metodi utili come hasText, hasLengthlì dentro.

Non mi piace scrivere più codice del necessario, quindi sono contento quando riduco il numero di righe scritte di 2 (2 righe> 1 riga) :-)

Devi usare un'eccezione. L'uso di un'asserzione sarebbe un uso improprio della funzione.

Le eccezioni non selezionate sono progettate per rilevare errori di programmazione degli utenti della tua libreria, mentre le asserzioni sono progettate per rilevare errori nella tua logica. Questi sono problemi separati che non devono essere mescolati.

Ad esempio, un'affermazione

assert myConnection.isConnected();

significa "So che ogni percorso di codice che porta a questa affermazione assicura che myConnectionsia collegato; se il codice sopra non è riuscito a ottenere una connessione valida, avrebbe dovuto generare un'eccezione o tornare prima di raggiungere questo punto."

D'altra parte, un assegno

if (!myConnection.isConnected()) {
    throw new IllegalArgumentException("connection is not established");
}

significa che "Chiamare la mia libreria senza stabilire una connessione è un errore di programmazione".

Se si sta scrivendo una funzione che non consente nullcome valore di parametro valido, è necessario aggiungere l' @Nonnullannotazione alla firma e utilizzare Objects.requireNonNullper verificare se l'argomento è nulle lanciare un NullPointerExceptionse lo è. L' @Nonnullannotazione è per la documentazione e in alcuni casi fornirà avvisi utili al momento della compilazione. Non impedisce il nullpassaggio in fase di esecuzione.

void doStuff(@Nonnull Object obj) {
    Objects.requireNonNull(obj, "obj must not be null");

    // do stuff...
}

Aggiornamento: l' @Nonnullannotazione non fa parte della libreria standard Java. Esistono invece numerosi standard concorrenti delle librerie di terze parti (vedi Quale annotazione @NotNull Java dovrei usare? ). Ciò non significa che sia una cattiva idea usarlo, solo che non è standard.

Preferisco sempre gettare IllegalArgumentException sulle asserzioni.

Le asserzioni vengono utilizzate principalmente in JUnit o in altri strumenti di test, per controllare / affermare i risultati dei test. Quindi potrebbe dare una falsa impressione ad altri sviluppatori che il tuo metodo sia un metodo di prova.

Inoltre ha senso lanciare IllegalArgumentException quando un metodo ha superato un argomento illegale o inappropriato . Ciò è più coerente con la convenzione di gestione delle eccezioni seguita dagli sviluppatori Java.

Il secondo IMO è leggermente migliore perché porta più informazioni e potrebbe essere ulteriormente esteso (ad esempio estendendo la classe di eccezioni) per essere ancora più informativo, inoltre non utilizza il confronto negativo che è più facile da capire.

Non uso molto gli Aserts, ma un approccio comune con Lombock @NonNull: https://projectlombok.org/features/NonNull

Implementazione di Lombok: import lombok.NonNull;

public class NonNullExample extends Something {
  private String name;

  public NonNullExample(@NonNull Person person) {
    super("Hello");
    this.name = person.getName();
  }
}

Versione Java:

 import lombok.NonNull;

public class NonNullExample extends Something {
  private String name;

  public NonNullExample(@NonNull Person person) {
    super("Hello");
    if (person == null) {
      throw new NullPointerException("person");
    }
    this.name = person.getName();
  }
}

Lombok è una biblioteca davvero carina che uso ovunque