发布于 由admin

Java 22无名模式匹配在Jackson反序列化JSON空对象时NPE？JsonAnySetter与NullPatternTypeExtractor

Java 22 无名模式匹配与 Jackson 反序列化空对象：JsonAnySetter 与 NullPatternTypeExtractor 的深度剖析

大家好，今天我们来深入探讨一个在 Java 22 中使用无名模式匹配时可能遇到的一个棘手问题，特别是在结合 Jackson 库进行 JSON 反序列化，并且涉及到空对象、JsonAnySetter 注解以及自定义的类型提取器时，可能会出现的空指针异常（NPE）。 我们将深入研究问题的根本原因，并提供多种解决方案，配合代码示例，确保你能够彻底理解并避免此类问题。

问题的背景：Java 22 无名模式匹配与 Jackson

Java 22 引入的无名模式匹配极大地简化了代码，尤其是在处理类型判断和类型转换的场景下。 例如：

Object obj = getObject(); // 假设 getObject() 返回一个 Object
if (obj instanceof String s) {
  System.out.println("It's a string: " + s);
} else if (obj instanceof Integer i) {
  System.out.println("It's an integer: " + i);
} else {
  System.out.println("It's something else.");
}

这段代码在 Java 22 中可以使用无名模式匹配简化为：

Object obj = getObject();
if (obj instanceof String _) {
  System.out.println("It's a string.");
} else if (obj instanceof Integer _) {
  System.out.println("It's an integer.");
} else {
  System.out.println("It's something else.");
}

虽然 _ 本身没有提供变量绑定，但其依然起到了类型匹配的作用。然而，当我们将这种简洁性与 Jackson 的反序列化机制结合使用，特别是涉及到 JsonAnySetter 和自定义类型提取器时，一些意想不到的问题可能会出现。

Jackson 是一个流行的 Java JSON 处理库，它允许我们将 JSON 数据映射到 Java 对象，或者将 Java 对象序列化为 JSON 数据。 JsonAnySetter 注解提供了一种灵活的方式来处理 JSON 数据中未映射到 Java 类属性的字段。

问题重现：NPE 的产生

现在，让我们来构建一个具体的例子来重现这个问题。 假设我们有以下 Java 类：

