Java构造函数风格：检查参数不为空

Question

如果您有一个类接受某些参数但其中任何参数都不允许为 null，那么最佳实践是什么？

下面的内容很明显，但异常有点不具体：

public class SomeClass
{
     public SomeClass(Object one, Object two)
     {
        if (one == null || two == null)
        {
            throw new IllegalArgumentException("Parameters can't be null");
        }
        //...
     }
}

这里的异常让你知道哪个参数为空，但构造函数现在非常丑陋：

public class SomeClass
{
     public SomeClass(Object one, Object two)
     {
        if (one == null)
        {
            throw new IllegalArgumentException("one can't be null");
        }           
        if (two == null)
        {
            throw new IllegalArgumentException("two can't be null");
        }
        //...
  }

这里的构造函数更整洁，但现在构造函数代码实际上并不在构造函数中：

public class SomeClass
{
     public SomeClass(Object one, Object two)
     {
        setOne(one);
        setTwo(two);
     }


     public void setOne(Object one)
     {
        if (one == null)
        {
            throw new IllegalArgumentException("one can't be null");
        }           
        //...
     }

     public void setTwo(Object two)
     {
        if (two == null)
        {
            throw new IllegalArgumentException("two can't be null");
        }
        //...
     }
  }

这些风格中哪一个最好？

还是有更广泛接受的替代方案？

Answer 1

第二个或第三个。

因为它告诉 API 的用户到底出了什么问题。

为了减少冗长，请使用 commons-lang 中的 Validate.notNull(obj, message)。因此，您的构造函数将如下所示：

public SomeClass(Object one, Object two) {
    Validate.notNull(one, "one can't be null");
    Validate.notNull(two, "two can't be null");
    ...
}

将检查放在 setter 中也是可以接受的，具有相同的详细注释。如果您的 setter 还具有保持对象一致性的作用，您也可以选择第三个。

Answer 2

Java 7 将 java.util.Objects.requireNonNull() 添加到每个人都可以使用的 API 中。因此，检查所有参数是否为 null 可以归结为一个简短的列表，例如：

this.arg1 = Objects.requireNonNull(arg1, "arg1 must not be null");
this.arg2 = Objects.requireNonNull(arg2, "arg2 must not be null");

旁注：

• 确保不要颠倒两个参数 - 第二个 是将用于 NPE 的消息，如果第一个参数为空（如果你反转它们，那么你的检查将永远不会失败）
• 另一个最佳实践：如果可能，使所有类成员为最终的（这样你就可以确定：当某个对象已成功创建，其所有成员均不为空；并且它们不会随时间变化）

Answer 3

您可以使用旨在促进前提条件检查的众多库之一。 Google Guava 中的许多代码都使用 com.google.common.base.Preconditions

在您自己的方法开始时调用简单的静态方法，以验证正确的参数和状态。这允许诸如

之类的构造

 if (count <= 0) {
   throw new IllegalArgumentException("必须为正数：" + count);
 }

更换为更紧凑的

 checkArgument(count > 0, "必须为正数：%s", count);

结构它有 checkNotNull 即 在 Guava 中广泛使用。然后你可以这样写：

 import static com.google.common.base.Preconditions.checkNotNull;
 //...

 public SomeClass(Object one, Object two) {
     this.one = checkNotNull(one);
     this.two = checkNotNull(two, "two can't be null!");
     //...
 }

大多数方法都被重载，要么不接受错误消息，要么接受固定的错误消息，要么接受带有可变参数的模板化错误消息。

---

On IllegalArgumentException 与 NullPointerException

虽然原始代码在 null 参数上抛出 IllegalArgumentException，但 Guava 的 Preconditions.checkNotNull< /code> 会抛出 NullPointerException 。

以下是《Effective Java 第二版：第 60 条：支持使用标准异常》的引文：

可以说，所有错误的方法调用都可以归结为非法参数或非法状态，但其他异常通常用于某些非法参数和状态。如果调用者在某些禁止使用 null 值的参数中传递 null，则约定将抛出 NullPointerException 而不是 IllegalArgumentException。

NullPointerException 并不是仅在访问 null 引用的成员时才保留；而是在访问 null 引用的成员时才保留。当参数为非法值时抛出它们是非常标准的。

System.out.println("some string".split(null));
// throws NullPointerException

Answer 4

我会有一个实用方法：

