反序列化时如何基于嵌套深度级别使用JsonIgnore忽略指定字段

要实现「仅当类嵌套深度超过2级时忽略指定字段」的需求，以Java常用的Jackson序列化框架为例，核心思路是跟踪反序列化时的嵌套深度，结合自定义注解标记目标字段，在深度超过阈值时跳过该字段的解析。

步骤1：自定义注解标记需要忽略的字段 #

定义一个注解，用来标记哪些字段需要在嵌套过深时被忽略，同时可指定深度阈值（默认设为2）：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface IgnoreWhenDeepNested {
    int depthThreshold() default 2;
}

步骤2：实现嵌套深度跟踪工具 #

用ThreadLocal维护当前线程的反序列化嵌套深度，保证多线程环境下的安全性：

public class NestingDepthTracker {
    private static final ThreadLocal<Integer> DEPTH = ThreadLocal.withInitial(() -> 0);

    public static void increment() {
        DEPTH.set(DEPTH.get() + 1);
    }

    public static void decrement() {
        DEPTH.set(DEPTH.get() - 1);
    }

    public static int getCurrentDepth() {
        return DEPTH.get();
    }
}

步骤3：自定义反序列化器修饰符 #

通过BeanDeserializerModifier拦截目标字段的反序列化逻辑，给标记了注解的字段添加深度检查：

import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition;
import java.util.List;

public class IgnoreDeepNestedModifier extends BeanDeserializerModifier {
    @Override
    public List<SettableBeanProperty> changeProperties(DeserializationConfig config, BeanDescription beanDesc, List<SettableBeanProperty> properties) {
        for (int i = 0; i < properties.size(); i++) {
            SettableBeanProperty prop = properties.get(i);
            BeanPropertyDefinition propDef = prop.getMember().getPropertyDefinition();
            if (propDef != null) {
                AnnotatedField field = propDef.getField();
                if (field != null && field.hasAnnotation(IgnoreWhenDeepNested.class)) {
                    IgnoreWhenDeepNested annotation = field.getAnnotation(IgnoreWhenDeepNested.class);
                    int threshold = annotation.depthThreshold();
                    // 包装原反序列化器，注入深度检查逻辑
                    SettableBeanProperty modifiedProp = prop.withValueDeserializer(new DepthCheckingDeserializer(prop.getValueDeserializer(), threshold));
                    properties.set(i, modifiedProp);
                }
            }
        }
        return properties;
    }
}

步骤4：实现深度检查的反序列化器 #

在反序列化时判断当前嵌套深度，超过阈值则跳过字段解析：

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import java.io.IOException;

public class DepthCheckingDeserializer extends JsonDeserializer<Object> {
    private final JsonDeserializer<Object> delegate;
    private final int depthThreshold;

    public DepthCheckingDeserializer(JsonDeserializer<Object> delegate, int depthThreshold) {
        this.delegate = delegate;
        this.depthThreshold = depthThreshold;
    }

    @Override
    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        NestingDepthTracker.increment();
        try {
            int currentDepth = NestingDepthTracker.getCurrentDepth();
            if (currentDepth > depthThreshold) {
                p.skipChildren(); // 必须跳过子节点，避免解析器位置错乱
                return null;
            }
            return delegate.deserialize(p, ctxt);
        } finally {
            NestingDepthTracker.decrement();
        }
    }
}

步骤5：注册并测试 #

将自定义修饰符注册到ObjectMapper，然后编写测试类验证：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.setDeserializerModifier(new IgnoreDeepNestedModifier());
        mapper.registerModule(module);

        // 测试JSON：Level3是第3级嵌套，超过阈值2
        String json = "{\"name\":\"Level1\",\"child\":{\"name\":\"Level2\",\"child\":{\"name\":\"Level3\",\"sensitiveField\":\"should be ignored\"}}}";
        Level1 obj = mapper.readValue(json, Level1.class);
        System.out.println(obj.getChild().getChild().getSensitiveField()); // 输出null，字段被忽略
    }
}

// 测试层级类
class Level1 {
    private String name;
    private Level2 child;
    // 省略getter/setter
}

class Level2 {
    private String name;
    private Level3 child;
    // 省略getter/setter
}

class Level3 {
    private String name;
    @IgnoreWhenDeepNested // 使用默认阈值2
    private String sensitiveField;
    // 省略getter/setter
}

关键细节说明 #

• 深度计算规则：根对象为第1级，直接子对象为第2级，子对象的子对象为第3级，以此类推。
• skipChildren()方法必须调用，否则跳过字段后JSON解析器会停留在错误的节点位置，导致后续解析失败。
• 如果使用Gson等其他序列化框架，思路类似：自定义TypeAdapter，在read方法中跟踪嵌套深度，判断是否忽略字段。

内容的提问来源于stack exchange，提问作者ajidahk