import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class MyClass {

    private String name;
    private Map<String, Object> otherProperties = new HashMap<>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @JsonAnySetter
    public void addOtherProperties(String key, Object value) {
        this.otherProperties.put(key, value);
    }

    public Map<String, Object> getOtherProperties() {
        return otherProperties;
    }

    public void setOtherProperties(Map<String, Object> otherProperties) {
        this.otherProperties = otherProperties;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "name='" + name + ''' +
                ", otherProperties=" + otherProperties +
                '}';
    }

    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        String json = "{"name":"Example","extraField":null}"; //extraField 字段为 null
        MyClass myClass = objectMapper.readValue(json, MyClass.class);
        System.out.println(myClass);
    }
}

在这个例子中，MyClass 有一个 name 属性和一个 otherProperties 映射，用于存储 JSON 中未映射到 name 的其他字段。 addOtherProperties 方法使用 @JsonAnySetter 注解，用于将未知的 JSON 字段添加到 otherProperties 映射中。

问题就出现在当 JSON 中包含 null 值，并且我们尝试使用无名模式匹配进行类型提取时。 假设 extraField 的值为 null，Jackson 会将 null 值传递给 addOtherProperties 方法。 如果我们想在 addOtherProperties 中对 value 进行类型判断，可能会使用如下代码：

@JsonAnySetter
public void addOtherProperties(String key, Object value) {
    if (value instanceof String s) {
        otherProperties.put(key, s);
    } else if (value instanceof Integer i) {
        otherProperties.put(key, i);
    } else {
        otherProperties.put(key, value);
    }
}

在 Java 22 中，这可以简化为：

@JsonAnySetter
public void addOtherProperties(String key, Object value) {
    if (value instanceof String _) {
        otherProperties.put(key, (String) value); // 需要强制类型转换
    } else if (value instanceof Integer _) {
        otherProperties.put(key, (Integer) value); // 需要强制类型转换
    } else {
        otherProperties.put(key, value);
    }
}

但是，关键点是，当 value 为 null 时， value instanceof String _ 和 value instanceof Integer _ 的结果都为 false。因此，代码会进入 else 分支，并将 null 值放入 otherProperties 映射中，这通常不会导致直接的 NPE。 真正的问题是，如果你在之后访问 otherProperties 映射中的 null 值，并且尝试对其进行操作，例如调用 toString() 方法，那么就会抛出 NPE。

现在，让我们考虑一个更复杂的情况，我们引入一个自定义的类型提取器，例如 NullPatternTypeExtractor。 这个提取器的目的是为了更精确地处理 null 值，并根据其预期的类型进行处理。

NullPatternTypeExtractor 的引入

假设我们有以下代码：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class MyClass {

    private String name;
    private Map<String, Object> otherProperties = new HashMap<>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @JsonAnySetter
    public void addOtherProperties(String key, Object value) {
        Object convertedValue = NullPatternTypeExtractor.extract(value);
        this.otherProperties.put(key, convertedValue);
    }

    public Map<String, Object> getOtherProperties() {
        return otherProperties;
    }

    public void setOtherProperties(Map<String, Object> otherProperties) {
        this.otherProperties = otherProperties;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "name='" + name + ''' +
                ", otherProperties=" + otherProperties +
                '}';
    }

    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        String json = "{"name":"Example","extraField":null}"; //extraField 字段为 null
        MyClass myClass = objectMapper.readValue(json, MyClass.class);
        System.out.println(myClass);
    }
}

// 假设的 NullPatternTypeExtractor
class NullPatternTypeExtractor {
    public static Object extract(Object value) {
        if (value == null) {
            return null; // 或者根据预期类型返回默认值，例如 "" 或 0
        }
        return value;
    }
}

在这个例子中，NullPatternTypeExtractor.extract(value) 的作用是对 value 进行处理。 即使 NullPatternTypeExtractor.extract(value) 直接返回 null，问题仍然存在，因为 otherProperties 映射中仍然会包含 null 值。

但是，如果 NullPatternTypeExtractor 使用了错误的无名模式匹配，就可能导致 NPE。 例如，考虑以下 NullPatternTypeExtractor 的实现：

class NullPatternTypeExtractor {
    public static Object extract(Object value) {
        if (value instanceof String _) {
            return (String) value;
        } else if (value instanceof Integer _) {
            return (Integer) value;
        } else {
            return null; // 错误：假设所有其他类型都应该为 null
        }
    }
}

在这种情况下，如果 value 本身是 null，那么 value instanceof String _ 和 value instanceof Integer _ 都会返回 false，因此代码会进入 else 分支，返回 null。 但是，如果 JSON 中的 extraField 预期是一个字符串或整数，并且你之后尝试访问 otherProperties.get("extraField") 并将其强制转换为字符串或整数，那么就会抛出 NPE。

解决方案：避免 NPE 的策略

为了避免上述 NPE 问题，我们可以采取以下几种策略：

  1. 在 JsonAnySetter 中显式处理 null 值:

    最简单的方法是在 addOtherProperties 方法中显式检查 value 是否为 null，并采取相应的措施。 例如，我们可以忽略 null 值，或者将其转换为默认值。

    @JsonAnySetter
public void addOtherProperties(String key, Object value) {
   if (value == null) {
       // 忽略 null 值
       // 或者，设置为默认值：
       // otherProperties.put(key, "");
       return;
   }
   otherProperties.put(key, value);
}

  2. 使用 Optional 类型:

    可以使用 Optional 类型来包装 value，从而更安全地处理 null 值。

    import java.util.Optional;

