Json工具（一）- Jackson

1、Jackson简介

Jackson是常用的高效安全的Json序列化和反序列化框架。Spring MVC 默认的 json 解析器是 Jackson。Jackson有三个核心模块。

jackson-core：提供 Jackson 处理 JSON 数据的核心功能，如流式解析和生成 JSON，提供基本的API。

jackson-annotations：提供注解编程相关的核心注解。

jackson-databind：提供数据绑定功能，使得 JSON 和 Java 对象之间的转换变得简单，提供ObjectMapper和许多用于映射数据的功能。

2、ObjectMapper

ObjectMapper是Jackson提供的序列化和反序列化工具，并且提供了各种定制的API以满足不同类型，不同约束的序列化和反序列化要求。ObjectMapper的入门使用案例如下：

public class JacksonTest1 {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        Person person = new Person();
        person.setAge(25);
        person.setDate(new Date());
        person.setName("xuyuan");
        person.setHeight(178);

        /* 序列化 */
        String jsonString = objectMapper.writeValueAsString(person);
        System.out.println(jsonString);
        //{"myHeight":178,"birthday":"2024-08-27 11:00:32","myAge":25,"myName":"xuyuan"}
        /* 反序列化 */
        Person newPerson = objectMapper.readValue(jsonString, Person.class);
        System.out.println(newPerson);
        // Person(name=xuyuan, age=25, date=Tue Aug 27 19:00:32 CST 2024, height=178)
        /* 对象转换 */
        Animal animal = objectMapper.convertValue(person, Animal.class);
        System.out.println(animal);
        // Animal(field1=xuyuan, field2=25, field3=Tue Aug 27 19:00:32 CST 2024, field4=178)
    }
}

@Data
class Person {
    @JsonProperty(value = "myName", index = 4)
    private String name;
    @JsonProperty(value = "myAge", index = 3)
    private Integer age;

    @JsonProperty(value = "birthday", index = 2)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Date date;
    @JsonProperty(value = "myHeight", index = 1)
    private int height;
}

@Data
class Animal {
    @JsonProperty("myName")
    private String field1;
    @JsonProperty("myAge")
    private Integer field2;

    @JsonProperty("birthday")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date field3;
    @JsonProperty("myHeight")
    private int field4;
}

3、ObjectMapper配置

ObjectMapper提供流式API，有相当丰富的配置选项。以下对配置作简单的说明，了解即可。具体使用的时候，需要使用相关配置，请参考官方文档。

（1）统一配置config

        mapper.setConfig();
        // 参数为DeserializationConfig或者SerializationConfig,设置 ObjectMapper的所有全局配置
        // DeserializationConfig: 控制反序列化过程中的配置，如如何处理未知属性、类型处理、字段可见性等。
        // SerializationConfig: 控制序列化过程中的配置，如属性的包含策略、日期格式、命名策略等。

（2）SerializationConfig和DeserializationConfig的配置

        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); // 设置日期格式
        mapper.setTimeZone(TimeZone.getTimeZone("UTC+8")); // 设置时区。影响日期和时间的格式化和解析。
        mapper.setLocale(Locale.CHINA); // 设置区域设置。影响日期、数字等格式化的本地化设置。
        mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE); // 设置JSON和JAVA对象的映射规则

        // mapper.setAccessorNaming(new DefaultAccessorNamingStrategy.Provider()); // 设置属性命名策略。定义如何将 Java 对象的属性名称转换为 JSON 中的字段名称。
        // mapper.setAnnotationIntrospector(); // 设置注解解析器。用于定义如何处理 Jackson 注解，比如 @JsonIgnore 或 @JsonProperty
        // mapper.setBase64Variant(); // 设置 Base64 编码变体。用于指定 JSON 中的 Base64 数据使用的编码方案
        // mapper.setDefaultAttributes(); // 配置默认属性的特性。允许启用或禁用 ObjectMapper 的某些特性（例如是否允许未知属性）
        // mapper.setDefaultTyping(); // 设置默认的类型处理。定义如何处理多态类型（例如使用类型信息进行反序列化）
        // mapper.setHandlerInstantiator(); // 设置处理程序实例化器。用于创建和管理 JSON 处理程序（如序列化器、反序列化器）的实例
        // 设置属性命名策略，与 setAccessorNaming 类似，定义 JSON 字段名称与 Java 属性名称的映射。（LOWER_CASE、LOWER_CAMEL_CASE、KEBAB_CASE）
        // mapper.setMixInResolver(); // 设置 MixIn 解析器。用于配置 MixIn 注解类的解析策略。
        // mapper.setSerializerFactory(); // 设置序列化工厂。用于配置自定义序列化器的创建和管理

