Verifique dois argumentos em Java, ambos não nulos ou nulos elegantemente

Usei o spring boot para desenvolver um projeto de shell usado para enviar email, por exemplo

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

Se os argumentos frome passwordestiverem ausentes, eu uso um remetente e uma senha padrão, por exemplo, [email protected]e 123456.

Portanto, se o usuário passar o fromargumento, ele também deve passar o passwordargumento e vice-versa. Ou seja, ambos são não nulos ou ambos são nulos.

Como verifico isso com elegância?

Agora meu caminho é

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

Existe uma maneira de usar o operador ^( XOR ):

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

A ifcondição será verdadeira se apenas uma variável for nula.

Mas acho que geralmente é melhor usar duas ifcondições com diferentes mensagens de exceção. Você não pode definir o que deu errado usando uma única condição.

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

É mais legível e muito mais fácil de entender, e leva apenas um pouco de digitação extra.

Bem, parece que você está tentando verificar se a condição de "nulidade" dos dois é a mesma ou não. Você poderia usar:

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

Ou torne mais explícito as variáveis ​​auxiliares:

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

Pessoalmente, prefiro legível a 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");
}

Coloque essa funcionalidade em um método de 2 argumentos com a assinatura:

void assertBothNullOrBothNotNull(Object a, Object b) throws RuntimeException

Isso economiza espaço no método real em que você está interessado e o torna mais legível. Não há nada errado com nomes de métodos ligeiramente detalhados e não há nada errado com métodos muito curtos.

Uma solução Java 8 seria usada Objects.isNull(Object), assumindo uma importação estática:

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

Para Java <8 (ou se você não gosta de usar Objects.isNull()), pode escrever facilmente seu próprio isNull()método.

Aqui está uma solução geral para qualquer número de verificações nulas

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

Usos

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

Como você deseja fazer algo especial (use padrões) quando o remetente e a senha estiverem ausentes, lide com isso primeiro.
Depois disso, você deve ter um remetente e uma senha para enviar um email; lance uma exceção se alguma delas estiver faltando.

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

Um benefício adicional é que, se um de seus padrões for nulo, isso também será detectado.

Dito isto, em geral , acho que o uso do XOR deve ser permitido quando esse é o operador que você precisa. Ele é uma parte da língua, não apenas algum truque que funciona por causa de um arcano compilador de bug.
Certa vez, tive um cow-orker que achou o operador ternário muito confuso para usar ...

Gostaria de sugerir outra alternativa, que é como eu realmente escreveria esse pedaço de código:

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

Para mim, essa parece ser a maneira mais natural de expressar essa condição, o que facilita a compreensão para alguém que possa ter que lê-la no futuro. Ele também permite que você envie mensagens de diagnóstico mais úteis e trate a senha desnecessária como menos grave, além de facilitar a modificação, o que é bastante provável para essa condição. Ou seja, você pode descobrir que fornecer uma senha como argumento da linha de comando não é a melhor ideia e pode permitir a leitura da senha da entrada padrão opcionalmente, se o argumento estiver ausente. Ou você pode ignorar silenciosamente o argumento da senha supérflua. Alterações como essas não exigiriam que você reescrevesse tudo.

Além disso, ele executa apenas o número mínimo de comparações, portanto, não é mais caro que as alternativas mais "elegantes" . Embora o desempenho seja muito improvável aqui, porque iniciar um novo processo já é muito mais caro do que uma verificação nula extra.

Eu acho que uma maneira correta de lidar com isso é considerar três situações: 'from' e 'password' são fornecidas, nem são fornecidas, uma mistura das duas é fornecida.

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

Parece que a pergunta original quer interromper o fluxo se for uma entrada incorreta, mas eles terão que repetir parte da lógica posteriormente. Talvez uma boa declaração de lançamento seja:

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

Aqui está uma maneira relativamente direta que não envolve Xs e longos ifs. No entanto, exige que você seja um pouco mais detalhado, mas, de cabeça para baixo, você pode usar as exceções personalizadas que sugeri para obter uma mensagem de erro mais significativa.

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

Ninguém parece ter mencionado o operador ternário :

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

Funciona bem para verificar essa condição específica, mas não generaliza bem as duas variáveis ​​passadas.

Pelo que vejo suas intenções, não há necessidade de sempre verificar ambas as nulidades exclusivas, mas verificar se passwordé nulo se e somente se fromnão for nulo. Você pode ignorar o passwordargumento fornecido e usar seu próprio padrão se fromfor nulo.

Escrito em pseudo deve ser assim:

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
}

Estou surpreso que ninguém tenha mencionado a solução simples de fazer frome passwordcampos de uma classe e passar uma referência a uma instância dessa 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

Aqui frompode ser nulo ou não nulo e, se não for nulo, os dois campos terão valores não nulos.

Uma vantagem dessa abordagem é que o erro de tornar um campo, mas não o outro, nulo é acionado onde a conta é obtida inicialmente, não quando o código que a utiliza é executado. Quando o código que usa a conta é executado, é impossível que os dados sejam inválidos.

Outra vantagem dessa abordagem é mais legível, pois fornece mais informações semânticas. Além disso, é provável que você exija o nome e a senha juntos em outros lugares, para que o custo da definição de uma classe adicional seja amortizado por vários usos.