Question

我想在JSON序列化之前更改对象。为此，我已经使用change方法创建了一个接口，任何实现此接口的类都将尝试＆＃34;尝试＆＃34;改变自己。（是的，可能这样做不是最优的，但例如为了清酒会）

@JsonSerialize(using = ChangesValuesSerializer.class)
public interface ChangesValues {
    void changeValues();
}

现在，ChangesValuesSerializer我是{I}实施serialize方法。并想知道，我怎么能说杰克逊，把它称为对象内置的序列化器。

class ChangesValuesSerializer extends JsonSerializer<ChangesValues> {

    @Override
    public void serialize(ChangesValues changesValues, JsonGenerator jsonGenerator,
            SerializerProvider serializerProvider) throws IOException,
            JsonProcessingException {

        changesValues.changeValues();

        // ***
        // ->> Just call Jacksons default serializer
        // ***
    }

}

Answer 1

您可以使用BeanSerializerModifier来访问默认的序列化程序，并使用您自己的委托覆盖它。在委托内，您可以更改序列化对象并调用默认序列化程序。这是一个例子：

public class JacksonSerializeModifier {
    public static class Bean {
        public final String value;

        public Bean(final String value) {
            this.value = value;
        }

        public void foo() {
            System.out.println("foo() invoked");
        }
    }

    private static class MyBeanSerializerModifier extends BeanSerializerModifier {
        @Override
        public JsonSerializer<?> modifySerializer(
                final SerializationConfig serializationConfig,
                final BeanDescription beanDescription,
                final JsonSerializer<?> jsonSerializer) {
            return new ModifyingSerializer((JsonSerializer<Object>) jsonSerializer);
        }
    }

    private static class ModifyingSerializer extends JsonSerializer<Object> {
        private final JsonSerializer<Object> serializer;

        public ModifyingSerializer(final JsonSerializer<Object> jsonSerializer) {
            this.serializer  = jsonSerializer;
        }

        @Override
        public void serialize(
                final Object o,
                final JsonGenerator jsonGenerator,
                final SerializerProvider serializerProvider)
        throws IOException {
            if (o instanceof Bean) {
                ((Bean) o).foo();
            }
            serializer.serialize(o, jsonGenerator, serializerProvider);
        }
    }

    public static void main(String[] args) throws JsonProcessingException {
        SimpleModule module = new SimpleModule();
        module.setSerializerModifier(new MyBeanSerializerModifier());
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(module);
        System.out.println(mapper.writeValueAsString(new Bean("abc")));
    }
}

输出：

foo() invoked
{"value":"abc"}

Answer 2

如果是抽象类，这是不可行的。

你可以通过添加另一个扩展JSON序列化程序的类（即BasicJSONSerializer）并从那里调用方法来绕过它。即。

class BasicJSONSerializer extends JsonSerializer<ChangesValues> {}

class ChangesValuesSerializer extends JsonSerializer<ChangesValues> {

    @Override
    public void serialize(ChangesValues changesValues, JsonGenerator jsonGenerator,
        SerializerProvider serializerProvider) throws IOException,
        JsonProcessingException {

        changesValues.changeValues();

        new BasicJSONSerializer().serialize(changesValues, jsonGenerator, serializerProvider);
    }
}

但这似乎是一个黑客，老实说，可能需要一个更好的设计。

在JSON序列化之前更改对象

2 个答案: