我需要以我将在下面描述的特定方式配置 Jackson。

要求

1. 带注释的字段仅使用其 id 进行序列化:
   • 如果字段是普通对象，序列化它的id
   • 如果字段是对象的集合，序列化一个id的数组
2. 带注释的字段以不同方式序列化其属性名称:
   • 如果字段是普通对象，在属性名后加上"_id"后缀
   • 如果该字段是对象的集合，则在属性名称后添加"_ids"后缀
3. 对于注解，我考虑的是自定义的 @JsonId，理想情况下是带有一个可选值来覆盖名称，就像 @JsonProperty 所做的那样
4. id 属性应由用户定义，可以使用:
   • 已经存在的 Jackson 的 @JsonIdentityInfo
   • 或者通过创建另一个类或字段注释
   • 或者通过决定检查哪个注解来检查 id 属性的可发现性(例如，对 JPA 场景很有用)
5. 对象应该用包装的根值序列化
6. 驼峰命名应转换为带下划线的小写
7. 所有这些都应该是可反序列化的(通过构造一个只设置了 id 的实例)

一个例子

考虑这些 POJO:

//Inform Jackson which property is the id
@JsonIdentityInfo(
    generator = ObjectIdGenerators.PropertyGenerator.class,
    property = "id"
)
public abstract class BaseResource{
    protected Long id;

    //getters and setters
}

public class Resource extends BaseResource{
    private String name;
    @JsonId
    private SubResource subResource;
    @JsonId
    private List<SubResource> subResources;

    //getters and setters
}

public class SubResource extends BaseResource{
    private String value;

    //getters and setters
}

Resource 实例的可能序列化可能是:

{
    "resource":{
        "id": 1,
        "name": "bla",
        "sub_resource_id": 2,
        "sub_resource_ids": [
            1,
            2,
            3
        ]
    }
}

到目前为止...

• 需求 #5 可以通过以下方式配置 ObjectMapper 来实现:

  objectMapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
  objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
  

  然后在我的 POJO 中使用 @JsonRootName("example_root_name_here")。

• 需求 #6 可以通过以下方式配置 ObjectMapper 来实现:

  objectMapper.setPropertyNamingStrategy(
      PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
  

如您所见，仍有许多要求需要满足。对于那些想知道为什么我需要这样的配置的人，这是因为我正在为 ember.js 开发一个 REST 网络服务。 (更具体地说是 Ember 数据)。 如果您能帮助满足任何要求，您将不胜感激。

谢谢!

最佳答案

您的大部分(全部？)需求都可以通过使用上下文序列化程序来实现。从ContextualDeserializer for mapping JSON to different types of maps with Jackson中得到一个答案和 jackson 的 wiki ( http://wiki.fasterxml.com/JacksonFeatureContextualHandlers ) 我能够想出以下内容。

您需要从@JsonId 注释开始，这是指示属性只需要使用 Id 属性的关键。

import com.fasterxml.jackson.annotation.*;
import java.lang.annotation.*;

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation // important so that it will get included!
public @interface JsonId {
}

接下来是实际的 ContextualSerializer，它负责繁重的工作。

import com.fasterxml.jackson.databind.ser.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.core.*;
import java.io.*;

public class ContextualJsonIdSerializer
    extends JsonSerializer<BaseResource>
    implements ContextualSerializer/*<BaseResource>*/
{
    private ObjectMapper mapper;
    private boolean useJsonId;

    public ContextualJsonIdSerializer(ObjectMapper mapper) { this(mapper, false); }
    public ContextualJsonIdSerializer(ObjectMapper mapper, boolean useJsonId) {
        this.mapper = mapper;
        this.useJsonId = useJsonId;
    }

    @Override
    public void serialize(BaseResource br, JsonGenerator jgen, SerializerProvider provider) throws IOException
    {
        if ( useJsonId ) {
            jgen.writeString(br.getId().toString());
        } else {
            mapper.writeValue(jgen, br);
        }
    }

    @Override
    public JsonSerializer<BaseResource> createContextual(SerializerProvider config, BeanProperty property)
            throws JsonMappingException
    {
        // First find annotation used for getter or field:
        System.out.println("Finding annotations for "+property);

        if ( null == property ) {
            return new ContextualJsonIdSerializer(mapper, false);
        }

        JsonId ann = property.getAnnotation(JsonId.class);
        if (ann == null) { // but if missing, default one from class
            ann = property.getContextAnnotation(JsonId.class);
        }
        if (ann == null ) {//|| ann.length() == 0) {
            return this;//new ContextualJsonIdSerializer(false);
        }
        return new ContextualJsonIdSerializer(mapper, true);
    }
}

此类查看 BaseResource 属性并检查它们以查看是否存在 @JsonId 注释。如果是，则仅使用 Id 属性，否则使用传入的 ObjectMapper 来序列化该值。这很重要，因为如果您尝试使用(基本上)在 ContextualSerializer 上下文中的映射器，那么您将得到堆栈溢出，因为它最终会一遍又一遍地调用这些方法。

您的资源应如下所示。我使用了 @JsonProperty 注释而不是将功能包装在 ContextualSerializer 中，因为重新发明轮子似乎很愚蠢。

import java.util.*;
import com.fasterxml.jackson.annotation.*;

public class Resource extends BaseResource{
    private String name;

    @JsonProperty("sub_resource_id")
    @JsonId
    private SubResource subResource;

    @JsonProperty("sub_resource_ids")
    @JsonId
    private List<SubResource> subResources;

    //getters and setters
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}

    public SubResource getSubResource() {return subResource;}
    public void setSubResource(SubResource subResource) {this.subResource = subResource;}

    public List<SubResource> getSubResources() {return subResources;}
    public void setSubResources(List<SubResource> subResources) {this.subResources = subResources;}
}

最后，执行序列化的方法只是创建了一个额外的 ObjectMapper 并在原始 ObjectMapper 中注册了一个模块。

// Create the original ObjectMapper
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);

// Create a clone of the original ObjectMapper
ObjectMapper objectMapper2 = new ObjectMapper();
objectMapper2.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
objectMapper2.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
objectMapper2.setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);

// Create a module that references the Contextual Serializer
SimpleModule module = new SimpleModule("JsonId", new Version(1, 0, 0, null));
// All references to SubResource should be run through this serializer
module.addSerializer(SubResource.class, new ContextualJsonIdSerializer(objectMapper2));
objectMapper.registerModule(module);

// Now just use the original objectMapper to serialize

关于java - 如何使用 Jackson 基于注释从对象中(反)序列化字段？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18659835/