如何配置 Jackson 将 Longs 序列化为字符串，而不是整数或双精度数？

Question

我们之前使用的框架（云端点）会自动将 java.lang.Long 序列化为 JSON 字符串（同时将整数和双精度数保留为 JSON 数字）。我们正在迁移以使用更标准的 Jackson 序列化框架。

为了向后兼容，我们需要 Jackson 能够将 Long 序列化为字符串，同时默认将整数和双精度数保留为 JSON 数字。我没有看到杰克逊有任何功能可以做到这一点。这可能吗？

Answer 1

为Long.class 和long.class 使用自定义序列化程序：

public static class LongSerializer extends JsonSerializer<Long> {
    @Override
    public void serialize(Long value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeString(value.toString());
    }
}

public static class LongDeserializer extends JsonDeserializer<Long> {
    @Override
    public Long deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        return p.getValueAsLong();
    }
}

您需要将它们注册到您的映射器：

public static void main(String[] args) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();

    SimpleModule module = new SimpleModule();
    module.addSerializer(long.class, new LongSerializer());
    module.addSerializer(Long.class, new LongSerializer());
    module.addDeserializer(long.class, new LongDeserializer());
    module.addDeserializer(Long.class, new LongDeserializer());
    objectMapper.registerModule(module);

    Test test = new Test();
    String json = objectMapper.writeValueAsString(test);
    System.out.println(json);
}

Answer 2

选项 1. 自定义序列化程序

@teppic 答案应该适用于大多数情况，但是

1. 您不需要自定义反序列化程序。默认的反序列化器可以处理 String => long

2. 可以使用com.fasterxml.jackson.databind.ser.std.ToStringSerializer序列化器

   module.addSerializer(Long.class, ToStringSerializer.instance);
   module.addSerializer(long.class, ToStringSerializer.instance);
   

3. 您会遇到边缘情况，因为自定义序列化器方法实际上无法处理另一个自定义序列化器使用 this JsonGenerator method 的情况

   (JsonGenerator) g.writeNumber((long)value);
   

   这里最重要的边缘情况是long[].class

   static class MyBean {
       long val = 1;        // works fine "1"
       Long val2 = 2L;      // works fine "2"
       long[] vals = {1,2}; // doesn't work [1,2]
   }
   

其实你可以

public static void main(String[] args) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    SimpleModule module = new SimpleModule();
    module.addSerializer(Long.class, ToStringSerializer.instance);
    module.addSerializer(long.class, ToStringSerializer.instance);
    module.addSerializer(long[].class, new JsonSerializer<long[]>(){
        @Override
        public final void serialize(
                long[] value, JsonGenerator g, SerializerProvider provider)
                throws IOException {

            g.writeStartArray();
            for (int i = 0, len = value.length; i < len; ++i) 
                g.writeString(String.valueOf(value[i]));

            g.writeEndArray();
        }
    });

    // register every other serializers that use 
    // (JsonGenerator) g.writeNumber((long)value); 
    // like AtomicLong, if you use it in your code

    mapper.registerModule(module);

    MyBean bean = new MyBean();
    String json = mapper.writeValueAsString(bean);
    MyBean myBean2 = mapper.readValue(json, MyBean.class);

    System.out.println(json);
    System.out.println(myBean2);
    System.out.println(mapper.writeValueAsString(myBean2));
}

---

选项 2. 自定义 JsonFactory 和 JsonGenerator

但话又说回来，这对你来说足够了吗，你确定没有人会尝试使用jsonGenerator.writeNumber(long) 还是你有其他的类，实际上默认使用它？因此，100% 可行的解决方案是在 ObjectMapper 上注册自定义 JsonFactory，并使用 2 个重写方法 _createGenerator 和 _createUTF8Generator

JsonFactory factory =  new JsonFactory(){
    @Override
    protected JsonGenerator _createGenerator(Writer out, IOContext ctxt)
            throws IOException {
        WriterBasedJsonGenerator gen = new WriterBasedJsonGenerator(ctxt,
                _generatorFeatures, _objectCodec, out){
            @Override
            public void writeNumber(long l) throws IOException {
                writeString(String.valueOf(l));
            }
        };
        return _internalSuperSetup(gen);
    }

    @Override
    protected JsonGenerator _createUTF8Generator(OutputStream out, IOContext ctxt)
            throws IOException {
        UTF8JsonGenerator gen = new UTF8JsonGenerator(ctxt,
                _generatorFeatures, _objectCodec, out){
            @Override
            public void writeNumber(long l) throws IOException {
                writeString(String.valueOf(l));
            }
        };
        return _internalSuperSetup(gen);
    }

    // reuse code from _createUTF8Generator and _createGenerator super methods
    private JsonGenerator _internalSuperSetup(JsonGenerator gen){
        if (_characterEscapes != null) gen.setCharacterEscapes(_characterEscapes);
        SerializableString rootSep = _rootValueSeparator;
        if (rootSep != DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR) 
            gen.setRootValueSeparator(rootSep);
        return gen;
    }
};
ObjectMapper mapper = new ObjectMapper(factory);