Як вирішити циклічне посилання в json-серіалізаторі, викликане сплячим двонаправленим відображенням?

Я пишу серіалізатор для серіалізації POJO до JSON, але застряг у круговій проблемі посилань. У сплячому двонаправленому відношенні "один до багатьох" батьки посилаються на дочірні та дочірні посилання на батьківського, і тут мій серіалізатор помирає. (див. приклад коду нижче)
Як розірвати цей цикл? Чи можемо ми отримати дерево власника об’єкта, щоб побачити, чи існує сам об’єкт десь у його власній ієрархії власників? Будь-який інший спосіб дізнатись, чи посилання буде круговим? чи будь-яка інша ідея вирішити цю проблему?

Чи може двонаправлений взаємозв'язок бути представлений у JSON? Деякі формати даних не підходять для деяких типів моделювання даних.

Одним із методів роботи з циклами при роботі з графіками об’їздів об’єктів є відстеження об’єктів, які ви бачили до цього часу (за допомогою порівняння ідентичності), щоб запобігти собі об’їзду нескінченного циклу.

Я покладаюсь на Google JSON, щоб вирішити подібні проблеми за допомогою функції

Виключення полів із серіалізації та десеріалізації

Припустимо, двосторонній зв’язок між класами A та B наступним чином

public class A implements Serializable {

    private B b;

}

І Б

public class B implements Serializable {

    private A a;

}

Тепер використовуйте GsonBuilder, щоб отримати власний об'єкт Gson наступним чином (Зауважте метод 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 р.) Має спеціальну підтримку на основі анотацій для обробки таких батьківських / дочірніх зв'язків, див. Http://wiki.fasterxml.com/JacksonFeatureBiDirReferences . ( Знімок шляху )

Звичайно, ви вже можете виключити серіалізацію батьківського посилання, використовуючи більшість пакетів обробки JSON (jackson, gson та flex-json, принаймні, підтримують це), але справжня хитрість полягає в тому, як десеріалізувати його назад (повторно створити батьківське посилання) просто обробляйте сторону серіалізації. Хоча на сьогодні звучить так, що просто виключення може для вас спрацювати.

EDIT (квітень 2012 р.): Jackson 2.0 тепер підтримує справжні посилання на ідентичність ( Wayback Snapshot ), тому ви можете вирішити це також таким чином.

Вирішуючи цю проблему, я застосував наступний підхід (стандартизуючи процес у моїй програмі, зробивши код зрозумілим та багаторазовим):

1. Створіть клас анотацій для використання у полях, які ви хочете виключити
2. Визначте клас, який реалізує інтерфейс Google ExclusionStrategy
3. Створіть простий метод генерування об’єкта GSON за допомогою GsonBuilder (подібно до пояснення Артура)
4. Помітьте поля, які потрібно виключити, за потреби
5. Застосуйте правила серіалізації до об’єкта com.google.gson.Gson
6. Серіалізуйте свій об’єкт

Ось код:

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

}

3)

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)

Використовував рішення, подібне до рішення Артура, але замість нього setExclusionStrategiesя використовував

Gson gson = new GsonBuilder()
                .excludeFieldsWithoutExposeAnnotation()
                .create();

і використовував @Exposeанотацію gson для полів, які мені потрібні в json, інші поля виключаються.

якщо ви використовуєте весняне завантаження, Джексон видає помилку під час створення відповіді з кругових / двонаправлених даних, тому використовуйте

@JsonIgnoreProperties

ігнорувати циркулярність

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, це дуже просте рішення, використовуючи 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

Щоб вирішити це, просто додайте ключове слово перехідний:

class object1{
    private object2 o2;
}

class object2{
    transient private object1 o1;
}

Як ви можете бачити тут: Чому Java має перехідні поля?

Перехідне ключове слово в Java використовується для позначення того, що поле не повинно бути серіалізованим.

Джексон надає JsonIdentityInfoанотації для запобігання круговим посиланням. Ви можете перевірити підручник тут .

Якщо ви використовуєте GSON для перетворення класу Java в JSON, ви можете уникнути полів, що викликають циклічну посилання та інфінітивний цикл, вам потрібно лише помістити анотацію @Expose у поля, які ви хочете відобразити в JSON, а поля без анотація @Expose не відображається в JSON.

Циклічне посилання з'являється, наприклад, якщо ми намагаємося серіалізувати клас User за допомогою польових маршрутів класу Route, а клас Route має польового користувача класу User, то GSON намагається серіалізувати клас User і при спробі серіалізувати маршрути, серіалізувати клас Route і в класі Route спробувати серіалізувати польового користувача, і знову спробувати серіалізувати клас User, є кругова посилання, що провокує інфінітивний цикл. Я показую згаданий клас User and Route.

import com.google.gson.annotations.Expose;

Користувач класу

@Entity
@Table(name = "user")
public class User {
    
@Column(name = "name", nullable = false)
@Expose
private String name;

@OneToMany(mappedBy = "user", fetch = FetchType.EAGER)
@OnDelete(action = OnDeleteAction.CASCADE)
private Set<Route> routes;

@ManyToMany(fetch = FetchType.EAGER)
@OnDelete(action = OnDeleteAction.CASCADE)
@JoinTable(name = "like_", joinColumns = @JoinColumn(name = "id_user"),
        inverseJoinColumns = @JoinColumn(name = "id_route"),
        foreignKey = @ForeignKey(name = ""),
        inverseForeignKey = @ForeignKey(name = ""))
private Set<Route> likes;

Класний маршрут

  @Entity
  @Table(name = "route")
  public class Route {
      
  @ManyToOne()
  @JoinColumn(nullable = false, name = "id_user", foreignKey = 
  @ForeignKey(name = "c"))    
  private User user;

Щоб уникнути інфінітивного циклу, ми використовуємо анотацію @Expose, що пропонує GSON.

Я показую у форматі JSON результат серіалізації за допомогою GSON класу User.

{
    "name": "ignacio"  
}

Ми бачимо, що маршрут поля та лайки не існують у форматі JSON, лише назва поля. Через це кругового посилання уникати.

Якщо ми хочемо цим скористатися, ми повинні створити об'єкт GSON певним чином.

Gson converterJavaToJson = new GsonBuilder().setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().create();

Врешті-решт, ми перетворюємо Java-клас моделі сплячого користувача за допомогою створеного перетворювача GSON.

 User user = createUserWithHibernate();
 String json = converterJavaToJson.toJson(user);

відповідь номер 8 тим краще, я думаю, так що якщо ви знаєте, яке поле видає помилку, ви лише встановлюєте fild в 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.zoserservice. bo.RequestMessage ["requestMessageProfessionals"]

Наприклад, ProductBean має serialBean. Картографування було б двонаправленим. Якщо ми зараз спробуємо використати gson.toJson(), це закінчиться циркулярним посиланням. Щоб уникнути цієї проблеми, ви можете виконати такі дії:

1. Отримати результати з джерела даних.
2. Ітераціюйте список і переконайтесь, що serialBean не має значення null, а потім
3. Встановити productBean.serialBean.productBean = null;
4. Тоді спробуйте використати gson.toJson();

Це має вирішити проблему