 public static <T> T checkNull(String message, T object) {
     if(object == null) {
       throw new NullPointerException(message);
     }
     return object;
  }

我会让它返回对象，以便您可以在这样的作业中使用它：

 public Constructor(Object param) {
     this.param = checkNull("Param not allowed to be null", param);
 }

编辑：关于使用第三方库的建议，Google 先决条件尤其比我的代码做得更好。但是，如果这是将库包含在项目中的唯一原因，我会犹豫。方法太简单了。

Answer 5

除了上面给出的所有有效且合理的答案之外，我认为最好指出也许检查 null 并不是必要的“良好实践”。 （假设除了 OP 之外的读者可能会认为这个问题是教条的）

来自 Misko Hevery 关于可测试性的博客：
断言或不断言

Answer 6

抛出未经检查的异常的替代方法是使用 assert。否则，我会抛出已检查的异常，以使调用者意识到构造函数无法使用非法值。

前两个解决方案之间的区别 - 您是否需要详细的错误消息，您是否需要知道哪个参数失败，或者是否足以知道由于非法参数而无法创建实例？

请注意，第二个和第三个示例无法正确报告两个参数都为空。

顺便说一句 - 我投票支持 (1) 的变体：

if (one == null || two == null) {
    throw new IllegalArgumentException(
      String.format("Parameters can't be null: one=%s, two=%s", one, two));
}

Answer 7

Java 中检查前提条件的方法比较 - Guava、Apache Commons、Spring Framework、Plain Java 断言，

public static void fooSpringFrameworkAssert(String name, int start, int end) {
        // Preconditions
        Assert.notNull(name, "Name must not be null");
        Assert.isTrue(start < end, "Start (" + start + ") must be smaller than end (" + end + ")");

        // Do something here ...
    }

    public static void fooApacheCommonsValidate(String name, int start, int end) {
        // Preconditions
        Validate.notNull(name, "Name must not be null");
        Validate.isTrue(start < end, "Start (%s) must be smaller than end (%s)", start, end);

        // Do something here ...
    }

    public static void fooGuavaPreconditions(String name, int start, int end) {
        // Preconditions
        Preconditions.checkNotNull(name, "Name must not be null");
        Preconditions.checkArgument(start < end, "Start (%s) must be smaller than end (%s)", start, end);

        // Do something here ...
    }

    public static void fooPlainJavaAsserts(String name, int start, int end) {
        // Preconditions
        assert null != name : "Name must not be null";
        assert start < end : "Start (" + start + ") must be smaller than end (" + end + ")";

        // Do something here ...
    }

这是本文的摘要：
http://www .sw-engineering-candies.com/blog-1/comparison-of-ways-to-check-preconditions-in-java

Answer 8

静态分析的注释也很有用，无论是作为运行时检查的补充还是代替运行时检查。

例如，FindBugs 提供了 @NonNull 注释。

public SomeClass(@NonNull 对象一，@NonNull 对象二) {

Answer 9

您可以简单地使用一个方法来获取需要验证的所有构造函数参数。此方法会引发异常并显示特定消息，具体取决于哪个参数无效。
您的构造函数调用此方法，如果它通过，它将初始化值。

Answer 10

我假设您谈论的是 Java 中内置的 assert。在我看来，使用它并不是一个好主意。因为它可以使用命令行参数打开/关闭。 因此有人说它只能在私有方法中使用。

我的导师告诉我不要重新发明轮子！他们的建议是使用图书馆。它们（可能）经过精心设计和测试。当然，您有责任确保您拥有一个高质量的库。

其他人告诉我，Enterprise ppl - 在某些方面 - 是错误的，对于简单的任务，您引入了比所需更多的依赖性。我也可以接受这一点......但这是我的最新经验：

首先我编写了自己的私有方法来检查空参数。这很无聊而且多余。我知道我应该将它放入实用程序类中。但是既然有人已经这样做了，我为什么要首先写它呢？我可以节省时间而不编写单元测试并设计现有的东西。除非你想锻炼或学习，否则我不建议这样做。

我最近开始使用 google 的 guava，我发现 - 以及 apache commons - 一旦你开始使用它们，你就不会只使用单一方法。您会越来越多地发现并使用它。最后，这将使您的代码更短、更易读、更一致且更易于维护。

顺便说一句：根据您的目标，我会使用上面提到的库之一选择 2 或 3...