（3）DeserializationConfig的私有配置

        // mapper.setConstructorDetector(); // 设置构造函数检测器。配置如何选择和使用构造函数进行反序列化。
        // mapper.setNodeFactory(); // 设置节点工厂。定义如何创建 JSON 节点（如对象、数组、值等）
        // mapper.setPolymorphicTypeValidator(); // 设置多态类型验证器。用于控制多态类型的验证策略，确保 JSON 数据的类型安全。

（4）SerializationConfig的私有配置

        // mapper.setDefaultPrettyPrinter(); // 设置默认的漂亮打印器。定义 JSON 序列化时如何美化输出（例如添加缩进）
        // mapper.setFilterProvider();// 设置过滤器提供者。用于动态控制哪些属性在序列化时被包含或排除

（5）ConfigOverrides的配置

        // mapper.setDefaultPropertyInclusion(); // 设置默认属性包含策略。与 setSerializationInclusion 类似，用于设置全局的属性包含策略
        // mapper.setDefaultSetterInfo(); // 设置默认的 setter 方法可见性。控制哪些 setter 方法对 JSON 反序列化可见
        // mapper.setDefaultVisibility(); // 设置默认的可见性。控制 JSON 序列化和反序列化时哪些字段和方法是可见的。
        // mapper.setDefaultLeniency(); // 设置默认宽松性。定义 ObjectMapper 在反序列化时是否宽松对待 JSON 内容（如忽略某些错误）
        // mapper.setDefaultMergeable(); // 设置默认可合并性。用于配置合并 JSON 对象的策略。
        // mapper.setSerializationInclusion(); // 设置序列化包含策略。控制哪些属性在序列化时包含到 JSON 中，例如可以配置仅包含非空属性。
        // mapper.setVisibility(); // 设置属性访问器的可见性。控制特定类型（如字段、方法）的可见性。

（6）InjectableValues的配置

        InjectableValues.Std injectableValues = new InjectableValues.Std();
        injectableValues.addValue("responseTime", new Date());
        mapper.setInjectableValues(injectableValues); // 设置默认的可注入值。允许在反序列化时注入额外的值到Java对象中。

（7）SimpleMixInResolver的配置

        // mapper.setMixIns(); // 设置 MixIn 注解类。允许将自定义注解应用到特定的类上，修改其序列化和反序列化行为。

（8）DefaultSerializerProvider的配置

        // mapper.setSerializerProvider(); // 设置序列化提供者。用于提供自定义的序列化策略和上下文。

（9）SubtypeResolver的配置

       // mapper.setSubtypeResolver(); // 设置子类型解析器。用于管理多态类型的子类解析。

（10）开启关闭某个序列化和反序列化的配置

参考SerializationFeature、DeserializationFeature、JsonParser.Feature、JsonGenerator.Feature给出的配置项。

        // mapper.enable();
        // mapper.disable();
        // mapper.configure();
        // 配置序列化某一个特定特性与enable和disable方法类似
        // 配置项为SerializationFeature、DeserializationFeature、JsonParser.Feature、JsonGenerator.Feature

（11）SerializationFeature

public enum SerializationFeature implements ConfigFeature {
    /**
     * 根值是否序列化
     */
    WRAP_ROOT_VALUE(false),

