【问题标题】:Is it possible to configure Jackson custom deserializers at class level for different data types?是否可以在类级别为不同的数据类型配置 Jackson 自定义反序列化器?
【发布时间】:2019-08-23 01:09:11
【问题描述】:

我需要反序列化一个长而复杂的 json,为此我编写了一组 java 类来映射数据,并且我必须为许多不同类型的字段编写自定义反序列化器(包括 String、Boolean、BigDecimal、等)。

我知道我可以使用相应的自定义反序列化器(如下所示)注释 java 类中的所有字段,但是我需要注释所有类中的几乎所有字段。

@JsonDeserialize(using = CustomBooleanJsonDeserializer.class)
private boolean active;

我也知道我可以在 Spring 默认 ObjectMapper 中注册一个模块(如 here),但我只想为这些特定的类使用这些自定义反序列化器。

@Bean
public Module customDeserializersModule() {
    SimpleModule module = new SimpleModule();
    module.addDeserializer(Boolean.class, new CustomBooleanJsonDeserializer());
    // add other custom deserializers 
    return module;
}

我什至知道我可以在RestController中使用自定义的ObjectMapper,但是我不想放弃通过@RequestBody自动绑定数据的便利,因为我必须防止别人在没有的情况下使用它必要的自定义反序列化程序。

@RequestMapping(method = RequestMethod.POST, value = "/data")
public ResponseEntity<ServerInfo> register(@RequestBody DataMapper data) {
   // DataMapper is the target POJO class of the json's deserialization
}

简而言之,我正在寻找类似的课程级别:

@JsonDeserialize(using = CustomStringJsonDeserializer.class, forType = String.class)
@JsonDeserialize(using = CustomBooleanJsonDeserializer.class, forType = Boolean.class)
@JsonDeserialize(using = CustomBigDecimalJsonDeserializer.class, forType = BigDecimal.class)
public class DataMapper implements Serializable {
    // obviously, @JsonDeserialize doesn't have a forType method
}

或者可能以某种方式为DataMapper 类实现自定义反序列化器,它定义了如何根据其数据类型反序列化每个字段(无需注释每个字段):

@JsonDeserialize(using = DataMapperJsonDeserializer.class)
public class DataMapper implements Serializable {
    // How can I implement the DataMapperJsonDeserializer with these 
    // characteristics? I know about the ContextualDeserializer interface, 
    // but I don't know how to use it without annotating each field.
}

或某种方式将模块的效果限制在一个包或一组类中:

module.restrictedTo(/*some package or set of classes*/);
// com.fasterxml.jackson.databind.Module doesn't have a restrictedTo method

