Überprüfen Sie zwei Argumente in Java, entweder beide nicht null oder beide elegant null

Ich habe Spring Boot verwendet, um ein Shell-Projekt zu entwickeln, mit dem E-Mails gesendet werden, z

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

Wenn die Argumente fromund passwordfehlen, verwende ich einen Standardabsender und ein Standardkennwort, z . B. noreply@bar.comund 123456.

Wenn der Benutzer das fromArgument übergibt , muss er auch das passwordArgument übergeben und umgekehrt. Das heißt, entweder sind beide nicht null oder beide sind null.

Wie überprüfe ich das elegant?

Jetzt ist mein Weg

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

Es gibt eine Möglichkeit, den Operator ^( XOR ) zu verwenden:

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

Die ifBedingung ist wahr, wenn nur eine Variable null ist.

Aber ich denke, normalerweise ist es besser, zwei ifBedingungen mit unterschiedlichen Ausnahmemeldungen zu verwenden. Sie können nicht mit einer einzigen Bedingung definieren, was schief gelaufen ist.

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

Es ist besser lesbar und viel einfacher zu verstehen, und es erfordert nur ein wenig zusätzliche Eingabe.

Nun, es hört sich so an, als würden Sie versuchen zu überprüfen, ob die "Null" -Zustand der beiden gleich ist oder nicht. Du könntest benutzen:

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

Oder machen Sie es mit Hilfsvariablen expliziter:

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

Ich persönlich bevorzuge lesbar gegenüber elegant.

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

Fügen Sie diese Funktionalität in eine 2-Argument-Methode mit der Signatur ein:

void assertBothNullOrBothNotNull(Object a, Object b) throws RuntimeException

Dies spart Platz in der eigentlichen Methode, an der Sie interessiert sind, und macht sie lesbarer. An leicht ausführlichen Methodennamen ist nichts auszusetzen, und an sehr kurzen Methoden ist nichts auszusetzen.

Unter der Objects.isNull(Object)Annahme eines statischen Imports wäre eine Java 8-Lösung zu verwenden :

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

Für Java <8 (oder wenn Sie es nicht mögen Objects.isNull()) können Sie einfach Ihre eigene isNull()Methode schreiben .

Hier ist eine allgemeine Lösung für eine beliebige Anzahl von Nullprüfungen

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));
}

Verwendet

// 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) { .. }

Da Sie etwas Besonderes tun möchten (Standardeinstellungen verwenden), wenn sowohl Absender als auch Kennwort fehlen, behandeln Sie dies zuerst.
Danach sollten Sie sowohl einen Absender als auch ein Passwort haben, um eine E-Mail zu senden. eine Ausnahme auslösen, wenn eine fehlt.

// 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();
}

Ein zusätzlicher Vorteil ist, dass, sollte einer Ihrer Standardeinstellungen null sein, dies ebenfalls erkannt wird.

Trotzdem denke ich im Allgemeinen , dass die Verwendung von XOR zulässig sein sollte, wenn dies der Operator ist, den Sie benötigen. Es ist ein Teil der Sprache, nicht nur ein Trick, der aufgrund eines arkanen Compiler-Fehlers funktioniert.
Ich hatte einmal einen Kuh-Orker, der den ternären Operator zu verwirrend fand, um ihn zu benutzen ...

Ich möchte eine andere Alternative vorschlagen, wie ich diesen Code tatsächlich schreiben würde:

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

Für mich scheint dies der natürlichste Weg zu sein, diesen Zustand auszudrücken, der es für jemanden, der ihn in Zukunft möglicherweise lesen muss, leicht verständlich macht. Außerdem können Sie hilfreichere Diagnosemeldungen geben und das unnötige Kennwort als weniger schwerwiegend behandeln, und es ist einfach zu ändern, was für einen solchen Zustand eher wahrscheinlich ist. Das heißt, Sie stellen möglicherweise fest, dass die Angabe eines Kennworts als Befehlszeilenargument nicht die beste Idee ist, und möchten möglicherweise das Lesen des Kennworts aus der Standardeingabe optional zulassen, wenn das Argument fehlt. Oder Sie möchten das überflüssige Kennwortargument stillschweigend ignorieren. Änderungen wie diese würden nicht erfordern, dass Sie das Ganze neu schreiben.

Außerdem werden nur die Mindestanzahl von Vergleichen ausgeführt, sodass es nicht teurer ist als die "eleganteren" Alternativen. Obwohl die Leistung hier sehr unwahrscheinlich ist, ist das Starten eines neuen Prozesses bereits viel teurer als eine zusätzliche Nullprüfung.

Ich denke, ein korrekter Weg, um damit umzugehen, besteht darin, drei Situationen zu betrachten: Sowohl 'von' als auch 'Passwort' werden bereitgestellt, keine werden bereitgestellt, eine Mischung aus beiden wird bereitgestellt.

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.
}

Es hört sich so an, als ob die ursprüngliche Frage den Fluss unterbrechen möchte, wenn es sich um eine falsche Eingabe handelt, aber dann müssen sie später einen Teil der Logik wiederholen. Vielleicht könnte eine gute Wurfaussage sein:

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"
);

Hier ist ein relativ unkomplizierter Weg, bei dem kein Xor oder langwieriges Wenn erforderlich ist. Es erfordert jedoch, dass Sie etwas ausführlicher sind, aber auf der anderen Seite können Sie die von mir vorgeschlagenen benutzerdefinierten Ausnahmen verwenden, um eine aussagekräftigere Fehlermeldung zu erhalten.

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);
  }
}

Niemand scheint den ternären Operator erwähnt zu haben :

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

Funktioniert gut zum Überprüfen dieser bestimmten Bedingung, verallgemeinert sich jedoch nicht weit über zwei Variablen hinaus.

Wie ich Ihre Absichten sehe, besteht nicht die Notwendigkeit, immer beide exklusiven Nullen zu überprüfen, sondern zu prüfen, ob passwordgenau dann null ist, wenn fromnicht null ist. Sie können das angegebene passwordArgument ignorieren und Ihren eigenen Standard verwenden, wennfrom null ist.

In Pseudo geschrieben muss so sein:

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
}

Ich bin überrascht, dass niemand die einfache Lösung erwähnt hat, eine Klasse zu erstellen fromund passwordFelder zu erstellen und einen Verweis auf eine Instanz dieser Klasse zu übergeben:

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

Hier from kann null oder nicht null sein, und wenn es nicht null ist, haben beide Felder nicht null Werte.

Ein Vorteil dieses Ansatzes besteht darin, dass der Fehler, ein Feld, aber nicht das andere Feld auf Null zu setzen, dort ausgelöst wird, wo das Konto ursprünglich abgerufen wurde, und nicht, wenn der Code, der das Konto verwendet, ausgeführt wird. Zum Zeitpunkt der Ausführung des Codes, der das Konto verwendet, ist es unmöglich, dass die Daten ungültig sind.

Ein weiterer Vorteil dieses Ansatzes ist besser lesbar, da er mehr semantische Informationen liefert. Es ist auch wahrscheinlich, dass Sie den Namen und das Kennwort an anderen Stellen zusammen benötigen, sodass sich die Kosten für die Definition einer zusätzlichen Klasse über mehrere Verwendungen amortisieren.