    /**
     * 美化输出，缩进格式输出JSON
     */
    INDENT_OUTPUT(false),


    /**
     * 序列化空Bean时, 是否抛出异常，默认抛出异常。
     * 空Bean即没有任何属性的Bean，或者有属性但是没有对应的get方法。
     */
    FAIL_ON_EMPTY_BEANS(true),

    /**
     * 自身循环引用时，是否抛出异常，默认抛出异常。
     *
     * @since 2.4
     */
    FAIL_ON_SELF_REFERENCES(true),

    /**
     * 包装异常，在序列化对象时如果出现异常，会捕获异常，进行包装后再抛出，以提供更详细的错误信息
     */
    WRAP_EXCEPTIONS(true),

    /**
     * 序列化时，如果已要求JSON中包含对象的类型信息，但是又有@JsonUnwrapped注解，则序列化失败。@JsonUnwrapped会去除对象结构，直接平铺对象内的属性
     *
     * @since 2.4
     */
    FAIL_ON_UNWRAPPED_TYPE_IDENTIFIERS(true),

    /**
     * 自身循环引用，序列化为null
     *
     * @since 2.11
     */
    WRITE_SELF_REFERENCES_AS_NULL(false),


    /**
     * 对象实现了Closeable接口，序列化后自动调用close()方法。默认禁用(不调用close()方法)。
     */
    CLOSE_CLOSEABLE(false),

    /**
     * writeValue序列化之后，是否调用JsonGenerator的flush
     */
    FLUSH_AFTER_WRITE_VALUE(true),


    /* TODO 特定数据类型的配置 */
    /*TODO 日期类型*/
    /**
     * 日期类型序列化成时间戳。如果禁用默认使用StdDateFormat(yyyy-MM-dd'T'HH:mm:ss.SSSX)格式化日期
     */
    WRITE_DATES_AS_TIMESTAMPS(true),

    /**
     * Map日期类型的key序列化为时间戳。默认禁用，使用StdDateFormat(yyyy-MM-dd'T'HH:mm:ss.SSSX)格式化日期
     */
    WRITE_DATE_KEYS_AS_TIMESTAMPS(false),

    /**
     * 序列化日期上的时区ID。默认禁用。启用时，日期的后面会带上时区ID，这种日期反序列化可能会有问题。
     *
     * @since 2.6
     */
    WRITE_DATES_WITH_ZONE_ID(false),

    /**
     * 使用ObjectMapper上下文中的时区序列化日期，对没有时区信息的日期类型无效。默认启用。禁用则使用默认的时区进行序列化日期。
     *
     * @since 2.13
     */
    WRITE_DATES_WITH_CONTEXT_TIME_ZONE(true),

    /**
     * Duration类型的对象序列化为时间戳。
     *
     * @since 2.5
     */
    WRITE_DURATIONS_AS_TIMESTAMPS(true),

    /*TODO CHAR数组*/
    /**
     * char数组序列化为json数组，禁用时会序列化为字符串
     */
    WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS(false),

    /*TODO 枚举*/
    /**
     * 举值的序列化方式。启用时，使用Enum.toString()的返回值；禁用时，使用Enum.name()的返回值。
     */
    WRITE_ENUMS_USING_TO_STRING(false),

    /**
     * 枚举值的序列化方式。启用时，枚举序列化为数字(序号，从0开始)，使用Enum.ordinal()的返回值。禁用时，枚举序列化为文本。默认禁用。
     */
    WRITE_ENUMS_USING_INDEX(false),

    /**
     * 枚举值的序列化方式。枚举作为Map的key时，序列化为数字(序号)。默认禁用。
     *
     * @since 2.10
     */
    WRITE_ENUM_KEYS_USING_INDEX(false),

    /*TODO 集合*/
    /**
     * Map中null值的序列化方式。启用时，序列化null值；禁用时，不序列化null值。建议使用JsonInclude.Include.NON_NULL过滤null
     */
    @Deprecated // since 2.9
            WRITE_NULL_MAP_VALUES(true),

