检查“get”链要求为空

Question

假设我想执行以下命令：

house.getFloor(0).getWall(WEST).getDoor().getDoorknob();

为了避免 NullPointerException，我必须执行以下操作：

if (house != null && house.getFloor(0) && house.getFloor(0).getWall(WEST) != null
  && house.getFloor(0).getWall(WEST).getDoor() != null) ...

是否有一种方法或现有的 Utils 类可以更优雅地执行此操作，让我们说类似以下内容？

checkForNull(house.getFloor(0).getWall(WEST).getDoor().getDoorknob());

Answer 1

如果您无法避免违反所选答案中所述的德墨忒尔定律 (LoD)，并且Java 8 介绍 可选，这可能是处理像您这样的获取链中的空值的最佳实践。

Optional 类型将使您能够连续传输多个映射操作（其中包含 get 调用）。空检查会在后台自动处理。

例如，当对象未初始化时，不会执行 print() 操作，也不会抛出任何异常。这一切我们都可以在幕后温和地处理。当对象初始化时，将进行打印。

System.out.println("----- Not Initialized! -----");

Optional.ofNullable(new Outer())
        .map(out -> out.getNested())
        .map(nest -> nest.getInner())
        .map(in -> in.getFoo())
        .ifPresent(foo -> System.out.println("foo: " + foo)); //no print

System.out.println("----- Let's Initialize! -----");

Optional.ofNullable(new OuterInit())
        .map(out -> out.getNestedInit())
        .map(nest -> nest.getInnerInit())
        .map(in -> in.getFoo())
        .ifPresent(foo -> System.out.println("foo: " + foo)); //will print!

class Outer {
    Nested nested;
    Nested getNested() {
        return nested;
    }
}
class Nested {
    Inner inner;
    Inner getInner() {
        return inner;
    }
}
class Inner {
    String foo = "yeah!";
    String getFoo() {
        return foo;
    }
}

class OuterInit {
    NestedInit nested = new NestedInit();
    NestedInit getNestedInit() {
        return nested;
    }
}
class NestedInit {
    InnerInit inner = new InnerInit();
    InnerInit getInnerInit() {
        return inner;
    }
}
class InnerInit {
    String foo = "yeah!";
    String getFoo() {
        return foo;
    }
}

因此，使用您的 getters 链，它将如下所示：

Optional.ofNullable(house)
        .map(house -> house.getFloor(0))
        .map(floorZero -> floorZero.getWall(WEST))
        .map(wallWest -> wallWest.getDoor())
        .map(door -> wallWest.getDoor())

它的返回将类似于 Optional ，这将使您的工作更加安全，而不必担心 null 异常。

Answer 2

为了检查获取链是否为 null，您可能需要从闭包调用代码。闭包调用代码将如下所示：

public static <T> T opt(Supplier<T> statement) {       
    try {
        return statement.get();
    } catch (NullPointerException exc) {
        return null;
    }   
}

您可以使用以下语法调用它：

Doorknob knob = opt(() -> house.getFloor(0).getWall(WEST).getDoor().getDoorknob());

该代码也是类型安全的，并且通常按预期工作：

1. 如果链中的所有对象都不 空。
2. 如果链中的任何对象为 null，则返回 null。

您可以将 opt 方法放入共享 util 类中，并在应用程序中的任何地方使用它。

Answer 3

最好的方法是避免链条。如果您不熟悉迪米特定律 (LoD)，我认为您应该熟悉。您给出了一个完美的消息链示例，该消息链与类过于密切，它没有必要了解任何内容。

德墨忒尔定律：http://en.wikipedia.org/wiki/Law_of_Demeter

Answer 4

当然，您可以简单地将整个表达式包装在 try-catch 块中，但这是一个坏主意。更简洁的是空对象模式。这样，如果你的房子没有 0 层，它只会返回一个像普通楼层一样的楼层，但没有实际内容；当楼层被要求提供它们没有的墙时，会返回类似的“空”墙等。

Answer 5

