"Relaxed" 杰克逊的字段名称

Question

我正在研究 Jackson 配置，我想知道是否有任何选项可以反序列化不同类型的字段模式。

比如我有一个对象：

class DeserializeIt {
    String fieldOne;
    String fieldOneAndHalf;
    String fieldTwo;
    String fieldThree;
    String fieldFour;

   //getters setters etc.
}

我有以下 JSON 有效载荷：

{
    "fieldOne" : "value1",
    "field_ONE-and_Half": "value15",
    "FIELD_TWO": "value2",
    "FIELD_THREE" : "value3",
    "field_four": "value4"
}

我想将所有这些字段名称反序列化为驼峰式大小写。

我试图创建我的自定义 PropertyNamingStrategy 但它是从另一个方向出发的：它不会将定界字段转换为驼峰式大小写，它会尝试转换对象字段并在解析的字符串中搜索它们。

并且由于我无法传递可能的字符串列表而不是一个变体（fieldOne 可以变成 field-one、field_one、field-ONE 等），所以这样做不工作。

你知道我还可以为如此轻松的反序列化配置什么吗？

Answer 1

我们需要扩展 com.fasterxml.jackson.databind.deser.BeanDeserializerModifier 和 com.fasterxml.jackson.databind.deser.BeanDeserializer 反序列化 POJO classes。下面的解决方案取决于您正在使用的 version，因为我从基础 class 复制了一些代码，这些代码还没有准备好拦截额外的功能。如果您的 POJO 没有任何额外的配置，classes vanillaDeserialize 方法将被调用，我们将尝试改进此方法。

在其他情况下，您需要调试此解串器并根据需要更新其他地方。下面的解决方案使用版本 2.9.8.

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.JsonTokenId;
import com.fasterxml.jackson.databind.BeanDescription;
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.BeanDeserializer;
import com.fasterxml.jackson.databind.deser.BeanDeserializerBase;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.module.SimpleModule;

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

public class JsonApp {

    public static void main(String[] args) throws Exception {
        File jsonFile = new File("./resource/test.json").getAbsoluteFile();

        SimpleModule relaxedModule = new SimpleModule();
        relaxedModule.setDeserializerModifier(new RelaxedBeanDeserializerModifier());

        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(relaxedModule);

        System.out.println(mapper.readValue(jsonFile, DeserializeIt.class));
    }
}

class RelaxedBeanDeserializerModifier extends BeanDeserializerModifier {

    @Override
    public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
        JsonDeserializer<?> base = super.modifyDeserializer(config, beanDesc, deserializer);
        if (base instanceof BeanDeserializer) {
            return new RelaxedBeanDeserializer((BeanDeserializer) base);
        }

        return base;
    }
}

class RelaxedBeanDeserializer extends BeanDeserializer {

    private Map<String, String> properties = new HashMap<>();

    public RelaxedBeanDeserializer(BeanDeserializerBase src) {
        super(src);
        _beanProperties.forEach(property -> {
            properties.put(property.getName().toLowerCase(), property.getName());
        });
    }

    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        // common case first
        if (p.isExpectedStartObjectToken()) {
            if (_vanillaProcessing) {
                return vanillaDeserialize(p, ctxt, p.nextToken());
            }
            // 23-Sep-2015, tatu: This is wrong at some many levels, but for now... it is
            //    what it is, including "expected behavior".
            p.nextToken();
            if (_objectIdReader != null) {
                return deserializeWithObjectId(p, ctxt);
            }
            return deserializeFromObject(p, ctxt);
        }
        return _deserializeOther(p, ctxt, p.getCurrentToken());
    }

    protected Object vanillaDeserialize(JsonParser p, DeserializationContext ctxt, JsonToken t) throws IOException {
        final Object bean = _valueInstantiator.createUsingDefault(ctxt);
        // [databind#631]: Assign current value, to be accessible by custom serializers
        p.setCurrentValue(bean);

        if (p.hasTokenId(JsonTokenId.ID_FIELD_NAME)) {
            String propName = p.getCurrentName();

            do {
                String relaxedName = getRelaxedName(propName);
                String mappedName = properties.get(relaxedName);
                defaultImplementation(p, ctxt, bean, mappedName);
            } while ((propName = p.nextFieldName()) != null);
        }
        return bean;
    }

    private void defaultImplementation(JsonParser p, DeserializationContext ctxt, Object bean, String propName) throws IOException {
        p.nextToken();
        SettableBeanProperty prop = _beanProperties.find(propName);

        if (prop != null) { // normal case
            try {
                prop.deserializeAndSet(p, ctxt, bean);
            } catch (Exception e) {
                wrapAndThrow(e, bean, propName, ctxt);
            }
            return;
        }
        handleUnknownVanilla(p, ctxt, bean, propName);
    }

    private String getRelaxedName(String name) {
        return name.replaceAll("[_\-]", "").toLowerCase();
    }
}

以上代码打印：

DeserializeIt{fieldOne='value1', fieldOneAndHalf='value15', fieldTwo='value2', fieldThree='value3', fieldFour='value4'}

另请参阅：

Answer 2

从 Jackson 2.9 开始，您可以使用 @JsonAlias annotation。在您的示例中，它将是这样的：

class DeserializeIt {
  @JsonAlias("fieldOne") 
  String fieldOne;

  @JsonAlias("field_ONE-and_Half") 
  String fieldOneAndHalf;

  @JsonAlias("FIELD_TWO") 
  String fieldTwo;

  @JsonAlias("FIELD_THREE") 
  String fieldThree;
  // and so on...
}

Answer 3

对我自己有效的方法：我添加了一个 AOP 组件，将传入对象的所有字段重命名为 Camel 大小写。

"Relaxed" 杰克逊的字段名称

"Relaxed" fields names for Jackson

java

json

jackson

deserialization

json-deserialization