码农小汪-Hibernate学习2-Mapping associations关联映射

重要的事情说三遍，说三遍。即使英文不好，看教程的时候还是尽量的百度一哈英文解释是什么，为啥子这么说呢，你好哈，就想我们写变量哈，都是尽可能的让名字通俗易懂，一看就知道这个啥啥意思。理解英文我们就知道了，这个到底是啥.xiao wang的英语也是很差的，初三的考高中75分。高中的时候英语的基础几乎为零吧，所以我们不要放弃。

what is Mapping associations?

So far we have mapped a single persistent entity class to a table in isolation 持久对象实体到table的映射。

package org.hibernate.tutorial.domain;

public class Person {

private Long id;
private int age;
private String firstname;
private String lastname;

public Person() {}

// Accessor methods for all properties, private setter for 'id'

}

Next, create the new mapping file as
Person.hbm.xml 我们可能分为不同的开发人员去完成这些工作，所以最后的时候可能集成到一起，把所有的文件搞定放在一起就好了
<hibernate-mapping package="org.hibernate.tutorial.domain">

<class name="Person" table="PERSON">
<id name="id" column="PERSON_ID">
<generator class="native"/>
</id>
<property name="age"/>
<property name="firstname"/>
<property name="lastname"/>
</class>

</hibernate-mapping>
上面的属性，还可以指定type,cloumn,length....对应在数据表中的属性
Finally, add the new mapping to Hibernate's configuration:
<mapping resource="org/hibernate/tutorial/domain/Person.hbm.xml"/>

A unidirectional Set-based association

基于集合的单向关联

一个person关联了一系列的events。和为单向的，我们可以通过person了解到有关的events，但是不能通过events了解到我们的person。简单来说这个就是单向的关联

we choose a java.util.Set because the collection will not contain duplicate elements。例子中选择set不存在相同的

public class Person {

private Set events = new HashSet();

public Set getEvents() {
return events;
}

public void setEvents(Set events) {
this.events = events;
}
}

“many” valued on both sides is called a many-to-many association. Hence, we use Hibernate’s many-to-many mapping:

<class name="Person" table="PERSON">
<id name="id" column="PERSON_ID">
<generator class="native"/>
</id>
<property name="age"/>
<property name="firstname"/>
<property name="lastname"/>

<set name="events" table="PERSON_EVENT">//提供中间的表
<key column="PERSON_ID"/>//当前表中的key
<many-to-many column="EVENT_ID" class="Event"/>
//其他表中的key,然后合成为新的表
</set>

</class>
这个有点N:M的关系

和我在数据库中学习的类似，为了避免数据冗余。生成一些不必要的东西，但是这个查询起来需要联合两三个表

private void addPersonToEvent(Long personId, Long eventId) {
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();

Person aPerson = (Person) session.load(Person.class, personId);
Event anEvent = (Event) session.load(Event.class, eventId);
aPerson.getEvents().add(anEvent);

session.getTransaction().commit();
}

现在就可以直接的使用这些数据了，简单直接滴。加载后Person和一个Event使用,只需修改集合 正常的收集方法。 没有显式的调用update()或save(); Hibernate自动检测到收集已被修改 和需要更新。 这就是所谓的自动的检查

值类型的集合

Let’s add a collection of email addresses to the Person entity. This will be represented as a java.util.Set of java.lang.String instances:

private Set emailAddresses = new HashSet();

public Set getEmailAddresses() {
return emailAddresses;
}

public void setEmailAddresses(Set emailAddresses) {
this.emailAddresses = emailAddresses;
}

The mapping of this Set is as follows:
<set name="emailAddresses" table="PERSON_EMAIL_ADDR">//外表的名字

<key column="PERSON_ID"/>//外表中的外键
<element type="string" column="EMAIL_ADDR"/>
</set>

这里没有描述很多。

Bi-directional associations

双向关联哦！·

Next you will map a bi-directional association. You will make the association between person and event work from both sides in Java. The database schema does not change, so you will still have many-to-many multiplicity.接下来你将地图一个双向关联。 你会让 人之间的关系和事件两边工作 在Java中。 数据库模式不改变,所以你还是会 多对多的多样性。

First, add a collection of participants to the Event class:

因为现在双方都可以访问对方了，一个Events可能对应多个persoon

private Set participants = new HashSet();

public Set getParticipants() {
return participants;
}

public void setParticipants(Set participants) {
this.participants = participants;
}
Now map this side of the association in Event.hbm.xml.
<set name="participants" table="PERSON_EVENT" inverse="true">
<key column="EVENT_ID"/>
<many-to-many column="PERSON_ID" class="Person"/>
</set>

inverse adj.相反的;逆向的;倒转的;n.相反;倒转;相反的事物;vt.使倒转;使颠倒;

注意在两个映射文件中，互换了 key 和 manyto-many 的字段名。这里最重要的是 Event 映射文件里增加了 set 元素的 inverse=”true” 属性。

这意味着在需要的时候，Hibernate 能在关联的另一端 — Person 类得到两个实体间关联的信息。这将会极大地帮助你理解双向关联是如何在两个实体间被创建的。 这个属性很难理解哦，为啥子，两个相互依赖的东西，都不是null时候，如果其中的一个属性没有创建，另外的也是没有创建，那时候两个都不可以创建啦

What about the inverse mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate, however, does not have enough information to correctly arrange SQL INSERT and UPDATE statements (to avoid constraint violations). Making one side of the association inverse tells Hibernate to consider it a mirror of the other side. That is all that is necessary for Hibernate to resolve any issues that arise when transforming a directional navigation model to a SQL database schema. The rules are straightforward: all bi-directional associations need one side as inverse. In a one-to-many association it has to be the many-side, and in many-to-many association you can select either side.

是怎样的inverse映射属性? 为你,和Java,双向 链接是一个简单的事双方正确设置引用。 然而,Hibernate不会 有足够的信息来正确地安排SQLINSERT和UPDATE语句(以避免约束违反)。 协会的一边inverse告诉Hibernate考虑它镜子的另一边。 这都是必要的 Hibernate解决出现的任何问题将定向导航模型的时候出现 一个SQL数据库模式。 规则很简单:所有双向关联 需要一方inverse。 在一对多关联是多方位的, 多对多关联,你可以选择任何一方。 这个很重要，不然后面的更烦的东西理解不来。

大概的意思就是，有inverse属性的一方我们创建持久对象的时候可以忽悠他，即使没有创建也不会错误！我们把当前对象创建了之后，然后又Inverse属性的一个，可以引用我们的当前的对象创建持久对象，反之，刚刚没有引用的对象，现在创建出来了，那么我们现在可以使用啦，所以这个对于我们来说是没得问题的啦！

看英文很累，虽然有翻译，但是我觉得还是原味的英文看起来舒服一点，虽然很烦躁，但是还得慢慢的来吧！文档，文档，文档一定要看。特别是使用我们的框架之类的吧。