Jacksonを使用してオブジェクトに未加工のJSONを含めるにはどうすればよいですか？

Jacksonを使用してオブジェクトが（非）シリアル化されるときに、Javaオブジェクト内に未加工のJSONを含めようとしています。この機能をテストするために、次のテストを作成しました。

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

@Test
public void test() throws JsonGenerationException, JsonMappingException, IOException {

    String foo = "one";
    String bar = "{\"A\":false}";

    Pojo pojo = new Pojo();
    pojo.foo = foo;
    pojo.bar = bar;

    String json = "{\"foo\":\"" + foo + "\",\"bar\":" + bar + "}";

    ObjectMapper objectMapper = new ObjectMapper();
    String output = objectMapper.writeValueAsString(pojo);
    System.out.println(output);
    assertEquals(json, output);

    Pojo deserialized = objectMapper.readValue(output, Pojo.class);
    assertEquals(foo, deserialized.foo);
    assertEquals(bar, deserialized.bar);
}

コードは次の行を出力します。

{"foo":"one","bar":{"A":false}}

JSONはまさに私が物事を見てほしい方法です。残念ながら、JSONをオブジェクトに読み込もうとすると、コードは例外で失敗します。ここに例外があります：

org.codehaus.jackson.map.JsonMappingException：[ソース：java.io.StringReader@d70d7a;のSTART_OBJECTトークンからjava.lang.Stringのインスタンスをデシリアライズできません。行：1、列：13]（参照チェーンを通じて：com.tnal.prism.cobalt.gather.testing.Pojo ["bar"]）

ジャクソンが一方向にうまく機能するのに、反対方向に移動すると失敗するのはなぜですか？それはそれ自身の出力を再び入力として受け取ることができるはずです。私がやろうとしていることは正統ではないことを知っていますが（一般的なアドバイスはbar、という名前のプロパティを持つ内部オブジェクトを作成することですA）、このJSONとはまったくやり取りしたくありません。私のコードはこのコードのパススルーとして機能しています-このJSONを取り込んで、何かに触れることなくもう一度送り返したいのです。

アドバイスありがとうございます。

編集：Pojoを静的クラスにしたため、別のエラーが発生していました。

@JsonRawValueは、逆方向を処理するのが少し難しいため、シリアライゼーション側のみを対象としています。実際には、事前にエンコードされたコンテンツを挿入できるようにするために追加されました。

それはかなり厄介ですが、逆のサポートを追加することは可能だと思います：コンテンツを解析してから、「raw」形式に書き直す必要があります。異なる場合があります）。これは一般的なケースです。しかし、おそらくそれは問題の一部のサブセットには意味があります。

しかし、私はあなたの特定のケースの回避策はタイプを「java.lang.Object」として指定することだと思います、これは問題なく動作するはずです：シリアライゼーションの場合、文字列はそのまま出力され、デシリアライゼーションの場合は次のようにデシリアライズされます地図。実際には、個別のゲッター/セッターが必要な場合があります。getterはシリアル化のためにStringを返します（そして@JsonRawValueが必要です）。セッターはマップまたはオブジェクトのいずれかを取ります。それが理にかなっている場合は、文字列に再エンコードできます。

@StaxManの回答に続いて、次のような作品を魅力的なものにしています。

public class Pojo {
  Object json;

  @JsonRawValue
  public String getJson() {
    // default raw value: null or "[]"
    return json == null ? null : json.toString();
  }

  public void setJson(JsonNode node) {
    this.json = node;
  }
}

そして、最初の質問に忠実であるために、ここに動作テストがあります：

public class PojoTest {
  ObjectMapper mapper = new ObjectMapper();

  @Test
  public void test() throws IOException {
    Pojo pojo = new Pojo("{\"foo\":18}");

    String output = mapper.writeValueAsString(pojo);
    assertThat(output).isEqualTo("{\"json\":{\"foo\":18}}");

    Pojo deserialized = mapper.readValue(output, Pojo.class);
    assertThat(deserialized.json.toString()).isEqualTo("{\"foo\":18}");
    // deserialized.json == {"foo":18}
  }
}

私はこれをカスタムデシリアライザ（ここからカットアンドペーストした）で行うことができました

package etc;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;

/**
 * Keeps json value as json, does not try to deserialize it
 * @author roytruelove
 *
 */
public class KeepAsJsonDeserialzier extends JsonDeserializer<String> {

    @Override
    public String deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {

        TreeNode tree = jp.getCodec().readTree(jp);
        return tree.toString();
    }
}

@JsonSetterが役立ちます。私のサンプルを参照してください（「データ」には解析されていないJSONが含まれているはずです）：

class Purchase
{
    String data;

    @JsonProperty("signature")
    String signature;

    @JsonSetter("data")
    void setData(JsonNode data)
    {
        this.data = data.toString();
    }
}

追加ロイするTrueloveの偉大な答えは、これはの出現に応じてカスタムデシリアライザを注入する方法です@JsonRawValue。

import com.fasterxml.jackson.databind.Module;

@Component
public class ModuleImpl extends Module {

    @Override
    public void setupModule(SetupContext context) {
        context.addBeanDeserializerModifier(new BeanDeserializerModifierImpl());
    }
}

import java.util.Iterator;

import com.fasterxml.jackson.annotation.JsonRawValue;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;

public class BeanDeserializerModifierImpl extends BeanDeserializerModifier {
    @Override
    public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) {
        Iterator<SettableBeanProperty> it = builder.getProperties();
        while (it.hasNext()) {
            SettableBeanProperty p = it.next();
            if (p.getAnnotation(JsonRawValue.class) != null) {
                builder.addOrReplaceProperty(p.withValueDeserializer(KeepAsJsonDeserialzier.INSTANCE), true);
            }
        }
        return builder;
    }
}

