Vérifier deux arguments en Java, soit les deux ne sont pas nuls, soit les deux sont nuls, de manière élégante.

Question

J'ai utilisé spring boot pour développer un projet shell utilisé pour envoyer des emails, par exemple.

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

Si le from y password sont manquants, j'utilise un expéditeur et un mot de passe par défaut, par ex. noreply@bar.com y 123456 .

Ainsi, si l'utilisateur passe le test from ils doivent également passer l'argument password et vice versa. En d'autres termes, soit les deux sont non nuls, soit les deux sont nuls.

Comment puis-je vérifier cela de manière élégante ?

Maintenant, mon chemin est

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

Answer 1

Il existe un moyen d'utiliser le ^ ( XOR ) :

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

El if La condition sera vraie si une seule variable est nulle.

Mais je pense qu'en général, il est préférable d'utiliser deux if 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 plus de frappe.

Answer 2

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

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

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

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

Answer 3

Personnellement, je préfère "lisible" à "é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");
}

Answer 4

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

void assertBothNullOrBothNotNull(Object a, Object b) throws RuntimeException

Cela permet de gagner de la place dans la méthode qui vous intéresse et de la rendre plus lisible. Il n'y a rien de mal à avoir des noms de méthodes légèrement verbeux et il n'y a rien de mal à avoir des méthodes très courtes.

Answer 5

Une solution Java 8 serait d'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 la fonction Objects.isNull() ), vous pouvez facilement écrire votre propre isNull() méthode.