检查Java中的两个参数，要么都不为null要么都优雅地为null

我用spring boot开发了一个用于发送电子邮件的shell项目，例如

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

如果缺少from和password参数，则使用默认的发送者和密码，例如noreply@bar.com和123456。

因此，如果用户传递了from参数，他们也必须传递password参数，反之亦然。也就是说，两者都不为空，或者两者都不为空。

如何优雅地检查？

现在我的方式是

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

有一种使用^（XOR）运算符的方法：

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

该if要是只有一个变量是空的条件将是真实的。

但我认为通常最好将两个if条件与不同的异常消息一起使用。您无法使用单个条件定义出了什么问题。

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

它更具可读性，更容易理解，并且只需要一点额外的输入即可。

好吧，听起来您正在尝试检查两者的“无效”条件是否相同。您可以使用：

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

或者使用辅助变量使其更加明确：

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

就个人而言，我更喜欢可读而不是优雅。

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

将该功能放入带有签名的2参数方法中：

void assertBothNullOrBothNotNull(Object a, Object b) throws RuntimeException

这样可以节省您感兴趣的实际方法的空间，并使其更具可读性。稍微冗长的方法名称没有什么问题，而非常简短的方法也没有什么问题。

Java 8解决方案是使用Objects.isNull(Object)，并假设是静态导入：

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

对于Java <8（或者如果您不喜欢使用Objects.isNull()），则可以轻松编写自己的isNull()方法。

这是任意数量的空检查的通用解决方案

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

用途

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

由于您想在没有发送者和密码的情况下做一些特殊的事情（使用默认设置），因此请先进行处理。
在那之后，您应该既有发送者又有密码来发送电子邮件。如果缺少任何一个，则引发异常。

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

另一个好处是，如果您的默认值都为空，则也会检测到。

话虽如此，总的来说，我认为当您需要运算符时，应允许使用XOR。它是语言的一部分，不仅是由于奥秘的编译器错误而起作用的技巧。
我曾经有一个牛-叫者，发现三元运算符太令人困惑了，无法使用...

我想提出另一种选择，那就是我实际上如何编写这段代码：

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

对我来说，这似乎是表达这种状况的最自然的方式，这使将来可能需要阅读的人容易理解。它还允许您提供更有用的诊断消息，并将不必要的密码视为不太严重的密码，并且可以轻松地修改这种情况的可能性。即，您可能会发现，将密码作为命令行参数不是最好的主意，并且如果该参数缺失，则可能希望允许从标准输入中读取密码。或者，您可能想静默地忽略多余的password参数。这样的更改不需要您重写整个过程。

除此之外，它仅执行最少数量的比较，因此它并不比更“优雅”的选择昂贵。尽管性能不太可能出现问题，因为启动新进程已经比额外的空检查昂贵得多。

我认为处理此问题的正确方法是考虑三种情况：既提供了“ from”和“ password”，又未提供，又提供了两者的混合。

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

听起来好像原来的问题想在输入错误的情况下中断流程，但随后他们将不得不重复某些逻辑。一个好的throw语句可能是：

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

这是一种相对简单的方法，不涉及任何Xor或冗长的ifs。但是，它确实需要您稍微冗长一些，但是从好的方面来说，您可以使用我建议的自定义异常来获取更有意义的错误消息。

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

似乎没有人提到三元运算符：

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

对于检查此特定条件非常有效，但不能很好地概括两个变量。

如我所见，您不必总是检查两个排他的password无效性，而仅当from不为null 时才检查是否为null。您可以忽略给定的password参数，如果from为null ，则使用您自己的默认值。

用伪写的必须是这样的：

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
}

我很惊讶，没有人提到制作的简单的解决方案from和password一类的领域和传递引用指向这个类的一个实例：

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

这里 from可以为null或非null，并且如果为非null，则其两个字段都具有非null值。

这种方法的一个优点是，在最初获得该帐户的地方（而不是在使用该帐户的代码运行时），会触发使一个字段为空而不使另一个字段为空的错误。到执行使用该帐户的代码时，数据就不可能无效。

这种方法的另一个优点是可读性更高，因为它提供了更多的语义信息。同样，您可能在其他地方同时要求输入名称和密码，因此定义附加类的成本将因多次使用而摊销。