POJO를 JSON으로 직렬화하는 serializer를 작성 중이지만 순환 참조 문제에 갇혀 있습니다. 최대 절전 모드 양방향 일대 다 관계에서 부모는 자식 및 자식 참조를 부모로 다시 참조하고 여기서 내 직렬 변환기가 죽습니다. (아래 예제 코드 참조)
이주기를 끊는 방법은 무엇입니까? 개체의 소유자 트리를 가져와 개체 자체가 소유자 계층의 어딘가에 있는지 확인할 수 있습니까? 참조가 순환되는지 확인하는 다른 방법이 있습니까? 또는이 문제를 해결하기위한 다른 아이디어가 있습니까?
답변:
양방향 관계를 JSON으로 표현할 수도 있습니까? 일부 데이터 형식은 일부 데이터 모델링 유형에 적합하지 않습니다.
순회 개체 그래프를 처리 할 때주기를 처리하는 한 가지 방법은 지금까지 본 개체를 추적하여 (ID 비교 사용) 무한주기를 통과하지 못하도록하는 것입니다.
이 기능을 사용하여 이러한 종류의 문제를 처리하기 위해 Google JSON 에 의존 합니다.
다음과 같이 A와 B 클래스 사이의 양방향 관계를 가정하십시오.
public class A implements Serializable {
private B b;
}
그리고 B
public class B implements Serializable {
private A a;
}
이제 GsonBuilder를 사용하여 다음과 같이 사용자 지정 Gson 개체를 가져옵니다 (Notice setExclusionStrategies 메서드).
Gson gson = new GsonBuilder()
.setExclusionStrategies(new ExclusionStrategy() {
public boolean shouldSkipClass(Class<?> clazz) {
return (clazz == B.class);
}
/**
* Custom field exclusion goes here
*/
public boolean shouldSkipField(FieldAttributes f) {
return false;
}
})
/**
* Use serializeNulls method if you want To serialize null values
* By default, Gson does not serialize null values
*/
.serializeNulls()
.create();
이제 순환 참조
A a = new A();
B b = new B();
a.setB(b);
b.setA(a);
String json = gson.toJson(a);
System.out.println(json);
GsonBuilder 클래스 살펴보기
Jackson 1.6 (2010 년 9 월 출시)에는 이러한 부모 / 자식 연결을 처리하기위한 특정 주석 기반 지원이 있습니다. http://wiki.fasterxml.com/JacksonFeatureBiDirReferences를 참조 하십시오 . ( 웨이 백 스냅 샷 )
물론 이미 대부분의 JSON 처리 패키지 (jackson, gson 및 flex-json이 지원)를 이미 사용하고있는 상위 링크의 직렬화를 제외 할 수 있지만 실제 트릭은 다시 직렬화 (상위 링크 다시 생성)하는 방법이 아닙니다. 직렬화 측면을 처리하십시오. 지금은 제외가 효과가있을 수 있습니다.
편집 (2012 년 4 월) : Jackson 2.0은 이제 진정한 ID 참조 ( Wayback Snapshot )를 지원 하므로이 방법으로도 해결할 수 있습니다.
이 문제를 해결하기 위해 다음과 같은 접근 방식을 취했습니다 (애플리케이션 전체에서 프로세스를 표준화하여 코드를 명확하고 재사용 가능하게 함).
코드는 다음과 같습니다.
1)
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface GsonExclude {
}
2)
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
public class GsonExclusionStrategy implements ExclusionStrategy{
private final Class<?> typeToExclude;
public GsonExclusionStrategy(Class<?> clazz){
this.typeToExclude = clazz;
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
return ( this.typeToExclude != null && this.typeToExclude == clazz )
|| clazz.getAnnotation(GsonExclude.class) != null;
}
@Override
public boolean shouldSkipField(FieldAttributes f) {
return f.getAnnotation(GsonExclude.class) != null;
}
}
삼)
static Gson createGsonFromBuilder( ExclusionStrategy exs ){
GsonBuilder gsonbuilder = new GsonBuilder();
gsonbuilder.setExclusionStrategies(exs);
return gsonbuilder.serializeNulls().create();
}
4)
public class MyObjectToBeSerialized implements Serializable{
private static final long serialVersionID = 123L;
Integer serializeThis;
String serializeThisToo;
Date optionalSerialize;
@GsonExclude
@ManyToOne(fetch=FetchType.LAZY, optional=false)
@JoinColumn(name="refobj_id", insertable=false, updatable=false, nullable=false)
private MyObjectThatGetsCircular dontSerializeMe;
...GETTERS AND SETTERS...
}
5)
첫 번째 경우 생성자에 null이 제공되며 제외 할 다른 클래스를 지정할 수 있습니다. 두 옵션 모두 아래에 추가됩니다.
Gson gsonObj = createGsonFromBuilder( new GsonExclusionStrategy(null) );
Gson _gsonObj = createGsonFromBuilder( new GsonExclusionStrategy(Date.class) );
6)
MyObjectToBeSerialized _myobject = someMethodThatGetsMyObject();
String jsonRepresentation = gsonObj.toJson(_myobject);
또는 Date 개체를 제외하려면
String jsonRepresentation = _gsonObj.toJson(_myobject);
Jackon을 사용하여 직렬화하는 경우 @JsonBackReference 를 양방향 매핑에 적용 하면 순환 참조 문제가 해결됩니다.
참고 : @JsonBackReference는 무한 재귀 (StackOverflowError)를 해결하는 데 사용됩니다.
@JsonIgnore의 나 만들어 JpaRepository속성을 매핑하는 데 실패하지만 @JsonBackReference여전히 순환 참조를 해결하고 문제가있는 속성에 대한 적절한 매핑을 허용
스프링 부트를 사용하는 경우 Jackson은 순환 / 양방향 데이터에서 응답을 생성하는 동안 오류가 발생하므로
안녕하세요.
순환 성을 무시하다
At Parent:
@OneToMany(mappedBy="dbApp")
@JsonIgnoreProperties("dbApp")
private Set<DBQuery> queries;
At child:
@ManyToOne
@JoinColumn(name = "db_app_id")
@JsonIgnoreProperties("queries")
private DBApp dbApp;
Javascript를 사용하는 경우, 기본 직렬화 동작을 수정하는 함수를 전달할 수있는 method replacer매개 변수 를 사용하는 것에 대한 매우 쉬운 솔루션 JSON.stringify()이 있습니다.
사용 방법은 다음과 같습니다. 순환 그래프에 4 개의 노드가있는 아래 예제를 고려하십시오.
// node constructor
function Node(key, value) {
this.name = key;
this.value = value;
this.next = null;
}
//create some nodes
var n1 = new Node("A", 1);
var n2 = new Node("B", 2);
var n3 = new Node("C", 3);
var n4 = new Node("D", 4);
// setup some cyclic references
n1.next = n2;
n2.next = n3;
n3.next = n4;
n4.next = n1;
function normalStringify(jsonObject) {
// this will generate an error when trying to serialize
// an object with cyclic references
console.log(JSON.stringify(jsonObject));
}
function cyclicStringify(jsonObject) {
// this will successfully serialize objects with cyclic
// references by supplying @name for an object already
// serialized instead of passing the actual object again,
// thus breaking the vicious circle :)
var alreadyVisited = [];
var serializedData = JSON.stringify(jsonObject, function(key, value) {
if (typeof value == "object") {
if (alreadyVisited.indexOf(value.name) >= 0) {
// do something other that putting the reference, like
// putting some name that you can use to build the
// reference again later, for eg.
return "@" + value.name;
}
alreadyVisited.push(value.name);
}
return value;
});
console.log(serializedData);
}
나중에 직렬화 된 데이터를 구문 분석 하고이 예제에서 비슷한 next이름의 참조를 사용하는 경우 실제 객체를 가리 키도록 속성을 수정하여 순환 참조가있는 실제 객체를 쉽게 다시 만들 수 있습니다 @.
이것이 제 경우에 마침내 해결 한 방법입니다. 이것은 적어도 Gson & Jackson과 함께 작동합니다.
private static final Gson gson = buildGson();
private static Gson buildGson() {
return new GsonBuilder().addSerializationExclusionStrategy( getExclusionStrategy() ).create();
}
private static ExclusionStrategy getExclusionStrategy() {
ExclusionStrategy exlStrategy = new ExclusionStrategy() {
@Override
public boolean shouldSkipField(FieldAttributes fas) {
return ( null != fas.getAnnotation(ManyToOne.class) );
}
@Override
public boolean shouldSkipClass(Class<?> classO) {
return ( null != classO.getAnnotation(ManyToOne.class) );
}
};
return exlStrategy;
}
이 오류는 두 개의 개체가있을 때 나타날 수 있습니다.
class object1{
private object2 o2;
}
class object2{
private object1 o1;
}
직렬화에 GSon을 사용하면 다음 오류가 발생합니다.
java.lang.IllegalStateException: circular reference error
Offending field: o1
이 문제를 해결하려면 transient 키워드를 추가하십시오.
class object1{
private object2 o2;
}
class object2{
transient private object1 o1;
}
여기에서 볼 수 있듯이 Java에는 왜 임시 필드가 있습니까?
Java의 transient 키워드는 필드가 직렬화되지 않아야 함을 표시하는 데 사용됩니다.
대답 번호 8이 더 낫다고 생각합니다. 어떤 필드가 오류를 던지고 있는지 알고 있다면 필드를 null로 설정하고 해결했습니다.
List<RequestMessage> requestMessages = lazyLoadPaginated(first, pageSize, sortField, sortOrder, filters, joinWith);
for (RequestMessage requestMessage : requestMessages) {
Hibernate.initialize(requestMessage.getService());
Hibernate.initialize(requestMessage.getService().getGroupService());
Hibernate.initialize(requestMessage.getRequestMessageProfessionals());
for (RequestMessageProfessional rmp : requestMessage.getRequestMessageProfessionals()) {
Hibernate.initialize(rmp.getProfessional());
rmp.setRequestMessage(null); // **
}
}
코드를 읽기 쉽게 만들기 위해 큰 주석이 주석 // **에서 아래 로 이동되었습니다 .
java.lang.StackOverflowError [요청 처리 실패; 중첩 된 예외는 org.springframework.http.converter.HttpMessageNotWritableException : JSON을 쓸 수 없음 : 무한 재귀 (StackOverflowError) (참조 체인을 통해 : com.service.pegazo.bo.RequestMessageProfessional [ "requestMessage"]-> com.service.pegazo. bo.RequestMessage [ "requestMessageProfessionals"]