これは内部クラスの問題です。Pojoクラスは、非static内部クラステストクラスの、とジャクソンはないインスタンス化できるクラスという。したがって、シリアライズはできますが、デシリアライズはできません。

次のようにクラスを再定義します。

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

の追加に注意してください static

この簡単な解決策は私にとってうまくいきました：

public class MyObject {
    private Object rawJsonValue;

    public Object getRawJsonValue() {
        return rawJsonValue;
    }

    public void setRawJsonValue(Object rawJsonValue) {
        this.rawJsonValue = rawJsonValue;
    }
}

したがって、JSONの生の値をrawJsonValue変数に格納でき、それを（オブジェクトとして）他のフィールドで逆シリアル化してJSONに戻し、REST経由で送信しても問題ありませんでした。@JsonRawValueを使用しても役に立ちませんでした。格納されたJSONはオブジェクトではなく文字列としてデシリアライズされ、それが私が望んでいたものではなかったためです。

これはJPAエンティティでも機能します：

private String json;

@JsonRawValue
public String getJson() {
    return json;
}

public void setJson(final String json) {
    this.json = json;
}

@JsonProperty(value = "json")
public void setJsonRaw(JsonNode jsonNode) {
    // this leads to non-standard json, see discussion: 
    // setJson(jsonNode.toString());

    StringWriter stringWriter = new StringWriter();
    ObjectMapper objectMapper = new ObjectMapper();
    JsonGenerator generator = 
      new JsonFactory(objectMapper).createGenerator(stringWriter);
    generator.writeTree(n);
    setJson(stringWriter.toString());
}

理想的には、ObjectMapperおよびJsonFactoryもコンテキストからのものであり、JSONを正しく処理するように構成されています（標準または「Infinity」フロートなどの非標準の値を使用）。

以下は、Jacksonモジュールを使用して@JsonRawValue両方の方法（シリアライズとデシリアライズ）で機能させる方法の完全に機能する例です。

public class JsonRawValueDeserializerModule extends SimpleModule {

    public JsonRawValueDeserializerModule() {
        setDeserializerModifier(new JsonRawValueDeserializerModifier());
    }

    private static class JsonRawValueDeserializerModifier extends BeanDeserializerModifier {
        @Override
        public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) {
            builder.getProperties().forEachRemaining(property -> {
                if (property.getAnnotation(JsonRawValue.class) != null) {
                    builder.addOrReplaceProperty(property.withValueDeserializer(JsonRawValueDeserializer.INSTANCE), true);
                }
            });
            return builder;
        }
    }

    private static class JsonRawValueDeserializer extends JsonDeserializer<String> {
        private static final JsonDeserializer<String> INSTANCE = new JsonRawValueDeserializer();

        @Override
        public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
            return p.readValueAsTree().toString();
        }
    }
}

次に、作成後にモジュールを登録できますObjectMapper。

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new JsonRawValueDeserializerModule());

String json = "{\"foo\":\"one\",\"bar\":{\"A\":false}}";
Pojo deserialized = objectMapper.readValue(json, Pojo.class);

私はまったく同じ問題を抱えていました。私はこの投稿で解決策を見つけました： Jacksonまたはその代替を使用してJSONツリーをプレーンクラスに解析します

最後の答えをご覧ください。JsonNodeをパラメーターとして受け取り、jsonNodeのtoStringメソッドを呼び出してStringプロパティを設定するプロパティのカスタムセッターを定義することで、すべてが機能します。

オブジェクトを使用すると、どちらの方法でも問題なく動作します...この方法では、2回でraw値をデシリアライズするオーバーヘッドが少し発生します。

ObjectMapper mapper = new ObjectMapper();
RawJsonValue value = new RawJsonValue();
value.setRawValue(new RawHello(){{this.data = "universe...";}});
String json = mapper.writeValueAsString(value);
System.out.println(json);
RawJsonValue result = mapper.readValue(json, RawJsonValue.class);
json = mapper.writeValueAsString(result.getRawValue());
System.out.println(json);
RawHello hello = mapper.readValue(json, RawHello.class);
System.out.println(hello.data);

RawHello.java

public class RawHello {

    public String data;
}

RawJsonValue.java

public class RawJsonValue {

    private Object rawValue;

    public Object getRawValue() {
        return rawValue;
    }

    public void setRawValue(Object value) {
        this.rawValue = value;
    }
}

同様の問題がありましたが、多くのJSONイテンス（List<String>）を含むリストを使用しています。

public class Errors {
    private Integer status;
    private List<String> jsons;
}

@JsonRawValueアノテーションでシリアライズを管理しました。しかし、デシリアライゼーションのために、Royの提案に基づいてカスタムデシリアライザを作成する必要がありました。

public class Errors {

    private Integer status;

    @JsonRawValue
    @JsonDeserialize(using = JsonListPassThroughDeserialzier.class)
    private List<String> jsons;

}

以下に、「リスト」デシリアライザを示します。

public class JsonListPassThroughDeserializer extends JsonDeserializer<List<String>> {

    @Override
    public List<String> deserialize(JsonParser jp, DeserializationContext cxt) throws IOException, JsonProcessingException {
        if (jp.getCurrentToken() == JsonToken.START_ARRAY) {
            final List<String> list = new ArrayList<>();
            while (jp.nextToken() != JsonToken.END_ARRAY) {
                list.add(jp.getCodec().readTree(jp).toString());
            }
            return list;
        }
        throw cxt.instantiationException(List.class, "Expected Json list");
    }
}