    /**
     * 空集合、空数组的序列化方式。启用时，序列化为空数组；禁用时，不序列化。默认启用。对Map无效。建议使用JsonInclude.Include.NON_EMPTY过滤空集合、空数组。
     */
    @Deprecated // since 2.8
            WRITE_EMPTY_JSON_ARRAYS(true),

    /**
     * 只有单个元素的集合、数组的序列化方式。启用时，正常序列化为数组；禁用时，不序列化为数组(去掉了层级)。默认禁用。
     */
    WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED(false),

    /*TODO BIGDECIMAL*/
    /**
     * 启用时，使用BigDecimal.toPlainString()的返回值；禁用时，使用BigDecimal.toString()的返回值，可能出现科学计数法。
     * 从2.5版本开始废弃，建议使用JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN。
     * BigDecimal有三个toString()方法：
     * toEngineeringString：有必要时使用工程计数法。工程记数法与科学技术法类似，但要求10的幂必须是3的倍数；
     * toPlainString：不使用任何指数；
     * toString：有必要时使用科学计数法。
     */
    @Deprecated // since 2.5
            WRITE_BIGDECIMAL_AS_PLAIN(false),

    /**
     * 是否使用纳秒时间戳写入数字时间戳值
     * @since 2.2
     */
    WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS(true),

    /**
     * 序列化Map时按Key进行排序。启用：排序；禁用：不排序。默认禁用。
     */
    ORDER_MAP_ENTRIES_BY_KEYS(false),

    /**
     * Jackson 会在序列化期间主动获取并缓存所有的序列化器，这可以提高序列化的性能，因为序列化器不需要在序列化过程中动态创建。
     * @since 2.1
     */
    EAGER_SERIALIZER_FETCH(true),

    /**
     * Jackson 序列化对象时会调用 equals() 方法来确定对象引用的唯一性，而不是依赖 Object.hashCode()。
     * 注意，这个特性可能会影响序列化的性能，因为它可能会导致比使用 hashCode() 更慢的 equals() 方法调用。只有当你确实需要依据对象的内容而不是引用来序列化对象时，才应该考虑启用这个特性。
     * @since 2.3
     */
    USE_EQUALITY_FOR_OBJECT_ID(false);

    private final boolean _defaultState;
    private final int _mask;

    private SerializationFeature(boolean defaultState) {
        _defaultState = defaultState;
        _mask = (1 << ordinal());
    }

    @Override
    public boolean enabledByDefault() {
        return _defaultState;
    }


    @Override
    public int getMask() {
        return _mask;
    }

    @Override
    public boolean enabledIn(int flags) {
        return (flags & _mask) != 0;
    }
}

（12）DeserializationFeature

public enum DeserializationFeature implements ConfigFeature {

    /**
     * 反序列化使用BIG_DECIMAL接收float
     */
    USE_BIG_DECIMAL_FOR_FLOATS(false),

    /**
     * 反序列化使用BIG_INTEGER接收int
     */
    USE_BIG_INTEGER_FOR_INTS(false),

    /**
     * 反序列化使用Long接收int
     */
    USE_LONG_FOR_INTS(false),

    /**
     * 在反序列化时，将 JSON 数组反序列化为 Java 数组。
     */
    USE_JAVA_ARRAY_FOR_JSON_ARRAY(false),

    /**
     * 在遇到未知属性时抛出异常。用于强制要求所有属性都应在对象定义中有对应的字段或 setter 方法。
     */
    FAIL_ON_UNKNOWN_PROPERTIES(true),

    /**
     * 在原始类型的属性为 null 时抛出异常。用于确保原始类型不为 null。
     */
    FAIL_ON_NULL_FOR_PRIMITIVES(false),

    /**
     * 在枚举类型的属性为数值类型（如整数）时抛出异常。用于确保枚举类型的属性只能是字符串类型。
     */
    FAIL_ON_NUMBERS_FOR_ENUMS(false),

    /**
     * 在找不到合适的子类型时抛出异常。用于确保在反序列化时能够正确匹配子类型。
     */
    FAIL_ON_INVALID_SUBTYPE(true),

    /**
     * 在读取重复的树节点键时抛出异常。用于确保树形结构中每个键都是唯一的。
     */
    FAIL_ON_READING_DUP_TREE_KEY(false),

    /**
     * 在忽略属性时抛出异常。用于检测是否有未处理的属性。
     */
    FAIL_ON_IGNORED_PROPERTIES(false),

    /**
     * 如果JSON字符串中包含某个对象没有对应的字段或属性，并且没有任何setter或handler来处理这种情况，那么默认行为是抛出异常。
     */
    FAIL_ON_UNRESOLVED_OBJECT_IDS(true),

    /**
     * 在缺少构造器参数时抛出异常。用于确保所有构造器参数都能被正确初始化。
     */
    FAIL_ON_MISSING_CREATOR_PROPERTIES(false),

    /**
     * 在构造器参数为 null 时抛出异常。用于确保构造器参数不为 null。
     */
    FAIL_ON_NULL_CREATOR_PROPERTIES(false),

    /**
     * 当你在使用 Jackson 进行 JSON 反序列化时，如果你的 JSON 数据中包含了用于指示具体类型的字段（例如，使用了 @class 属性来表示具体的类型），
     * Jackson 需要知道如何处理这个字段。如果没有配置相应的处理策略，当这个字段缺失时，Jackson 可能无法正确地确定对象的类型，进而可能导致反序列化失败。
     */
    FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY(true),

    /**
     * 如果存在额外的标记，即使这些标记并不影响JSON对象的主要结构，Jackson也会抛出异常，因为这违反了JSON格式的正确性。
     * 这种行为有助于确保数据的完整性和正确性，避免因为末尾的额外标记导致的潜在错误。
     */
    FAIL_ON_TRAILING_TOKENS(false),

    /**
     * 将解析过程中发生的异常封装为 Jackson 运行时异常，而不是普通的 IOException
     */
    WRAP_EXCEPTIONS(true),

    /**
     * 允许将单一值反序列化为数组。当遇到单一值时，将其解析为只包含该值的数组。
     */
    ACCEPT_SINGLE_VALUE_AS_ARRAY(false),

    /**
     * 允许在反序列化数组时解包单个元素。当数组仅包含一个元素时，返回该元素而不是数组。
     */
    UNWRAP_SINGLE_VALUE_ARRAYS(false),

    /**
     * 允许解包根对象，将根对象的属性直接提取为反序列化的结果。
     */
    UNWRAP_ROOT_VALUE(false),

    /**
     * 允许将空字符串反序列化为 null 对象。当遇到空字符串时，解析为 null。
     */
    ACCEPT_EMPTY_STRING_AS_NULL_OBJECT(false),

    /**
     * 允许将空数组（[]）反序列化为 null 对象。当遇到空数组时，解析为 null。
     */
    ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT(false),

    /**
     * 允许将浮点数作为整数进行反序列化。当遇到浮点数时，如果它表示一个整数，则解析为整数
     */
    ACCEPT_FLOAT_AS_INT(true),

    /**
     * 使用toString()方法获取枚举值的字符串形式
     */
    READ_ENUMS_USING_TO_STRING(false),

    /**
     * 将未知的枚举值反序列化为 null
     */
    READ_UNKNOWN_ENUM_VALUES_AS_NULL(false),

    /**
     * 当反序列化枚举时，如果遇到未知的枚举值，将使用枚举的默认值。
     */
    READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE(false),

    /**
     * 将时间戳解析为纳秒
     */
    READ_DATE_TIMESTAMPS_AS_NANOSECONDS(true),

    /**
     * 在反序列化过程中调整日期时间值到上下文时区
     */
    ADJUST_DATES_TO_CONTEXT_TIME_ZONE(true),

