잭슨을 사용하여 오브젝트에 raw JSON을 포함하려면 어떻게 해야 합니까?

잭슨을 사용하여 오브젝트에 raw JSON을 포함하려면 어떻게 해야 합니까?

Jackson을 사용하여 오브젝트를 시리얼화(해제)할 때 Java 오브젝트 내에 raw 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.codehouse.map 입니다.Json Mapping Exception:java.lang 인스턴스를 역직렬화할 수 없습니다.START_OBJECT 토큰을 [출처: java.io]에서 문자열로 출력합니다.StringReader@d70d7a; 줄: 1, 열: 13](참조 체인: com.tnal.prism.covalt.gather.testing 경유).Pojo["바"]

잭슨은 왜 한쪽 방향에서는 잘 기능하지만 다른 방향으로 갈 때는 실패하는 걸까요?자체 출력을 다시 입력으로 받아들일 수 있을 것 같습니다.제가 하려는 것이 비정통적이라는 것을 알고 있습니다(일반적인 조언은 이 안에 있는 오브젝트를 만드는 것입니다).bar라는 이름의 속성을 가진A이 JSON과는 전혀 대화하고 싶지 않습니다.이 코드는 이 코드의 패스스루로서 기능하고 있습니다.JSON이 변경되었을 때 코드를 변경할 필요가 없기 때문에, 이 JSON을 도입해, 아무것도 만지지 않고 재발송신하고 싶습니다.

조언해 주셔서 고마워요.

EDIT: Pojo를 정적 클래스로 설정했습니다.그 때문에, 다른 에러가 발생했습니다.

@JsonRawValue는 시리얼라이제이션측에서만 사용할 수 있습니다.이는 역방향은 처리하기가 좀 어렵기 때문입니다.실제로 사전 인코딩된 콘텐츠를 주입할 수 있도록 추가되었다.

리버스 서포트를 추가하는 것은 매우 곤란합니다만, 내용을 해석하고 나서, 같은 형식인지 아닌지를 불문하고 「raw」형식으로 다시 쓸 필요가 있습니다(문자의 인용이 다를 수 있기 때문입니다.일반적인 경우입니다.그러나 일부 문제에 대해서는 이치에 맞을 수 있습니다.

다만, 특정의 경우의 회피책은, 타입을 「java.lang」으로 지정하는 것이라고 생각합니다.오브젝트'는 시리얼라이제이션에서는 스트링이 그대로 출력되고 시리얼라이제이션에서는 맵으로 디시리얼라이제이션됩니다.실제로 다른 getter/setter가 필요한 경우 getter는 시리얼라이제이션용으로 String을 반환하고(및 @JsonRawValue 필요), setter는 Map 또는 Object 중 하나를 사용합니다.타당하다면 String으로 다시 인코딩할 수 있습니다.

@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 KeepAsJsonDeserializer extends JsonDeserializer<String> {
    
    @Override
    public String deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException {
        
        TreeNode tree = jp.getCodec().readTree(jp);
        return tree.toString();
    }
}

다음과 같이 원하는 멤버에 주석을 달아 사용합니다.

@JsonDeserialize(using = KeepAsJsonDeserializer.class)
private String value;

@JsonSetter가 도움이 될 수 있습니다.샘플 참조('데이터'에는 파싱되지 않은 JSON이 포함되어 있어야 함):

class Purchase
{
    String data;

    @JsonProperty("signature")
    String signature;

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

이치노Pojoclass는 테스트클래스의 스태틱하지 않은 내부 클래스이며, 잭슨은 그 클래스를 인스턴스화할 수 없습니다.즉, 시리얼화는 할 수 있지만, 역직렬화는 할 수 없습니다.

클래스를 다음과 같이 재정의합니다.

public static class Pojo {
    public String foo;

    @JsonRawValue
    public String bar;
}

「 」의 에 주의해 .static

Roy 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;
    }
}

다음과 같은 간단한 솔루션이 도움이 되었습니다.

public class MyObject {
    private Object rawJsonValue;

    public Object getRawJsonValue() {
        return rawJsonValue;
    }

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

그래서 rawJsonValue 변수에 JSON의 raw값을 저장할 수 있었고, 그 후 다른 필드와 함께 (개체로) 역직렬화하여 REST를 통해 전송해도 문제가 없었습니다.저장된 JSON이 오브젝트가 아닌 String으로 역직렬화 되어 있어서 @JsonRawValue를 사용해도 도움이 되지 않았습니다.

이것은 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());
}

Object Mapper 및 Json Factory가 컨텍스트에서 생성되어 JSON을 올바르게 처리하도록 구성되는 것이 이상적입니다(표준 또는 'Infinity'와 같은 비표준 값을 사용하여 플로팅됨).

은 잭슨 하여 잭슨을 만드는 를 보여 .@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);

나도 똑같은 문제가 있었어.이 투고에서 해결책을 찾았습니다.잭슨 또는 그 대체를 사용하여 JSON 트리를 플레인 클래스로 해석합니다.

마지막 정답을 보세요.JsonNode를 파라미터로 사용하여 jsonNode의 toString 메서드를 호출하여 String 속성을 설정하는 속성의 커스텀세터를 정의하면 모든 것이 잘 됩니다.

오브젝트를 사용하는 것은 양쪽 모두 효과가 있습니다.이 메서드에서는 raw 값을 2회만에 역직렬화하는 데 약간의 오버헤드가 있습니다.

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이 (JSON)를사용하고 있습니다.List<String>를 참조해 주세요.

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

는 '하다'를 사용해서 를 관리했습니다.@JsonRawValue주석입니다.하지만 탈직렬화를 위해 로이의 제안에 따라 맞춤 탈직렬화기를 만들어야 했습니다.

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

언급URL : https://stackoverflow.com/questions/4783421/how-can-i-include-raw-json-in-an-object-using-jackson