Jackson将对象序列化为JSON到base64(无需无休止的循环)

问题描述 投票：0回答：2

有没有一种简单的方法可以将一个使用Jackson的对象序列化为base64编码的JSON？(object -> JSON -> base64)

我试着用一个自定义的 StdSerializer但这（当然）会导致无休止的循环。

class MySerializer extends StdSerializer<Foo> {
  public void serialize(Foo value, JsonGenerator gen, SerializerProvider provider) {
    StringWriter stringWriter = new StringWriter();
    JsonGenerator newGen = gen.getCodec().getFactory().createGenerator(stringWriter);
    gen.getCodec().getFactory().getCodec().writeValue(newGen, value);
    String json = stringWriter.toString();
    String base64 = new String(Base64.getEncoder().encode(json.getBytes()));
    gen.writeString(base64);
  }
}

一个变通的办法是将所有字段复制到另一个类中，并使用该类作为中间表示。

class TmpFoo {
  public String field1;
  public int field2;
  // ...
}

class MySerializer extends StdSerializer<Foo> {
  public void serialize(Foo value, JsonGenerator gen, SerializerProvider provider) {
    TmpFoo tmp = new TmpFoo();
    tmp.field1 = value.field1;
    tmp.field2 = value.field2;
    // etc.

    StringWriter stringWriter = new StringWriter();
    JsonGenerator newGen = gen.getCodec().getFactory().createGenerator(stringWriter);
    gen.getCodec().getFactory().getCodec().writeValue(newGen, tmp); // here "tmp" instead of "value"
    String json = stringWriter.toString();
    String base64 = new String(Base64.getEncoder().encode(json.getBytes()));
    gen.writeString(base64);
  }
}

创建一个 new ObjectMapper 是不需要的，因为我需要默认ObjectMapper的所有注册模块和序列器。

我希望有一些更简单的方法来实现这一点。

EDIT: 示例

步骤1：Java对象

class Foo {
  String field1 = "foo";
  int field2 = 42;
}

第二步：JSON

{"field1":"foo","field2":42}

第三步：Base64

eyJmaWVsZDEiOiJmb28iLCJmaWVsZDIiOjQyfQ==
java json jackson base64 jackson-databind
2个回答
2
投票

根据 本网站有一个变通方法可以避免这个递归问题。

当我们定义一个自定义序列化器时，Jackson会在内部覆盖原来的BeanSerializer实例[...]我们的SerializerProvider每次都会找到自定义序列化器，而不是默认序列化器，这将导致一个无限循环。

一个可能的变通方法是使用BeanSerializerModifier在Jackson内部覆盖它之前为Folder类型存储默认序列化器。

如果我对这个变通方法的理解正确，你的 Serializer 应该是这样的。

class FooSerializer extends StdSerializer<Foo> {

    private final JsonSerializer<Object> defaultSerializer;

    public FooSerializer(JsonSerializer<Object> defaultSerializer) {
        super(Foo.class);
        this.defaultSerializer = defaultSerializer;
    }

    @Override
    public void serialize(Foo value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        StringWriter stringWriter = new StringWriter();
        JsonGenerator tempGen = provider.getGenerator().getCodec().getFactory().createGenerator(stringWriter);
        defaultSerializer.serialize(value, tempGen, provider);

        tempGen.flush();

        String json = stringWriter.toString();
        String base64 = new String(Base64.getEncoder().encode(json.getBytes()));
        gen.writeString(base64);
    }
}

除了序列器之外，还需要一个修饰符。

public class FooBeanSerializerModifier extends BeanSerializerModifier {

    @Override
    public JsonSerializer<?> modifySerializer(
      SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) {

        if (beanDesc.getBeanClass().equals(Foo.class)) {
            return new FooSerializer((JsonSerializer<Object>) serializer);
        }
        return serializer;
    }
}

例子模块。

ObjectMapper mapper = new ObjectMapper();