@JsonAnySetter
public void addOtherProperties(String key, Object value) {
   Optional<Object> optionalValue = Optional.ofNullable(value);
   optionalValue.ifPresent(v -> otherProperties.put(key, v));
}

  3. 自定义反序列化器:

    可以创建一个自定义的反序列化器来处理特定的 null 值。 这种方法更加灵活，但需要更多的代码。

    import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.NullNode;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class MyClassDeserializer extends JsonDeserializer<MyClass> {
   @Override
   public MyClass deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
       JsonNode node = p.getCodec().readTree(p);
       MyClass myClass = new MyClass();
       if (node.has("name")) {
           myClass.setName(node.get("name").asText());
       }

       Map<String, Object> otherProperties = new HashMap<>();
       node.fields().forEachRemaining(entry -> {
           String key = entry.getKey();
           if (!key.equals("name")) {
               JsonNode valueNode = entry.getValue();
               if (valueNode instanceof NullNode) {
                   // 处理 null 值
                   otherProperties.put(key, ""); // 例如，设置为默认值
               } else {
                   otherProperties.put(key, p.getCodec().treeToValue(valueNode, Object.class));
               }
           }
       });
       myClass.setOtherProperties(otherProperties);

       return myClass;
   }
}

    然后，将自定义的反序列化器应用于 MyClass：

    import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

@JsonDeserialize(using = MyClassDeserializer.class)
public class MyClass {
   // ... (其他代码)
}

  4. 修改 NullPatternTypeExtractor 的实现:

    如果使用 NullPatternTypeExtractor，请确保其正确处理 null 值，并且不会错误地假设所有其他类型都应该为 null。

    class NullPatternTypeExtractor {
   public static Object extract(Object value) {
       if (value == null) {
           return null; // 正确处理 null 值
       } else if (value instanceof String _) {
           return (String) value;
       } else if (value instanceof Integer _) {
           return (Integer) value;
       } else {
           return value; // 返回原始值，而不是假设为 null
       }
   }
}

  5. 使用 Jackson 的 DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES 特性

    这个特性可以让 Jackson 在遇到基本类型（如 int, boolean）的 null 值时抛出异常。 这样可以提前发现问题，而不是在之后访问 null 值时才抛出 NPE。

    ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true);

  6. 使用 Jackson 的 NON_NULL 序列化/反序列化选项:

    可以配置 Jackson 在序列化和反序列化时忽略 null 值。 这样可以避免 null 值被写入 JSON 数据，或者从 JSON 数据中读取。

    ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); // 忽略序列化时的 null 值

  7. 在访问 otherProperties 中的值之前进行 null 检查:

    无论采取哪种策略，最重要的是在访问 otherProperties 映射中的值之前始终进行 null 检查。

    Object extraFieldValue = myClass.getOtherProperties().get("extraField");
if (extraFieldValue != null) {
   // 安全地使用 extraFieldValue
   System.out.println(extraFieldValue.toString());
} else {
   // 处理 null 值的情况
   System.out.println("extraField is null");
}

代码示例：最佳实践

以下是一个结合了多种策略的示例，展示了如何避免 NPE：