【问题讨论】:

    标签: java json spring jackson deserialization


    【解决方案1】:

    您可以尝试将SimpleModule 与ContextualDeserializer 接口一起使用。第一个可用于包装默认反序列化器,第二个可用于检查类型配置 - 检查注解。

    让我们从注解开始:

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @interface ForceCustomDeserializer {
    }
    

    我假设您对于给定类型只有一个自定义实现,但如果不是真的,请在注释上方扩展并提供一些允许使用适当反序列化器的额外信息。例如,下面我们可以看到两个自定义反序列化器,它们额外记录一些信息并运行默认反序列化。使用基本解串器是因为如果您有一些额外的配置,我们不会丢失它。

    class CustomBoolDeserializer extends StdScalarDeserializer<Boolean> implements ContextualDeserializer {
    
        private NumberDeserializers.BooleanDeserializer base;
    
        public CustomBoolDeserializer(NumberDeserializers.BooleanDeserializer base) {
            super(Boolean.class);
            this.base = base;
        }
    
        @Override
        public Boolean deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            System.out.println("Custom BooleanDeserializer ....");
    
            return base.deserialize(p, ctxt);
        }
    
        @Override
        public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) {
            Class<?> parent = property.getMember().getDeclaringClass();
            ForceCustomDeserializer annotation = parent.getAnnotation(ForceCustomDeserializer.class);
    
            return annotation == null ? base : this;
        }
    }
    
    class CustomStringDeserializer extends StringDeserializer implements ContextualDeserializer {
    
        private final StringDeserializer base;
    
        public CustomStringDeserializer(StringDeserializer base) {
            this.base = base;
        }
    
        @Override
        public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            System.out.println("Custom StringDeserializer ....");
    
            return base.deserialize(p, ctxt);
        }
    
        @Override
        public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) {
            Class<?> parent = property.getMember().getDeclaringClass();
            ForceCustomDeserializer annotation = parent.getAnnotation(ForceCustomDeserializer.class);
    
            return annotation == null ? base : this;
        }
    }
    

    我们可以测试上面的自定义实现如下:

    import com.fasterxml.jackson.core.JsonParser;
    import com.fasterxml.jackson.databind.BeanDescription;
    import com.fasterxml.jackson.databind.BeanProperty;
    import com.fasterxml.jackson.databind.DeserializationConfig;
    import com.fasterxml.jackson.databind.DeserializationContext;
    import com.fasterxml.jackson.databind.JsonDeserializer;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
    import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
    import com.fasterxml.jackson.databind.deser.std.NumberDeserializers;
    import com.fasterxml.jackson.databind.deser.std.StdScalarDeserializer;
    import com.fasterxml.jackson.databind.deser.std.StringDeserializer;
    import com.fasterxml.jackson.databind.module.SimpleModule;
    
    import java.io.File;
    import java.io.IOException;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    public class JsonApp {
    
        public static void main(String[] args) throws Exception {
            File jsonFile = new File("./resource/test.json").getAbsoluteFile();
    
            SimpleModule forcedCustomModule = new SimpleModule();
            forcedCustomModule.setDeserializerModifier(new BeanDeserializerModifier() {
                @Override
                public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
                    if (deserializer instanceof StringDeserializer) {
                        // wrap with yours or return new deserializer
                        return new CustomStringDeserializer((StringDeserializer) deserializer);
                    }
                    if (deserializer instanceof NumberDeserializers.BooleanDeserializer) {
                        // wrap with yours or return new deserializer
                        return new CustomBoolDeserializer((NumberDeserializers.BooleanDeserializer) deserializer);
                    }
                    // override for other types
    
                    return deserializer;
                }
            });
    
            ObjectMapper mapper = new ObjectMapper();
            mapper.registerModule(forcedCustomModule);
    
            System.out.println(mapper.readValue(jsonFile, Pojo.class));
        }
    }
    
    @ForceCustomDeserializer
    class Pojo {
    
        private String name;
        private boolean bool;
    
        // getters, setters, toString
    }
    

    JSON 有效载荷的上例:

    {
      "name": "Jackson",
      "bool": true
    }
    

    打印:

    Custom StringDeserializer ....
    Custom BooleanDeserializer ....
    Pojo{name='Jackson', bool=true}
    

    另见:

    【讨论】:

    • 我喜欢它,尽管这是最后的手段。要通过 Spring Controllers 中默认的 @RequestBody 数据绑定使用这种方法,我需要全局注册这个模块,因此,系统将验证所有反序列化的 @ForceCustomDeserializer 注释的存在,这是一个大系统。
    • 有什么办法可以在反序列化之前不用注册这个模块?也就是说POJO告诉ObjectMapper应该怎么做反序列化而不是ObjectMapper 必须验证所有POJOs。我对BeanDeserializerModifier 没有任何问题,但我宁愿避免在全局范围内定义它。
    • @Nicolau,您想为给定的POJO 类设置自定义反序列化器。现在我们有两种方法:使用Jackson 注释进行注释,Jackson 将读取这些注释并为给定属性分配自定义反序列化器或以更一般的方式告诉Jackson - 使用BeanDeserializerModifier。请注意,上面的示例在自定义反序列化器中检查 @ForceCustomDeserializer 注释是否在类级别上使用。如果存在注释 - 返回自定义反序列化器;如果不是 - 实现窥视默认反序列化器。
    • 是的,这是一个很好的例子,我认为在某种程度上它符合我的第三个想法:将模块的效果限制在一个包或一组类。我只是希望我可以为某些 POJO 类设置自定义反序列化器,仅使用 Jackson 注释但不注释每个字段。课堂级别的东西,比如问题中的前两个想法。 有没有办法在自定义反序列化器中注册类似的 BeanDeserializerModifier,适用于类级别?
    • @Nicolau,我没有找到这样的注释。 @JsonDeserialize直接作用于给定的方法、字段或类。我们可以使用ObjectMapper.configOverride(java.lang.Class<?>),但它适用于所有类。也许,您可以创建两个 ObjectMapper 实例,并在需要自定义反序列化器时使用一个实例,否则使用其他实例。
    【解决方案2】:

    您可以为该类定义一个自定义反序列化器(作为问题中的第二个想法)并在里面使用您自己的自定义 ObjectMapper:

    public class DataMapperJsonDeserializer extends JsonDeserializer<DataMapper> {
    
        private static final ObjectMapper objectMapper = new ObjectMapper();
        private static final SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd/MM/yyyy");
    
        static {
            SimpleModule module = new SimpleModule();
            module.addDeserializer(BigInteger.class, new CustomBigIntegerJsonDeserializer());
            module.addDeserializer(BigDecimal.class, new CustomBigDecimalJsonDeserializer());
            module.addDeserializer(Boolean.class, new CustomBooleanJsonDeserializer());
            module.addDeserializer(String.class, new CustomStringJsonDeserializer());
            objectMapper.registerModule(module);
            objectMapper.addMixIn(DataMapper.class, DefaultJsonDeserializer.class);
            objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            objectMapper.setDateFormat(simpleDateFormat);
        }
    
        @Override
        public DataMapper deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
            return objectMapper.readValue(jsonParser, DataMapper.class);
        }
    
        @JsonDeserialize
        private interface DefaultJsonDeserializer {
            // Reset default json deserializer
        }
    
    }
    

    注意使用Jackson Mix-in Annotations(DefaultJsonDeserializerinterface)从POJO类中动态删除自定义反序列化器,避免StackOverflowError否则会因为objectMapper.readValue(jsonParser, DataMapper.class)而被抛出。


    那么,就是注释POJO类:

    @JsonDeserialize(using = DataMapperJsonDeserializer.class)
    public class DataMapper implements Serializable {
        // It is not necessary to annotate each field with custom deserializers.
    }
    

    您甚至可以将其他POJO 类添加为DataMapper 的字段,并且每种类型的自定义反序列化器将自动应用于其字段,无需注释。

    【讨论】:

    • 在自定义反序列化器中使用新的自定义 ObjectMapper 实例可以解决问题。如果您已经对其进行了测试,并且它适用于所有极端情况,我认为这是可以接受的。使用@JsonDeserialize 注释的技巧非常有趣。我对此一无所知。一个缺点是,该解决方案不适用于许多 POJO 类。您需要创建许多带有隐藏 ObjectMappers 的反序列化器。
    • @MichałZiober:我编辑了我的答案,您可以使用这种方法来创建不同级别的嵌套,而无需为每个 POJO 类创建自定义反序列化器。另一方面,这个想法(正如你所建议的)是全局配置ObjectMapper,并在必要时覆盖它并使用自定义ObjectMapper,通过类中的简单注释水平。
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2014-07-05
    • 2017-06-12
    • 2016-07-09
    • 1970-01-01
    • 2020-05-28
    • 2022-11-23
    • 2013-12-30
    相关资源
    最近更新 更多