    /**
     * 决定是否立即获取序列化器,使用缓存
     * EAGER_SERIALIZER_FETCH的设置取决于应用的具体需求和性能与内存使用的权衡。
     * 如果应用对性能有较高要求，且能够接受一定的内存增加，那么设置为true可能是合适的。
     * 反之，如果更注重内存使用的效率，或者对性能要求不是特别高，那么可以考虑保持默认设置或根据具体情况进行调整‌
     */
    EAGER_DESERIALIZER_FETCH(true);

    private final boolean _defaultState;
    private final int _mask;

    private DeserializationFeature(boolean defaultState) {
        _defaultState = defaultState;
        _mask = (1 << ordinal());
    }

    @Override
    public boolean enabledByDefault() {
        return _defaultState;
    }

    @Override
    public int getMask() {
        return _mask;
    }

    @Override
    public boolean enabledIn(int flags) {
        return (flags & _mask) != 0;
    }
}

（13）JsonParser.Feature

public enum Feature {
        // // // Low-level I/O handling features:

        /**
         * JsonParser 实例在解析完成后是否自动关闭输入源的特性。
         * 如果启用此特性，解析器会在解析完成后自动关闭与之关联的 InputStream、Reader 或其他输入源。
         */
        AUTO_CLOSE_SOURCE(true),

        /**
         * JsonParser是否允许解析Java/C++风格注释的特性。由于JSON规范不支持注释，这个特性是非标准的，且默认是禁用的。
         * 从Jackson 2.10开始，推荐使用JsonReadFeature#ALLOW_JAVA_COMMENTS来配置这个特性。
         */
        ALLOW_COMMENTS(false),

        /**
         * 配置JsonParser是否允许解析YAML风格的注释。 由于JSON规范不支持注释，这个特性是非标准的，且默认是禁用的。
         * 推荐使用JsonReadFeature#ALLOW_YAML_COMMENTS来配置这个特性。
         */
        ALLOW_YAML_COMMENTS(false),


        ALLOW_UNQUOTED_FIELD_NAMES(false),


        ALLOW_SINGLE_QUOTES(false),


        @Deprecated
        ALLOW_UNQUOTED_CONTROL_CHARS(false),

        @Deprecated
        ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER(false),


        @Deprecated
        ALLOW_NUMERIC_LEADING_ZEROS(false),


        @Deprecated
        ALLOW_LEADING_DECIMAL_POINT_FOR_NUMBERS(false),


        @Deprecated
        ALLOW_NON_NUMERIC_NUMBERS(false),


        @Deprecated
        ALLOW_MISSING_VALUES(false),


        @Deprecated
        ALLOW_TRAILING_COMMA(false),

        // // // Validity checks

        /**
         * 配置JsonParser是否应该检查JSON对象中的重复字段名。
         * 启用该特性会增加性能开销，增加基础解析的执行时间约20-30%，JsonParser会检查当前上下文中的所有字段名，并在遇到重复字段名时抛出一个JsonParseException异常。
         */
        STRICT_DUPLICATE_DETECTION(false),

        /**
         * 未知属性的处理方式。尝试读取一个未知的属性时，将会抛出一个JsonProcessingException异常。
         */
        IGNORE_UNDEFINED(false),

        // // // Other

        /**
         * 是否应该包含对源数据的引用。可用于控制在解析异常等情况下是否泄露有关源数据的详细信息。
         */
        INCLUDE_SOURCE_IN_LOCATION(true),

        ;

        /**
         * Whether feature is enabled or disabled by default.
         */
        private final boolean _defaultState;

        private final int _mask;

        /**
         * Method that calculates bit set (flags) of all features that
         * are enabled by default.
         *
         * @return Bit mask of all features that are enabled by default
         */
        public static int collectDefaults() {
            int flags = 0;
            for (Feature f : values()) {
                if (f.enabledByDefault()) {
                    flags |= f.getMask();
                }
            }
            return flags;
        }

        private Feature(boolean defaultState) {
            _mask = (1 << ordinal());
            _defaultState = defaultState;
        }

        public boolean enabledByDefault() {
            return _defaultState;
        }