import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class MyClass {

    private String name;
    private Map<String, Object> otherProperties = new HashMap<>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @JsonAnySetter
    public void addOtherProperties(String key, Object value) {
        Optional.ofNullable(value).ifPresent(v -> {
            // 可以在此处进行类型转换或默认值设置
            if (v instanceof String _) {
                otherProperties.put(key, (String) v);
            } else if (v instanceof Integer _) {
                otherProperties.put(key, (Integer) v);
            } else {
                otherProperties.put(key, v);
            }
        });
    }

    public Map<String, Object> getOtherProperties() {
        return otherProperties;
    }

    public void setOtherProperties(Map<String, Object> otherProperties) {
        this.otherProperties = otherProperties;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "name='" + name + ''' +
                ", otherProperties=" + otherProperties +
                '}';
    }

    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        // 配置 Jackson
        objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        String json = "{"name":"Example","extraField":null}"; //extraField 字段为 null
        MyClass myClass = objectMapper.readValue(json, MyClass.class);

        // 安全地访问 otherProperties 中的值
        Object extraFieldValue = myClass.getOtherProperties().get("extraField");
        if (extraFieldValue != null) {
            System.out.println("extraField value: " + extraFieldValue);
        } else {
            System.out.println("extraField is null");
        }

        System.out.println(myClass);
    }
}

表格总结：解决方案对比

解决方案 优点 缺点 适用场景
在 JsonAnySetter 中显式处理 null 值 简单易懂，无需额外依赖 代码冗余，需要为每个 JsonAnySetter 方法添加 null 检查 适用于简单的 null 值处理场景，例如忽略 null 值或设置为默认值
使用 Optional 类型 更安全地处理 null 值，避免 NPE 代码略微复杂，需要了解 Optional 的用法 适用于需要更安全地处理 null 值的场景
自定义反序列化器 灵活，可以处理复杂的 null 值场景 代码量大，需要深入了解 Jackson 的反序列化机制 适用于需要高度定制的反序列化场景，例如需要根据不同的字段类型进行不同的 null 值处理
修改 NullPatternTypeExtractor 的实现 可以集中处理 null 值，避免代码重复 需要确保 NullPatternTypeExtractor 的实现正确，否则可能导致其他问题 适用于需要统一处理 null 值的场景
使用 DeserializationFeature 特性 可以在反序列化时检测到 null 值，提前发现问题 只能检测基本类型的 null 值，无法处理对象类型的 null 值 适用于需要快速检测基本类型的 null 值的场景
使用 NON_NULL 序列化/反序列化选项 可以避免 null 值被写入 JSON 数据或从 JSON 数据中读取 可能会丢失一些信息，需要根据实际情况进行选择 适用于不需要处理 null 值的场景
在访问 otherProperties 中的值之前进行 null 检查 最后的安全屏障，确保不会因为访问 null 值而抛出 NPE 代码冗余，需要在每个访问 otherProperties 的地方添加 null 检查 适用于任何场景，作为最后的安全保障

实际项目中的考量

在实际项目中，选择哪种解决方案取决于具体的业务需求和代码风格。 如果只是简单的忽略 null 值，那么在 JsonAnySetter 中显式处理 null 值就足够了。 如果需要更安全地处理 null 值，可以使用 Optional 类型。 如果需要处理复杂的 null 值场景，可以创建自定义的反序列化器。 无论选择哪种方案，最重要的是要保持代码的清晰和可维护性。

总结与启示

通过本文的讨论，我们深入了解了 Java 22 无名模式匹配与 Jackson 反序列化空对象时可能出现的 NPE 问题，以及如何利用 JsonAnySetter 和自定义类型提取器来解决这些问题。 问题的关键在于理解 null 值的处理方式，以及如何避免在访问 null 值时抛出 NPE。

记住，谨慎处理 null 值，并选择合适的解决方案，可以编写出更加健壮和可靠的代码。 希望本文能够帮助你更好地理解和解决此类问题，并在实际项目中编写出更加高质量的代码。

进一步的思考

除了上述解决方案，还可以考虑使用静态分析工具来检测潜在的 NPE 问题。 此外，编写单元测试也是必不可少的，可以帮助我们及早发现和修复问题。 记住，预防胜于治疗，尽早发现问题可以避免在生产环境中出现严重的故障。

保持代码的清晰和可维护性

无论选择哪种解决方案，都要始终牢记保持代码的清晰和可维护性。 编写清晰的代码可以方便其他人理解和维护，而编写可维护的代码可以方便我们自己进行修改和扩展。 记住，代码不仅仅是给机器执行的，更是给人类阅读的。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注