RESTful API更新场景中Integer类型字段置空问题的解决方案探讨

这个问题确实挺头疼的，尤其是在做部分更新场景时，Spring MVC默认的请求体映射确实没法区分「字段完全没传」和「字段传了null」这两种情况——毕竟两种情况DTO里的字段值都是null。针对Integer类型的字段，我有几个实用的思路，你可以根据业务场景选：

方案1：用Optional包装字段（简单但有局限） #

把DTO里的Integer字段改成Optional<Integer>类型，利用Optional的状态来区分场景：

public class UpdateDto {
    private String name;
    private Optional<Integer> price; // 用Optional包装Integer字段
}

然后在更新逻辑里判断：

// 更新price字段
if (updateDto.getPrice() != null) {
    // 说明请求里显式传了price字段（不管值是null还是具体数字）
    product.setPrice(updateDto.getPrice().orElse(null));
} else {
    // 说明请求里没传price字段，不更新该字段
}

注意：Spring Boot默认已经配置了Jackson对Optional的反序列化支持。实际测试中，请求体没传price时，DTO的price会是null；如果传了price: null，会被解析成Optional.empty()，刚好能区分两种场景。

方案2：自定义可追踪字段包装类（最灵活） #

如果Optional满足不了需求，或者你想更精准地追踪字段是否被传入，可以自己写一个包装类：

// 自定义包装类，标记字段是否被传入
public class TrackableField<T> {
    private boolean isProvided; // 标记是否传入了该字段
    private T value;

    // 私有构造，用静态方法创建实例
    private TrackableField(boolean isProvided, T value) {
        this.isProvided = isProvided;
        this.value = value;
    }

    // 当字段被传入时调用（不管值是null还是具体值）
    public static <T> TrackableField<T> provided(T value) {
        return new TrackableField<>(true, value);
    }

    // 字段未传入时的默认状态
    public static <T> TrackableField<T> notProvided() {
        return new TrackableField<>(false, null);
    }

    // getter方法
    public boolean isProvided() {
        return isProvided;
    }

    public T getValue() {
        return value;
    }
}

然后在DTO里使用这个包装类，并配合Jackson反序列化器：

public class UpdateDto {
    private String name;
    @JsonDeserialize(using = TrackableFieldDeserializer.class)
    private TrackableField<Integer> price;
}

// 自定义Jackson反序列化器
public class TrackableFieldDeserializer extends JsonDeserializer<TrackableField<?>> {
    @Override
    public TrackableField<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        Object value = p.readValueAs(Object.class);
        return TrackableField.provided(value);
    }
}

更新逻辑就非常清晰了：

// 更新price字段
if (updateDto.getPrice() != null && updateDto.getPrice().isProvided()) {
    // 确认请求传了price字段，直接赋值（包括null）
    product.setPrice((Integer) updateDto.getPrice().getValue());
} else {
    // 未传入price字段，不更新
}

这个方案完全自定义，能精准区分所有场景，适合复杂的业务需求。

方案3：用Map接收请求体（快速但无类型安全） #

如果你的更新逻辑比较简单，不想折腾DTO和自定义类，可以直接用Map<String, Object>接收请求体：

@PostMapping("/products/{id}")
public void updateProduct(@PathVariable Long id, @RequestBody Map<String, Object> requestBody) {
    Product product = productRepository.findById(id).orElseThrow();
    
    // 处理name字段
    if (requestBody.containsKey("name")) {
        String name = (String) requestBody.get("name");
        product.setName(name.isEmpty() ? null : name);
    }
    
    // 处理price字段
    if (requestBody.containsKey("price")) {
        // 存在key说明用户传了这个字段，不管值是null还是数字
        Integer price = (Integer) requestBody.get("price");
        product.setPrice(price);
    }
    
    productRepository.save(product);
}

这个方案的优点是快速实现，不需要额外配置，但缺点是失去了DTO的类型安全和自动校验，需要自己做类型转换，适合简单的更新场景。

方案4：用Json Patch规范（REST标准方案） #

如果你的项目需要遵循REST规范，推荐使用JSON Patch来处理部分更新。Spring已经支持Json Patch，只需引入依赖（Spring Boot默认包含）：

<dependency>
    <groupId>com.github.fge</groupId>
    <artifactId>json-patch</artifactId>
    <version>1.12</version>
</dependency>

然后写接口：

@PatchMapping("/products/{id}")
public void updateProduct(@PathVariable Long id, @RequestBody JsonPatch patch) {
    Product product = productRepository.findById(id).orElseThrow();
    
    // 把实体转换成JSON Node
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode patched = patch.apply(objectMapper.convertValue(product, JsonNode.class));
    
    // 转换回实体并保存
    Product updatedProduct = objectMapper.treeToValue(patched, Product.class);
    productRepository.save(updatedProduct);
}

客户端可以明确指定要更新的字段，比如发送如下请求体表示把price设为null：

[
    {"op": "replace", "path": "/price", "value": null}
]

这种方式完全符合REST规范，但客户端需要按照Json Patch格式发送请求，有一定学习成本。

以上几个方案各有优劣，你可以根据项目复杂度和业务需求选择：简单场景用Optional或Map，复杂场景用自定义包装类，追求规范的话用Json Patch。

内容的提问来源于stack exchange，提问作者Wooyoung Tyler Kim