blocks|key|241574|text|您的第一个示例是正常且正确的双向一对多/多对一映射。将Question设置为Choice-attribute+("owning+side")就足以保持关系。内存中的实体图将被打乱，直到关系的另一端再次从数据库中读取。在数据库中，视点所有者是持久化到具有外键列的表中的实体(双向一对一也是如此)。在说明书中，这是以如下方式解释的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|241575|241576|一对多/多对一双向关系的多个方必须是拥有方，因此不能在ManyToOne批注中指定mappedBy元素。|blockquote|241577|241578|……|241579|托管实体之间的双向关系将基于关系的拥有方持有的引用进行持久化。当内存中的引用发生变化时，开发人员有责任保持拥有端的内存引用和相反端的内存引用保持一致。在单向一对一和一对多关系的情况下，开发人员有责任确保遵守关系的语义。|241580|241581|在JPA术语中，您的第二个示例没有拥有方，因为缺少mappedBy。相反，您有两个单向关系，它们被强制使用与store相同的列。至少在Hibernate+3.5.6中，它会以如下方式运行：|241582|relationship.|241583|Adding+|unordered-list-item|241584|
|241585|将Question设置为choice-attribute将不会持久化Choice+to+question-attribute将不会持久化relationship.|241586|241587|To持久值to+-attribute两者都必须设置(是的，也不是-+"QUESTION_ID"+insertable|241588|241589|entityMap^0|R|8|12|6|0|0|0|0|0|0|0|P|8|0|0|0|0|1|8|C|6|Y|6|18|8|0|0|Y|D|1C|A|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1C|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|1E|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1F|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1K|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1L|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1M|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|V|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|10|3|X|5|6|7|1W|8|@]|D|@]|E|$]]|$1|11|3|12|5|V|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@]|E|$]]|$1|13|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|15|$]]

Your first example is normal and correct bidirectional one-to-many/many-to-one mapping. Setting <code>Question</code> to <code>Choice</code>-attribute ("owning side") is enough to have relationship persisted. Entity graph in memory will be messed until other side of the relationship is read from database again. From the
database point-of-view owner is the entity that is persisted to table that have foreign key column (same for bidirectional one-to-one). In specification this is explained following way:

<blockquote>
 The many side of one-to-many / many-to-one bidirectional relationships
 must be the owning side, hence the mappedBy element cannot be
 specified on the ManyToOne annotation. 
 .... 
 Bidirectional
 relationships between managed entities will be persisted based on
 references held by the owning side of the relationship. It is the
 developer’s responsibility to keep the in-memory references held on
 the owning side and those held on the inverse side consistent with
 each other when they change. In the case of unidirectional one-to-one
 and one-to-many relationships, it is the developer’s responsibility to
 insure that the semantics of the relationships are adhered to.
</blockquote>

In JPA terms your second example does not have owning side, because of absence of <code>mappedBy</code>. Instead you have two unidirectional relationships which are forced to use same column as store. At least with Hibernate 3.5.6 it will behave following way:

<ul>
<li>Setting <code>Question</code> to <code>choice</code>-attribute will not persist relationship.</li>
<li>Adding <code>Choice</code> to <code>question</code>-attribute will not persist relationship.</li>
<li>To persist value to <code>"QUESTION_ID"</code> both have to be set (yes, also not-<code>insertable</code> <code>question</code>). </li>
</ul>

blocks|key|242881|text|同样重要的是要记住，如果没有mappedBy，你将会遇到循环依赖的问题。当双向关系中没有所有者时，就会发生这种情况。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|242882|在循环依赖中，您将在保存之前(显式地)设置实体的两端|242883|thisObj.set(thatObj);
thatObj.set(thisObj);|code-block|syntax|javascript|242884|entityMap^0|E|8|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

It is also important to remember that without <code>mappedBy</code> you will run into an issue of circular dependencies. This happens when there is no owner in a bidirectional relationship.
In a circular dependency you will (explicitly) set both sides of the entities before saving
<pre><code>thisObj.set(thatObj);
thatObj.set(thisObj);
</code></pre>

blocks|key|2912472|text|双向关系必须遵循以下规则：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2912473|反向关联必须引用其拥有方通过使用attribute|2912474|@ManyToOne属性association|unordered-list-item|2912475|
|2912476|@OneToMany+|2912477|2912478|+mappedBy可以具有双向关联始终是双向关联的拥有方是双向关联的反面@one关联的拥有方是具有包含外键的表的实体|2912479|2912480|多对一双向关系的多方不得定义多对多的双向关系，任何一方都可以是拥有方|2912481|2912482|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|X|8|@]|9|@]|A|$]]|$1|K|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|F|7|Z|8|@]|9|@]|A|$]]|$1|N|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|11|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|S|$]]

Bidirectional relationships must follow these rules:
<ol>
<li>The inverse side must refer to its owning sideby using the mappedBy attribute</li>
<li>The owning side may have the inversedBy attribute</li>
<li>@ManyToOne is always the owning side of a bidirectional association</li>
<li>@OneToMany is always the inverse side of a bidirectional association</li>
<li>the owning side of a @OneToOne association is the entity with the table containing the foreign key</li>
<li>The many side of many-to-one bidirectional relationships must not define the mappedBy attribute</li>
<li>For many-to-many bidirectional relationships, either side may be the owning side</li>
</ol>

I have a simple model with a <code>Question</code> and <code>Choice</code> object.

<ul>
<li>ONE Question has MANY CHOICE(S).</li>
<li>MANY Choice has ONE Question</li>
</ul>

There are two ways to implement that with Hibernate

Implementation One: The owner side is Choice

Question.java

<pre><code>@OneToMany (mappedBy="question")
private Set choices = new HashSet();
</code></pre>

Choice.java

<pre><code>@ManyToOne
@JoinColumn (name="QUESTION_ID")
private Question question;
</code></pre>

Implementation Two: The owner side is Question

Question.java

<pre><code>@OneToMany
@JoinColumn (name = "QUESTION_ID")
private Set choices = new HashSet();
</code></pre>

Choice.java

<pre><code>@ManyToOne
@JoinColumn (name="QUESTION_ID", updatable = false, insertable = false)
private Question question;
</code></pre>

What is the difference between the two implementation?

What does relationship owner means in bidirectional relationship?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我有一个带有Question和Choice对象的简单模型。一个问题有多个CHOICE(S).MANY 有一个问题有两种方法可以使用Hibernate实现该功能实现一:所有者端是ChoiceQuestion.java@OneToMany (mappedBy="question")private Set choices =...

问在双向关系中，关系所有者意味着什么？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在双向关系中，关系所有者意味着什么？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在双向关系中，关系所有者意味着什么？
EN