使Jackson反序列化为没有setter或constructor的私有字段

Question

我成功地将Jackson配置为序列化一个类，而不在类内部的私有字段上使用任何getter或注释

objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);

但我无法使这个非静态类的JSON字符串反序列化为一个没有任何参数化构造函数或设置器的对象。这是不是可能的--我想应该通过思考，但我不知道具体是怎么...

这里有两个测试，需要通过，以达到我的需要：

public class ObjectMapperTest {

    private ObjectMapper mapper;

    @Before
    public void init() {
        mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
    }

    @Test
    public void serialize() throws Exception {
        Payload payloadToSerialize = new Payload();
        payloadToSerialize.data = "testData";
        String serializedPayload = mapper.writeValueAsString(payloadToSerialize);
        assertThat(serializedPayload, is("{\"data\":\"testData\"}"));
        // --> OK
    }

    @Test
    public void deserialize() throws Exception {
        Payload deserializedPayload = mapper.readValue("{\"data\":\"testData\"}", Payload.class);
        assertThat(deserializedPayload.data, is("testData"));
        // com.fasterxml.jackson.databind.JsonMappingException:
        // No suitable constructor found for type [simple type, class ...ObjectMapperTest$Payload]:
        // can not instantiate from JSON object (missing default constructor or creator, or perhaps need to add/enable type information?)
        // at [Source: {"data":"testData"}; line: 1, column: 2]
    }

    public class Payload {

        private String data;

        public Payload() {
            // empty constructor for Jackson
        }
    }
}

Answer 1

您可以编写自己的反序列化器来解析JSON并创建payload的实例，然后使用反射设置data值。示例：

@Before
public void init() {
    mapper = new ObjectMapper();
    mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
    mapper.registerModule(
        new SimpleModule()
        .addDeserializer(Payload.class, new JsonDeserializer<Payload>() {
            @Override
            public Payload deserialize(JsonParser parser, DeserializationContext ctx)
                throws IOException, JsonProcessingException {
                JsonNode obj = parser.readValueAsTree(); // Read the JSON as a node

                Payload payload = new Payload();
                if (obj.isObject() && obj.has("data")) { // The node is an object and has a "data" field
                    try {
                        // Use reflection to set the value
                        Field dataField = payload.getClass().getDeclaredField("data");
                        dataField.setAccessible(true);
                        dataField.set(payload, obj.get("data").asText());
                    } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException ex) {
                        throw new IOException("Reflection error", ex);
                    }
                }
                return payload;
            }
        }));
}

编辑：如果您想要一些更“通用”的东西，您可以尝试自己创建实例并更改所有字段的可访问性。然后告诉Jackson使用JSON更新值。

public <T> T deserialize(final String json, final T instance) throws Exception {
    for (Field field : instance.getClass().getDeclaredFields()) {
        field.setAccessible(true);
    }
    mapper.readerForUpdating(instance).readValue(json);
    return instance;
}


@Test
public void deserializeUpdate() throws Exception {
    Payload deserializedPayload = deserialize("{\"data\":\"testData\"}", new Payload());
    assertThat(deserializedPayload.data, is("testData"));
}

我在你的有效负载类上测试了这个，也许它在更复杂的对象上不起作用。