Question

所以，标题基本上描述了我需要的东西。比如，要序列化的bean看起来像这样：

public class SomeBean {
    public String someString;
}

我希望杰克逊像这样序列化 SomeBean 的一个实例：

{
    someString: '<the value>',
    __hash_someString: '<a proprietary hash of <the value>>'
}

此功能应该是通用的。我不想为 SomeBean 编写特定的序列化程序，因为这需要在多个位置进行。不能将“ __ hash_someString ”添加到类本身，因为它会污染模型。

实施

我希望杰克逊能正常处理豆子。但是当遇到特定的注释（ @GenerateHash ）时，它应该像之前一样向对象添加另一个字段。所以它想这样：

public class SomeBean {
    @GenerateHash
    public String someString;
}

到目前为止的道路

有很多类似的主题，但没有一个尝试这样的事情。我并没有真正进入Jackson Serialization的内部工作，但似乎你只能选择修改一个整体的对象。我还没有找到一种方法来拦截字段的序列化过程，只有该字段的值。

我尝试使用 BeanSerializerModifier 实现此功能，并尝试使用@Serializer进行一些操作。但是，我通常会陷入无限循环。

我咨询的资源是（不限于）：

简而言之 我怎样才能让杰克逊序列化

public class SomeBean {
    @GenerateHash
    public String someString;

    public String unaffectedString;
}

到此：

{
    someString: '<the value>',
    __hash_someString: '<a proprietary hash of <the value>>',
    unaffectedString: '<some value>'
}

Answer 1

这非常有趣。我想你可以用BeanSerializerModifier解决这个问题。

这个想法是注册一个自定义序列化程序，它可以访问原始的bean序列化程序，属性描述和对象值。如果使用GenerateHash注释对属性进行注释，则序列化程序将发出一个附加字段。这是一个例子：

public class JacksonGenerateHash {
    @Retention(RetentionPolicy.RUNTIME)
    public static @interface GenerateHash {
    }

    public static class Bean {
        @GenerateHash
        public final String value;

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

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

    private static class HashGeneratingSerializer extends JsonSerializer<Object>
            implements ContextualSerializer {
        private final JsonSerializer<Object> serializer;
        private final BeanProperty property;

        public HashGeneratingSerializer(
                final JsonSerializer<Object> jsonSerializer,
                final BeanProperty property) {
            this.serializer  = jsonSerializer;
            this.property = property;
        }

        @Override
        public void serialize(
                final Object o,
                final JsonGenerator jsonGenerator,
                final SerializerProvider serializerProvider)
        throws IOException {
            serializer.serialize(o, jsonGenerator, serializerProvider);
            // if the generatehash is present the property must be set
            if (property != null) {
               jsonGenerator.writeNumberField("_hash_" + property.getName(), o.hashCode());
            }
        }
        // override this method to access the bean property
        @Override
        public JsonSerializer<?> createContextual(
                final SerializerProvider prov, final BeanProperty property)
                throws JsonMappingException {
            if (property != null && property.getAnnotation(GenerateHash.class) != null) {
                return new HashGeneratingSerializer(serializer, property);
            }
            return serializer;
        }
    }

    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")));
    }
}

输出：

{"value":"abc","_hash_value":96354}

杰克逊用另一个字段的哈希添加自定义字段

1 个答案: