blocks|key|1189057|text|双向关系甚至可以用JSON表示吗？某些数据格式不适合某些类型的数据建模。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1189058|在处理遍历对象图时，处理循环的一种方法是跟踪到目前为止看到的对象(使用标识比较)，以防止自己遍历无限循环。|1189059|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Can a bi-directional relationship even be represented in JSON? Some data formats are not good fits for some types of data modelling. 

One method for dealing with cycles when dealing with traversing object graphs is to keep track of which objects you've seen so far (using identity comparisons), to prevent yourself from traversing down an infinite cycle.

blocks|key|974904|text|Jackson+1.6+(发布于2010年9月)具有特定的基于注释的支持，用于处理此类父/子链接，请参阅http://wiki.fasterxml.com/JacksonFeatureBiDirReferences。(Wayback+Snapshot)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|974905|当然，您可以排除已经使用大多数JSON处理包(jackson、gson和flex-json至少支持它)的父链接的序列化，但真正的诀窍在于如何将其反序列化(重新创建父链接)，而不仅仅是处理序列化方面。虽然现在听起来只是排除可能对你有用。|974906|编辑(2012年4月)：Jackson+2.0现在支持真正的identity+references+(Wayback+Snapshot)，所以你也可以这样解决它。|974907|entityMap|0|LINK|mutability|MUTABLE|url|http://jackson.codehaus.org/|1|http://wiki.fasterxml.com/JacksonFeatureBiDirReferences|2|https://web.archive.org/web/20161206182112/http://wiki.fasterxml.com/JacksonFeatureBiDirReferences|3|http://www.cowtowncoder.com/blog/archives/2012/03/entry_466.html|4|http://wiki.fasterxml.com/JacksonFeatureObjectIdentity|5|https://web.archive.org/web/20161206171637/http://wiki.fasterxml.com/JacksonFeatureObjectIdentity^0|0|7|0|1G|1J|1|31|G|2|0|0|C|B|3|U|J|4|1F|G|5|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]|$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|D|3|E|5|6|7|19|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]|$A|1E|B|1F|1|1G]|$A|1H|B|1I|1|1J]]|C|$]]|$1|H|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]|T|$5|K|L|M|C|$N|U]]|V|$5|K|L|M|C|$N|W]]|X|$5|K|L|M|C|$N|Y]]]]

<a href="http://jackson.codehaus.org" rel="nofollow noreferrer">Jackson</a> 1.6 (released september 2010) has specific annotation-based support for handling such parent/child linkage, see <a href="http://wiki.fasterxml.com/JacksonFeatureBiDirReferences" rel="nofollow noreferrer">http://wiki.fasterxml.com/JacksonFeatureBiDirReferences</a>. (<a href="https://web.archive.org/web/20161206182112/http://wiki.fasterxml.com/JacksonFeatureBiDirReferences" rel="nofollow noreferrer">Wayback Snapshot</a>)
You can of course already exclude serialization of parent link already using most JSON processing packages (jackson, gson and flex-json at least support it), but the real trick is in how to deserialize it back (re-create parent link), not just handle serialization side. Although sounds like for now just exclusion might work for you.
EDIT (April 2012): <a href="http://www.cowtowncoder.com/blog/archives/2012/03/entry_466.html" rel="nofollow noreferrer">Jackson 2.0</a> now supports true <a href="http://wiki.fasterxml.com/JacksonFeatureObjectIdentity" rel="nofollow noreferrer">identity references</a> (<a href="https://web.archive.org/web/20161206171637/http://wiki.fasterxml.com/JacksonFeatureObjectIdentity" rel="nofollow noreferrer">Wayback Snapshot</a>), so you can solve it this way also.

blocks|key|1189178|text|我使用了一个类似于亚瑟的解决方案，但没有使用setExclusionStrategies|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1189179|Gson+gson+=+new+GsonBuilder()
++++++++++++++++.excludeFieldsWithoutExposeAnnotation()
++++++++++++++++.create();|code-block|syntax|javascript|1189180|并对json中需要的字段使用了@Expose+gson注释，排除了其他字段。|1189181|entityMap^0|M|M|0|0|F|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Used a solution similar to Arthur's but instead of <code>setExclusionStrategies</code> I used 

<pre><code>Gson gson = new GsonBuilder()
 .excludeFieldsWithoutExposeAnnotation()
 .create();
</code></pre>

and used <code>@Expose</code> gson annotation for fields which I need in the json, other fields are excluded.

blocks|key|1189140|text|如果你使用的是Javascript，有一个非常简单的解决方案，那就是使用JSON.stringify()方法的replacer参数，你可以传递一个函数来修改默认的序列化行为。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1189141|下面是你如何使用它。考虑下面的例子，在一个循环图中有4个节点。|1189142|//+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+"@"+%2B+value.name;
++++++++++++}
++++++++++++alreadyVisited.push(value.name);
++++++++}
++++++++return+value;
++++});
++++console.log(serializedData);
}|code-block|syntax|javascript|1189143|稍后，如果使用的是带有@的命名引用，则可以通过解析序列化数据并修改next属性以指向实际对象，从而轻松地重新创建具有循环引用的实际对象。|1189144|entityMap^0|10|G|1J|8|0|0|0|B|1|X|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

If you are using Javascript, there's a very easy solution to that using the <code>replacer</code> parameter of <code>JSON.stringify()</code> method where you can pass a function to modify the default serialization behavior. 

Here's how you can use it. Consider the below example with 4 nodes in a cyclic graph.

<pre><code>// 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) &gt;= 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);
}
</code></pre>

Later, you can easily recreate the actual object with the cyclic references by parsing the serialized data and modifying the <code>next</code> property to point to the actual object if it's using a named reference with a <code>@</code> like in this example.

blocks|key|1189219|text|这就是我最终解决这个问题的方法。这至少适用于Gson+&+Jackson。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1189220|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;
}+|code-block|syntax|javascript|1189221|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is how i finally solved it in my case. This works at least with Gson &amp; Jackson.

<pre><code>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&lt;?&gt; classO) {
 return ( null != classO.getAnnotation(ManyToOne.class) );
 }
 };
 return exlStrategy;
} 
</code></pre>

blocks|key|1189289|text|如果使用GSON转换JSON中的Java类，则可以避免导致循环引用和无限循环的字段，只需将注释@Expose放在希望出现在JSON中的字段中，没有注释@Expose的字段不会出现在JSON中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1189290|循环引用出现例如，如果我们尝试使用类Route的字段routes来序列化类User，并且类Route具有类User的字段user，然后GSON尝试序列化类User，并且当尝试序列化路由时，序列化类Route，并且在类Route中尝试序列化字段user，然后再次尝试序列化类User，则会有一个循环引用，这会引发无限循环。我展示了上面提到的User和Route类。|1189291|import+com.google.gson.annotations.Expose;|code-block|syntax|javascript|1189292|类User|1189293|@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;|1189294|类路由|1189295|++@Entity
++@Table(name+=+"route")
++public+class+Route+{
++++++
++@ManyToOne()
++@JoinColumn(nullable+=+false,+name+=+"id_user",+foreignKey+=+
++@ForeignKey(name+=+"c"))++++
++private+User+user;|1189296|为了避免不定式循环，我们使用注释@Expose来提供GSON。|1189297|我以JSON格式显示了在类User上使用GSON序列化的结果。|1189298|{
++++"name":+"ignacio"++
}|1189299|我们可以看到，字段route和like不是以JSON格式存在的，只有字段名称。正因为如此，避免了循环引用。|1189300|如果我们想要使用它，我们必须以特定的方式创建一个对象GSON。|1189301|Gson+converterJavaToJson+=+new+GsonBuilder().setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().create();|1189302|最后，我们使用创建的conversor+GSON对hibernate用户模型的java类进行了转换。|1189303|+User+user+=+createUserWithHibernate();
+String+json+=+converterJavaToJson.toJson(user);|1189304|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1H|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1J|8|@]|9|@]|A|$]]|$1|10|3|11|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|15|5|F|7|1M|8|@]|9|@]|A|$G|H]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

If you use GSON to convert Java class in JSON you can avoid the fields that cause the circular reference and the infinitive loop, you only have to put the annotation @Expose in the fields that you want to appear in the JSON, and the fields without the annotation @Expose do not appear in the JSON.
The circular reference appears for example if we try to serialize the class User with the field routes of class Route, and the class Route have the field user of the class User, then GSON try to serialize the class User and when try to serialize routes, serialize the class Route and in the class Route try to serialize the field user, and again try to serialize the class User, there is a circular reference that provoke the infinitive loop. I show the class User and Route that mentioned.
<pre><code>import com.google.gson.annotations.Expose;
</code></pre>
Class User
<pre><code>@Entity
@Table(name = &quot;user&quot;)
public class User {
 
@Column(name = &quot;name&quot;, nullable = false)
@Expose
private String name;

@OneToMany(mappedBy = &quot;user&quot;, fetch = FetchType.EAGER)
@OnDelete(action = OnDeleteAction.CASCADE)
private Set&lt;Route&gt; routes;

@ManyToMany(fetch = FetchType.EAGER)
@OnDelete(action = OnDeleteAction.CASCADE)
@JoinTable(name = &quot;like_&quot;, joinColumns = @JoinColumn(name = &quot;id_user&quot;),
 inverseJoinColumns = @JoinColumn(name = &quot;id_route&quot;),
 foreignKey = @ForeignKey(name = &quot;&quot;),
 inverseForeignKey = @ForeignKey(name = &quot;&quot;))
private Set&lt;Route&gt; likes;
</code></pre>
Class Route
<pre><code> @Entity
 @Table(name = &quot;route&quot;)
 public class Route {
 
 @ManyToOne()
 @JoinColumn(nullable = false, name = &quot;id_user&quot;, foreignKey = 
 @ForeignKey(name = &quot;c&quot;)) 
 private User user;
</code></pre>
To avoid the infinitive loop, we use the annotation @Expose that offer GSON.
I show in format JSON the result of serialize with GSON the class User.
<pre><code>{
 &quot;name&quot;: &quot;ignacio&quot; 
}
</code></pre>
We can see that the field route and likes do not exist in the format JSON, only the field name. Because of this, the circular reference is avoid.
If we want to use that, we have to create an object GSON on a specific way.
<pre><code>Gson converterJavaToJson = new GsonBuilder().setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().create();
</code></pre>
In the end, we transform the java class of the model of hibernate user using the conversor GSON created.
<pre><code> User user = createUserWithHibernate();
 String json = converterJavaToJson.toJson(user);
</code></pre>

I am writing a serializer to serialize POJO to JSON but stuck in circular reference problem. In hibernate bidirectional one-to-many relation, parent references child and child references back to parent and here my serializer dies. (see example code below) 
How to break this cycle? Can we get owner tree of an object to see whether object itself exists somewhere in its own owner hierarchy? Any other way to find if the reference is going to be circular? or any other idea to resolve this problem?

How to solve circular reference in json serializer caused by hibernate bidirectional mapping?

数据建模

路由

JSON

Java

我正在编写一个序列化程序来将POJO序列化为JSON，但是陷入了循环引用的问题。在hibernate的双向一对多关系中，parent引用回父对象的子引用和子引用，这时我的序列化程序就完蛋了。(参见下面的示例代码)如何打破这个循环？我们可以得到一个对象的所有者树来查看对象本身是否存在于它自己的所有者层次结构中的某个地方吗？有没有其他方法来确定引用是否将是循环的？或任何其他想法来解决这个问题？

问如何解决hibernate双向映射导致的json序列化中的循环引用？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何解决hibernate双向映射导致的json序列化中的循环引用？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何解决hibernate双向映射导致的json序列化中的循环引用？
EN