确保逻辑上不能为 null 的内容并非如此。例如 - 房子总是有一面西墙。为了避免状态中出现此类异常，您可以使用方法来检查您期望的状态是否存在：

if (wall.hasDoor()) {
   wall.getDoor().etc();
}

这本质上是空检查，但可能并不总是如此。

重点是，如果您有 null，您应该采取一些措施。例如 - return 或抛出 IllegalStateException

而你不应该做的 - 不要捕获 NullPointerException。运行时异常不适合捕获 - 不希望您能够从中恢复，依赖逻辑流的异常也不是一个好的实践。想象一下，您实际上并不希望某些内容为 null，并且您捕获（并记录）一个 NullPointerException。这不会是非常有用的信息，因为此时很多东西都可能为 null。

Answer 6

对我来说更好的解决方案是使用 java.util.Optional.map(..) 链接这些检查： https://stackoverflow.com /a/67216752/1796826

Answer 7

您无法编写任何 checkForNull 方法来实现此目的（这根本不是 Java 中方法调用和参数求值的工作方式）。

您可以将链接语句分解为多个语句，并在每一步进行检查。然而，也许更好的解决方案是首先不让这些方法返回 null。您可能想使用一种名为 空对象模式 的东西。

相关问题

• 如何避免 Java 中的 != null 语句？

Answer 8

您可能有一个如下所示的通用方法：

public static <T> void ifPresentThen(final Supplier<T> supplier, final Consumer<T> consumer) {
    T value;
    try {
        value = supplier.get();
    } catch (NullPointerException e) {
        // Don't consume "then"
        return;
    }
    consumer.accept(value);
}

所以现在您可以这样做

ifPresentThen(
    () -> house.getFloor(0).getWall(WEST).getDoor().getDoorknob(),
    doorKnob -> doSomething());

Answer 9

使用供应商实现 nullPointer try/catch，您可以将所有 get 链发送给它

public static <T> T getValue(Supplier<T> getFunction, T defaultValue) {
    try {
        return getFunction.get();
    } catch (NullPointerException ex) {
        return defaultValue;
    }
}

，然后以这种方式调用它。

ObjectHelper.getValue(() -> object1.getObject2().getObject3().getObject4()));

Answer 10

// Example
LazyObject.from(curr).apply(A.class, A::getB).apply(B.class, B::getC).apply(C.class, C::getD).to(String.class);

// LazyObject.java
public class LazyObject {

private Object value;

private LazyObject(Object object) {
    this.value = object;
}

public <F, T> LazyObject apply(Class<F> type, Function<F, T> func) {
    Object v = value;
    if (type.isInstance(v)) {
        value = func.apply(type.cast(v));
    } else {
        value = null; // dead here
    }
    return this;
}

public <T> void accept(Class<T> type, Consumer<T> consumer) {
    Object v = value;
    if (type.isInstance(v)) {
        consumer.accept(type.cast(v));
    }
}

public <T> T to(Class<T> type) {
    Object v = value;
    if (type.isInstance(v)) {
        return type.cast(v);
    }
    return null;
}

public static LazyObject from(Object object) {
    return new LazyObject(object);
}

}

Answer 11

非常老的问题，但仍然添加我的建议：

我建议不要在一个方法调用链中从房子深处获取 DoorKnob，您应该尝试让 DoorKnob 从调用代码提供给此类，或者通过创建一个专门用于此目的的中央查找设施（例如 DoorKnob 服务）

松散耦合设计的简化示例：

class Architect {

    FloorContractor floorContractor;

    void build(House house) {
        for(Floor floor: house.getFloors()) {
            floorContractor.build(floor);
        }
    }    
}

class FloorContractor {

    DoorMaker doorMaker;

    void build(Floor floor) {
        for(Wall wall: floor.getWalls()) {
            if (wall.hasDoor()) {
                doorMaker.build(wall.getDoor());
            }
        }
    } 
}

class DoorMaker {

    Tool tool;

    void build(Door door) {
        tool.build(door.getFrame());
        tool.build(door.getHinges());
        tool.build(door.getDoorKnob());
    }        
}