Vérifiez deux arguments en Java, tous deux non nuls ou tous les deux nuls avec élégance

J'ai utilisé Spring Boot pour développer un projet shell utilisé pour envoyer des e-mails, par exemple

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

Si les arguments fromet passwordmanquent, j'utilise un expéditeur et un mot de passe par défaut, par exemple noreply@bar.comet 123456.

Donc, si l'utilisateur transmet l' fromargument, il doit également passer l' passwordargument et vice versa. Autrement dit, soit les deux sont non nuls, soit les deux sont nuls.

Comment puis-je vérifier cela avec élégance?

Maintenant ma voie est

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

Il existe un moyen d'utiliser l' opérateur ^( XOR ):

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

La ifcondition sera vraie si une seule variable est nulle.

Mais je pense qu'en général, il est préférable d'utiliser deux ifconditions avec des messages d'exception différents. Vous ne pouvez pas définir ce qui a mal tourné en utilisant une seule condition.

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

Il est plus lisible et beaucoup plus facile à comprendre, et il suffit d'un peu de frappe supplémentaire.

Eh bien, il semble que vous essayez de vérifier si la condition de «nullité» des deux est la même ou non. Vous pouvez utiliser:

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

Ou rendez-le plus explicite avec des variables d'assistance:

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

Personnellement, je préfère le lisible à l'élégant.

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

Mettez cette fonctionnalité dans une méthode à 2 arguments avec la signature:

void assertBothNullOrBothNotNull(Object a, Object b) throws RuntimeException

Cela économise de l'espace dans la méthode qui vous intéresse et la rend plus lisible. Il n'y a rien de mal avec les noms de méthode légèrement verbeux et il n'y a rien de mal avec les méthodes très courtes.

Une solution Java 8 serait à utiliser Objects.isNull(Object), en supposant une importation statique:

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

Pour Java <8 (ou si vous n'aimez pas utiliser Objects.isNull()), vous pouvez facilement écrire votre propre isNull()méthode.

Voici une solution générale pour n'importe quel nombre de vérifications nulles

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

Les usages

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

Puisque vous voulez faire quelque chose de spécial (utilisez les valeurs par défaut) lorsque l'expéditeur et le mot de passe sont absents, gérez-le d'abord.
Après cela, vous devriez avoir à la fois un expéditeur et un mot de passe pour envoyer un e-mail; lancer une exception si l'un ou l'autre est manquant.

// 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 avantage supplémentaire est que, si l'une de vos valeurs par défaut est nulle, cela sera également détecté.

Cela dit, en général, je pense que l'utilisation de XOR devrait être autorisée lorsque c'est l'opérateur dont vous avez besoin. Il est une partie de la langue, pas seulement un truc qui fonctionne à cause d'un compilateur bug Arcane.
Une fois, j'ai eu un cow-orker qui a trouvé l'opérateur ternaire trop déroutant à utiliser ...

Je voudrais suggérer une autre alternative, comment j'écrirais réellement ce morceau de code:

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

Cela me semble être la manière la plus naturelle d'exprimer cette condition qui la rend facile à comprendre pour quelqu'un qui pourrait avoir à la lire à l'avenir. Cela vous permet également de donner des messages de diagnostic plus utiles et de traiter le mot de passe inutile comme moins sérieux et il est facile de modifier ce qui est plutôt probable pour une telle condition. Par exemple, vous découvrirez peut-être que donner un mot de passe comme argument de ligne de commande n'est pas la meilleure idée et que vous voudrez peut-être autoriser la lecture du mot de passe à partir de l'entrée standard si l'argument est manquant. Ou vous pouvez ignorer silencieusement l'argument de mot de passe superflu. Des changements comme ceux-ci ne vous obligeraient pas à tout réécrire.

De plus, il n'exécute que le nombre minimum de comparaisons, donc ce n'est pas plus cher que les alternatives plus "élégantes" . Bien que les performances soient très peu probables, un problème ici, car le démarrage d'un nouveau processus est déjà beaucoup plus coûteux qu'une vérification de null supplémentaire.

Je pense qu'une manière correcte de gérer cela est de considérer trois situations: à la fois «de» et «mot de passe» sont fournis, aucun n'est fourni, un mélange des deux est fourni.

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

Il semble que la question d'origine veuille interrompre le flux s'il s'agit d'une entrée incorrecte, mais ils devront ensuite répéter une partie de la logique plus tard. Peut-être qu'une bonne déclaration de lancer pourrait être:

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

Voici un moyen relativement simple qui n'implique aucun Xor og long ifs. Cependant, cela vous oblige à être un peu plus détaillé, mais vous pouvez utiliser les exceptions personnalisées que j'ai suggérées pour obtenir un message d'erreur plus significatif.

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

Personne ne semble avoir mentionné l' opérateur ternaire :

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

Fonctionne bien pour vérifier cette condition particulière, mais ne généralise pas bien au-delà de deux variables.

Comme je vois vos intentions, il n'est pas nécessaire de toujours vérifier les deux nullités exclusives mais de vérifier si passwordest nul si et seulement si fromn'est pas nul. Vous pouvez ignorer l' passwordargument donné et utiliser votre propre valeur par défaut si fromest null.

Écrit en pseudo doit être comme ceci:

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
}

Je suis surpris que personne n'ait mentionné la solution simple de créer fromet de passwordchamps d'une classe et de passer une référence à une instance de cette 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

Ici frompeut être nul ou non nul et s'il n'est pas nul, ses deux champs ont des valeurs non nulles.

Un avantage de cette approche est que l'erreur de rendre un champ mais pas l'autre champ nul est déclenchée là où le compte est initialement obtenu, pas lorsque le code utilisant le compte s'exécute. Au moment où le code utilisant le compte est exécuté, il est impossible que les données soient invalides.

Un autre avantage de cette approche est plus lisible car elle fournit plus d'informations sémantiques. En outre, il est probable que vous ayez besoin du nom et du mot de passe ensemble à d'autres endroits, de sorte que le coût de la définition d'une classe supplémentaire s'amortit sur plusieurs utilisations.