SimpleModule module = new SimpleModule();
module.setSerializerModifier(new FooBeanSerializerModifier());

mapper.registerModule(module);

EDIT:

我已经添加了 flush() 冲刷 JsonGenerator tempGen.另外，我已经用JUnit创建了一个最小的测试环境，它可以用以下方法来验证你的示例 Foo: github repo可以找到 此处.

编辑：备选方案2

另一个（简单的）选择是使用一个带有generics的包装类。

public class Base64Wrapper<T> {

    private final T wrapped;

    private Base64Wrapper(T wrapped) {
        this.wrapped = wrapped;
    }

    public T getWrapped() {
        return this.wrapped;
    }

    public static <T> Base64Wrapper<T> of(T wrapped) {
        return new Base64Wrapper<>(wrapped);
    }
}

public class Base64WrapperSerializer extends StdSerializer<Base64Wrapper> {


    public Base64WrapperSerializer() {
        super(Base64Wrapper.class);
    }

    @Override
    public void serialize(Base64Wrapper value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        StringWriter stringWriter = new StringWriter();
        JsonGenerator tempGen = provider.getGenerator().getCodec().getFactory().createGenerator(stringWriter);
        provider.defaultSerializeValue(value.getWrapped(), tempGen);
        tempGen.flush();

        String json = stringWriter.toString();
        String base64 = new String(Base64.getEncoder().encode(json.getBytes()));
        gen.writeString(base64);
    }
}

一个用例是：

final ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addSerializer(new Base64WrapperSerializer());
mapper.registerModule(module);

final Foo foo = new Foo();
final Base64Wrapper<Foo> base64Wrapper = Base64Wrapper.of(foo);
final String base64Json = mapper.writeValueAsString(base64Wrapper);

这个例子可以在 这个GitHub (分支：wrapper)repo，用JUnit测试验证你的foo例子中的BASE64字符串。

1
投票

你可以不创建新的对象，而是将现有的对象转换成map。就像下面的例子

import static java.nio.charset.StandardCharsets.UTF_8;

public class FooSerializer extends StdSerializer<Foo> {

    public FooSerializer() {
        super(Foo.class);
    }

    @Override
    public void serialize(Foo foo, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) {
        try {
            ObjectMapper mapper = (ObjectMapper) jsonGenerator.getCodec();
            var map = toMap(foo); // if you need class info for deserialization than use toMapWithClassInfo
            String json = mapper.writeValueAsString(map);
            jsonGenerator.writeString(Base64.getEncoder().encodeToString(json.getBytes(UTF_8)));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static Map<String, Object> toMap(Object o) throws Exception {
        Map<String, Object> result = new HashMap<>();
        Field[] declaredFields = o.getClass().getDeclaredFields();
        for (Field field : declaredFields) {
            field.setAccessible(true);
            result.put(field.getName(), field.get(o));
        }
        return result;
    }


    public static Map<String, Object> toMapWithClassInfo(Object obj) throws Exception {
        Map<String, Object> result = new HashMap<>();
        BeanInfo info = Introspector.getBeanInfo(obj.getClass());
        for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
            Method reader = pd.getReadMethod();
            if (reader != null)
                result.put(pd.getName(), reader.invoke(obj));
        }
        return result;
    }
}

我提供了2种转换为地图的方法：有和没有类信息。选择一种，适用于你的问题。

0
投票

要序列化对象jackson搜索 @JsonValue 方法。您可以添加 encodedJsonString 注释的方法 @JsonValue 在 Foo 类。

用这个试试。

@Getter
@Setter
public class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    public String field1;
    public int field2;

    @JsonValue
    public String toEncodedJsonString() {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            new ObjectOutputStream(baos).writeObject(this);
            return org.apache.commons.codec.binary.Base64.encodeBase64String(baos.toByteArray());
        }catch (Exception ex){

        }
        return null;
    }
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.