Controlla due argomenti in Java, entrambi non nulli o entrambi nulli in modo elegante

Ho usato Spring Boot per sviluppare un progetto shell utilizzato per inviare e-mail, ad es

sendmail -from foo@bar.com -password  foobar -subject "hello world"  -to aaa@bbb.com

Se le frome passwordgli argomenti sono mancanti, io uso un mittente e la password predefiniti, ad esempio, noreply@bar.come 123456.

Quindi, se l'utente passa l' fromargomento, deve passare anche l' passwordargomento e viceversa. Vale a dire, entrambi sono non nulli o entrambi sono nulli.

Come posso controllare questo elegantemente?

Ora la mia strada è

if ((from != null && password == null) || (from == null && password != null)) {
    throw new RuntimeException("from and password either both exist or both not exist");
}

C'è un modo usando l' operatore ^( XOR ):

if (from == null ^ password == null) {
    // Use RuntimeException if you need to
    throw new IllegalArgumentException("message");
}

La ifcondizione sarà vera se solo una variabile è nulla.

Ma penso che di solito sia meglio usare due ifcondizioni con diversi messaggi di eccezione. Non puoi definire cosa è andato storto usando una singola condizione.

if ((from == null) && (password != null)) {
    throw new IllegalArgumentException("If from is null, password must be null");
}
if ((from != null) && (password == null)) {
    throw new IllegalArgumentException("If from is not null, password must not be null");
}

È più leggibile ed è molto più facile da capire, e richiede solo una piccola digitazione extra.

Bene, sembra che tu stia cercando di verificare se la condizione di "nullità" dei due è la stessa o no. Puoi usare:

if ((from == null) != (password == null))
{
    ...
}

O rendilo più esplicito con le variabili helper:

boolean gotFrom = from != null;
boolean gotPassword = password != null;
if (gotFrom != gotPassword)
{
    ...
}

Personalmente, preferisco leggere ad elegante.

if (from != null && password == null) {
    throw new RuntimeException("-from given without -password");
}
if (from == null && password != null) {
    throw new RuntimeException("-password given without -from");
}

Inserisci quella funzionalità in un metodo a 2 argomenti con la firma:

void assertBothNullOrBothNotNull(Object a, Object b) throws RuntimeException

Ciò consente di risparmiare spazio nel metodo effettivo che ti interessa e lo rende più leggibile. Non c'è niente di sbagliato nei nomi dei metodi leggermente dettagliati e non c'è niente di sbagliato nei metodi molto brevi.

Una soluzione Java 8 sarebbe da utilizzare Objects.isNull(Object), ipotizzando un'importazione statica:

if (isNull(from) != isNull(password)) {
    throw ...;
}

Per Java <8 (o se non ti piace usare Objects.isNull()), puoi facilmente scrivere il tuo isNull()metodo.

Ecco una soluzione generale per qualsiasi numero di controlli null

public static int nulls(Object... objs)
{
    int n = 0;
    for(Object obj : objs) if(obj == null) n++;
    return n;
}

public static void main (String[] args) throws java.lang.Exception
{
    String a = null;
    String b = "";
    String c = "Test";

    System.out.println (" "+nulls(a,b,c));
}

usi

// equivalent to (a==null & !(b==null|c==null) | .. | c==null & !(a==null|b==null))
if (nulls(a,b,c) == 1) { .. }

// equivalent to (a==null | b==null | c==null)
if (nulls(a,b,c) >= 1) { .. }

// equivalent to (a!=null | b!=null | c!=null)
if (nulls(a,b,c) < 3) { .. }

// equivalent to (a==null & b==null & c==null)
if (nulls(a,b,c) == 3) { .. }

// equivalent to (a!=null & b!=null & c!=null)
if (nulls(a,b,c) == 0) { .. }

Dato che vuoi fare qualcosa di speciale (usa i valori predefiniti) quando mancano sia il mittente che la password, gestisci prima quello.
Successivamente, dovresti avere sia un mittente che una password per inviare un'e-mail; genera un'eccezione se manca uno dei due.

// use defaults if neither is provided
if ((from == null) && (password == null)) {
    from = DEFAULT_SENDER;
    password = DEFAULT_PASSWORD;
}

// we should have a sender and a password now
if (from == null) {
    throw new MissingSenderException();
}
if (password == null) {
    throw new MissingPasswordException();
}

Un ulteriore vantaggio è che, nel caso in cui una delle impostazioni predefinite sia nulla, verrà rilevata anche quella.

Detto questo, in generale penso che l'uso di XOR dovrebbe essere consentito quando è l'operatore di cui hai bisogno. Si tratta di una parte del linguaggio, non solo qualche trucco che funziona a causa di un arcana compilatore-bug.
Una volta avevo un cow-orker che trovava l'operatore ternario troppo confuso per usare ...

Vorrei suggerire un'altra alternativa che è come scriverei effettivamente questo pezzo di codice:

if( from != null )
{
    if( password == null )
        error( "password required for " + from );
}
else
{
    if( password != null )
        warn( "the given password will not be used" );
}

Per me questo sembra essere il modo più naturale per esprimere questa condizione che lo rende facile da capire per qualcuno che potrebbe doverlo leggere in futuro. Ti consente anche di fornire messaggi diagnostici più utili e di trattare la password non necessaria come meno seria e semplifica la modifica, il che è piuttosto probabile per tale condizione. Vale a dire che potresti scoprire che fornire una password come argomento della riga di comando non è la migliore idea e potresti voler consentire la lettura della password dall'input standard facoltativamente se l'argomento è mancante. Oppure potresti voler ignorare silenziosamente l'argomento password superflua. Modifiche come queste non richiederebbero di riscrivere il tutto.

Oltre a ciò, esegue solo il numero minimo di confronti, quindi non è più costoso delle alternative più "eleganti" . Anche se le prestazioni sono molto improbabili qui perché l'avvio di un nuovo processo è già molto più costoso di un controllo null aggiuntivo.

Penso che un modo corretto di gestirlo sia quello di considerare tre situazioni: sono fornite sia "da" che "password", nessuna delle due, un mix delle due.

if(from != null && password != null){
    //use the provided values
} else if(from == null && password == null){
    //both values are null use the default values
} else{
   //throw an exception because the input is not correct.
}

Sembra che la domanda originale voglia interrompere il flusso se si tratta di un input errato, ma in seguito dovranno ripetere parte della logica. Forse una buona affermazione potrebbe essere:

throw new IllegalArgumentException("form of " + form + 
    " cannot be used with a "
    + (password==null?"null":"not null") +  
    " password. Either provide a value for both, or no value for both"
);

Ecco un modo relativamente semplice che non comporta alcun Xor og lungo se. Tuttavia, richiede di essere leggermente più dettagliato, ma al lato positivo, è possibile utilizzare le eccezioni personalizzate che ho suggerito per ottenere un messaggio di errore più significativo.

private void validatePasswordExists(Parameters params) {
   if (!params.hasKey("password")){
      throw new PasswordMissingException("Password missing");
   }
}

private void validateFromExists(Parameters params) {
   if (!params.hasKey("from")){
      throw new FromEmailMissingException("From-email missing");
   }
}

private void validateParams(Parameters params) {

  if (params.hasKey("from") || params.hasKey("password")){
     validateFromExists(params);
     validatePasswordExists(params);
  }
}

Nessuno sembra aver menzionato l' operatore ternario :

if (a==null? b!=null:b==null)

Funziona bene per controllare questa particolare condizione, ma non generalizza ben oltre due variabili.

Come vedo le tue intenzioni, non è necessario controllare sempre entrambe le nullità esclusive ma verificare se passwordè nullo se e solo se fromnon è nullo. Puoi ignorare l' passwordargomento dato e usare il tuo default sefrom è null.

Scritto in pseudo deve essere così:

if (from == null) { // form is null, ignore given password here
    // use your own defaults
} else if (password == null) { // form is given but password is not
    // throw exception
} else { // both arguments are given
    // use given arguments
}

Sono sorpreso che nessuno abbia menzionato la semplice soluzione di creazione frome passwordcampi di una classe e passaggio di un riferimento a un'istanza di quella classe:

class Account {
    final String name, password;
    Account(String name, String password) {
        this.name = Objects.requireNonNull(name, "name");
        this.password = Objects.requireNonNull(password, "password");
    }
}

// the code that requires an account
Account from;
// do stuff

Qui from potrebbe essere nullo o non nullo e se è nullo, entrambi i suoi campi hanno valori non nulli.

Un vantaggio di questo approccio è che l'errore di rendere nullo un campo ma non l'altro campo viene attivato nel punto in cui l'account viene inizialmente ottenuto, non quando viene eseguito il codice che utilizza l'account. Quando viene eseguito il codice che utilizza l'account, è impossibile che i dati non siano validi.

Un altro vantaggio di questo approccio è più leggibile in quanto fornisce più informazioni semantiche. Inoltre, è probabile che tu richieda il nome e la password insieme in altri luoghi, quindi il costo della definizione di una classe aggiuntiva si ammortizza su più utilizzi.