        public boolean enabledIn(int flags) {
            return (flags & _mask) != 0;
        }

        public int getMask() {
            return _mask;
        }
    }

（14）JsonGenerator.Feature

    public enum Feature {
        // // Low-level I/O / content features

        
        AUTO_CLOSE_TARGET(true),

       
        AUTO_CLOSE_JSON_CONTENT(true),

        
        FLUSH_PASSED_TO_STREAM(true),

        // // Quoting-related features
        
        
        @Deprecated
        QUOTE_FIELD_NAMES(true),

       
         @Deprecated
        QUOTE_NON_NUMERIC_NUMBERS(true),

        // // Character escaping features

        
        @Deprecated
        ESCAPE_NON_ASCII(false),

        // // Datatype coercion features

       
        @Deprecated
        WRITE_NUMBERS_AS_STRINGS(false),

        
        WRITE_BIGDECIMAL_AS_PLAIN(false),

        // // Schema/Validity support features

        STRICT_DUPLICATE_DETECTION(false),
        
        
        IGNORE_UNKNOWN(false),
        ;

        private final boolean _defaultState;
        private final int _mask;
        
       
        public static int collectDefaults()
        {
            int flags = 0;
            for (Feature f : values()) {
                if (f.enabledByDefault()) {
                    flags |= f.getMask();
                }
            }
            return flags;
        }
        
        private Feature(boolean defaultState) {
            _defaultState = defaultState;
            _mask = (1 << ordinal());
        }

        public boolean enabledByDefault() { return _defaultState; }

        // @since 2.3
        public boolean enabledIn(int flags) { return (flags & _mask) != 0; }

        public int getMask() { return _mask; }
    }

4、ObjectMapper成员变量

/**
     * 创建JsonParser和JsonGenerator的工厂对象
     */
    protected final JsonFactory _jsonFactory;

    /**
     * 用于创建JavaType实例的工厂
     * 需要允许模块添加更多自定义类型处理（主要是为了支持非 Java JVM 语言的类型）
     */
    protected TypeFactory _typeFactory;

    /**
     * 获取反序列化自定义注入值的处理器
     */
    protected InjectableValues _injectableValues;

    /**
     * 处理多态类型的序列化和反序列化
     */
    protected SubtypeResolver _subtypeResolver;

    /**
     * 提供覆盖ObjectMapper的配置，定制化为每一个类提供重写的配置，还有全局的配置覆盖ObjectMapper的配置
     * @since 2.9
     */
    protected final ConfigOverrides _configOverrides;

    /**
     * 配置相关的强制类型转换规则
     * @since 2.12
     */
    protected final CoercionConfigs _coercionConfigs;

    /**
     * 负责处理和Mix-in注解相关的逻辑。Mix-in注解是一种在运行时向Jackson对象映射系统添加注解的方法，这些注解可以是全局配置或者是针对特定类或字段的配置。
     * @since 2.6
     */
    protected SimpleMixInResolver _mixIns;

    /**
     * 定义序列化过程中基本的全局配置
     */
    protected SerializationConfig _serializationConfig;

    /**
     * 根据要序列化的对象的类型提供合适的序列化器（JsonSerializer<T>）
     */
    protected DefaultSerializerProvider _serializerProvider;

    /**
     * 负责创建序列化器（JsonSerializer<T>）
     */
    protected SerializerFactory _serializerFactory;

    /**
     * 定义反序列化过程中基本的全局配置
     */
    protected DeserializationConfig _deserializationConfig;

    /**
     * 提供了在反序列化过程中需要的各种服务和信息。包括相关所有配置
     */
    protected DefaultDeserializationContext _deserializationContext;

    /**
     处理JSON序列化和反序列化的核心类，它支持通过模块（Module）系统来扩展其功能。
     每个模块都可以注册自定义的序列化器（JsonSerializer<T>）、反序列化器（JsonDeserializer<T>）等，以便在序列化和反序列化过程中使用。
     * @since 2.5
     */
    protected Set<Object> _registeredModuleTypes;