hibernate的OneToOne映射详解
http://www.2cto.com/kf/201604/500985.html
hibernate的OneToOne映射包括外键的单/双向映射，主键的单/双向映射，联合主键映射等。
关于OneToOne的映射，hibernate的annotation的API做了如下描述：
2.2.5.1.一对一(One-to-one)
使用@OneToOne注解可以建立实体bean之间的一对一的关联. 一对一关联有三种情况： 一是关联的实体都共享同样的主
键, 二是其中一个实体通过外键关联到另一个实体的主键 (注意要模拟一对一关联必须在外键列上添加唯一约束). 三
是通过关联表来保存两个实体之间的连接关系 (注意要模拟一对一关联必须在每一个外键上添加唯一约束).
首先,我们通过共享主键来进行一对一关联映射:
?
1 @Entity
2 public class Body {
3 @Id
4 public Long getId() { return id; }
5
6 @OneToOne(cascade = CascadeType.ALL)
7 @PrimaryKeyJoinColumn
8 public Heart getHeart() {
9 return heart;
10 }
11 …
12 }
?
1 @Entity
2 public class Heart {
3 @Id
4 public Long getId() { …}
5 }
上面的例子通过使用注解@PrimaryKeyJoinColumn定义了一对一关联.
下面这个例子使用外键列进行实体的关联.
?
1
@Entity
2
public class Customer implements Serializable {
3
@OneToOne(cascade = CascadeType.ALL)
4
<strong>@JoinColumn(name="passport_fk")</strong>
5
public Passport getPassport() {
6
…
7
}
8
9
@Entity
10
public class Passport implements Serializable {
11
@OneToOne(<strong>mappedBy = “passport”
12
</strong>)
13
public Customer getOwner() {
14
…
}
上面这个例子中,Customer通过Customer表中名为的passport_fk外键列和Passport关联.@JoinColumn注解定义了联接列
(join column). 该注解和@Column注解有点类似, 但是多了一个名为referencedColumnName的参数. 该参数定义了所关
联目标实体中的联接列. 注意,当referencedColumnName关联到非主键列的时候, 关联的目标类必须实现Serializable,
还要注意的是所映射的属性对应单个列(否则映射无效).
一对一关联可能是双向的.在双向关联中, 有且仅有一端是作为主体(owner)端存在的：主体端负责维护联接列(即更
新). 对于不需要维护这种关系的从表则通过mappedBy属性进行声明.mappedBy的值指向主体的关联属性. 在上面这个例
子中,mappedBy的值为passport. 最后,不必也不能再在被关联端(owned side)定义联接列了,因为已经在主体端进行了
声明.
如果在主体没有声明@JoinColumn, 自动进行处理： 在主表(owner table)中将创建联接列, 列名为：主体的关联属
系统
性名＋下划线＋被关联端的主键列名. 在上面这个例子中是passport_id, 因为Customer中关联属性名为
passport,Passport的主键是id.
The third possibility (using an association table) is very exotic.
第三种方式也许是最另类的(通过关联表).
?
1
@Entity
2
public class Customer implements Serializable {
3
@OneToOne(cascade = CascadeType.ALL)
4
<strong>@JoinTable(name = "CustomerPassports",
5
joinColumns = @JoinColumn(name=“customer_fk”),
6
inverseJoinColumns =
7
@JoinColumn(name=“passport_fk”)</strong>
8
)
9
public Passport getPassport() {
10
…
11
}
12
13
@Entity
14
public class Passport implements Serializable {
15
@OneToOne(<strong>mappedBy = “passport”
16
</strong>)
17
public Customer getOwner() {
…
}
Customer通过名为CustomerPassports的关联表和Passport关联; 该关联表拥有名为passport_fk的外键列,该 外键指向
Passport表,该信息定义为inverseJoinColumn的属性值, 而customer_fk外键列指向Customer表, 该信息定义为
joinColumns的属性值.
这种关联可能是双向的.在双向关联中, 有且仅有一端是作为主体端存在的：主体端负责维护联接列(即更新). 对于不
需要维护这种关系的从表则通过mappedBy属性进行声明.mappedBy的值指向主体的关联属性. 在上面这个例子
中,mappedBy的值为passport. 最后,不必也不能再在被关联端(owned side)定义联接列了,因为已经在主体端进行了声
明.
你必须明确定义关联表名和关联列名.
hibernate的xml方式的API则分别做了单独描述：
一.单向关联，包括外键和主键
7.2.2.One-to-one
基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯
一性约束。
?
1 <class name=“Person”>
2 <id column=“personId” name=“id”>
3 <generator class=“native”>
4 </generator></id>
5 <many-to-one column=“addressId” name=“address” not-
6 null=“true” unique=“true”>
7 </many-to-one></class>
8
9 <class name=“Address”>
10 <id column=“addressId” name=“id”>
11 <generator class=“native”>
12 </generator></id>
</class>
?
1 create table Person ( personId bigint not null primary key,
2 addressId bigint not null unique )
3 create table Address ( addressId bigint not null primary
key )
Aunidirectional one-to-one association on a primary keyusually uses a special id generator In this
example, however, we have reversed the direction of the association:
?
1
<class name="Person">
2
<id column="personId" name="id">
3
<generator class="native">
4
</generator></id>
5
</class>
6
7
<class name="Address">
8
<id column="personId" name="id">
9
<generator class="foreign"><param
10
name=“property”>person
11
</generator>
12
</id>
13
<one-to-one constrained="true" name="person">
</one-to-one></class>
?
1 create table Person ( personId bigint not null primary key
2 )
3 create table Address ( personId bigint not null primary
key )
二.使用链接表的单向关联
7.3.3.One-to-one
Aunidirectional one-to-one association on a join tableis possible, but extremely unusual.
?
1
<class name="Person">
2
<id column="personId" name="id">
3
<generator class="native">
4
</generator></id>
5
<join optional="true" table="PersonAddress">
6
<key column="personId" unique="true">
7
<many-to-one column="addressId" name="address" not-
8
null=“true” unique=“true”>
9
</many-to-one></key></join>
10
</class>
11
12
<class name="Address">
13
<id column="addressId" name="id">
14
<generator class="native">
15
</generator></id>
</class>
?
1 create table Person ( personId bigint not null primary key
2 )
3 create table PersonAddress ( personId bigint not null
4 primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary
key )
三.双向关联
7.4.2.One-to-one
Abidirectional one-to-one association on a foreign keyis common:
?
1
<class name="Person">
2
<id column="personId" name="id">
3
<generator class="native">
4
</generator></id>
5
<many-to-one column="addressId" name="address" not-
6
null=“true” unique=“true”>
7
</many-to-one></class>
8
9
<class name="Address">
10
<id column="addressId" name="id">
11
<generator class="native">
12
</generator></id>
13
<one-to-one name="person" property-ref="address">
</one-to-one></class>
?
1 create table Person ( personId bigint not null primary key,
2 addressId bigint not null unique )
3 create table Address ( addressId bigint not null primary
key )
Abidirectional one-to-one association on a primary keyuses the special id generator:
?
1
<class name="Person">
2
<id column="personId" name="id">
3
<generator class="native">
4
</generator></id>
5
<one-to-one name="address">
6
</one-to-one></class>
7
8
<class name="Address">
9
<id column="personId" name="id">
10
<generator class="foreign"><param
11
name=“property”>person
12
</generator>
13
</id>
14
<one-to-one constrained="true" name="person">
</one-to-one></class>
?
1 create table Person ( personId bigint not null primary key
2 )
3 create table Address ( personId bigint not null primary
key )
四.使用链接表的双向关联
7.5.2.一对一（one to one）
Abidirectional one-to-one association on a join tableis possible, but extremely unusual.
?
1
<class name="Person">
2
<id column="personId" name="id">
3
<generator class="native">
4
</generator></id>
5
<join optional="true" table="PersonAddress">
6
<key column="personId" unique="true">
7
<many-to-one column="addressId" name="address" not-
8
null=“true” unique=“true”>
9
</many-to-one></key></join>
10
</class>
11
12
<class name="Address">
13
<id column="addressId" name="id">
14
<generator class="native">
15
</generator></id>
16
<join inverse="true" optional="true"
17
table=“PersonAddress”>
18
<key column="addressId" unique="true">
19
<many-to-one column="personId" name="person" not-
null="true" unique="true">
</many-to-one></key></join>
</class>
?
1 create table Person ( personId bigint not null primary key
2 )
3 create table PersonAddress ( personId bigint not null
4 primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary
key )
1.OneToOne的外键单向映射
先看annotation版本
本例使用Husband和Wife为例，需要在Husband里面引用Wife，并在getWife上使用
@OneToOne@JoinColumn(name=“wifeId”)
Husband类
?
1
package com.baosight.model;
2
3
import javax.persistence.Entity;
4
import javax.persistence.GeneratedValue;
5
import javax.persistence.Id;
6
import javax.persistence.JoinColumn;
7
import javax.persistence.OneToOne;
8
9
@Entity
10
public class Husband {
11
private String id;
12
private String name;
13
private Wife wife;
14
@Id
15
@GeneratedValue//auto
16
public String getId() {
17
return id;
18
}
19
public void setId(String id) {
20
this.id = id;
21
}
22
public String getName() {
23
return name;
24
}
25
public void setName(String name) {
26
this.name = name;
27
}
28
@OneToOne
29
@JoinColumn(name=“wifeId”)
30
public Wife getWife() {
31
return wife;
32
}
33
public void setWife(Wife wife) {
34
this.wife = wife;
35
}
36
}
Wife类
?
1
package com.baosight.model;
2
3
import javax.persistence.Entity;
4
import javax.persistence.GeneratedValue;
5
import javax.persistence.Id;
6
7
@Entity
8
public class Wife {
9
private String id;
10
private String name;
11
@Id
12
@GeneratedValue//auto
13
public String getId() {
14
return id;
15
}
16
public void setId(String id) {
17
this.id = id;
18
}
19
public String getName() {
20
return name;
21
}
22
public void setName(String name) {
23
this.name = name;
24
}
25
}
使用JUnit进行测试
OrMappingTest类
?
1
package com.baosight.model;
2
3
import org.hibernate.SessionFactory;
4
import org.hibernate.cfg.AnnotationConfiguration;
5
import org.hibernate.cfg.Configuration;
6
import org.hibernate.tool.hbm2ddl.SchemaExport;
7
import org.junit.AfterClass;
8
import org.junit.BeforeClass;
9
import org.junit.Test;
10
11
public class OrMappingTest {
12
private static SessionFactory sf = null;
13
@BeforeClass
14
public static void beforeClass(){
15
// 读取配置文件
16
Configuration cfg = new AnnotationConfiguration();
17
// 得到session工厂
18
sf = cfg.configure().buildSessionFactory();
19
}
20
@Test
21
public void testSchemaExport() {
22
new SchemaExport(new
23
AnnotationConfiguration().configure()).create(false, true);
24
}
25
@AfterClass
26
public static void afterClass(){
27
// 关闭session工厂
28
sf.close();
29
}
}
运行结果为：
\
2.OneToOne的外键单向映射
看看xml版本
使用Student和StudentCard,.，需要在StudentCard里面引用Student，并在StudentCard.hbm.xml使用
Student类
?
1
package com.baosight.model;
2
3
4
public class Student {
5
private String id;
6
private String name;
7
private int age;
8
public String getId() {
9
return id;
10
}
11
public void setId(String id) {
12
this.id = id;
13
}
14
public String getName() {
15
return name;
16
}
17
public void setName(String name) {
18
this.name = name;
19
}
20
21
public int getAge() {
22
return age;
23
}
24
public void setAge(int age) {
25
this.age = age;
26
}
27
28
}
StudentCard类
?
1
package com.baosight.model;
2
3
4
public class StudentCard {
5
private String id;
6
private String num;
7
private Student student;
8
public String getId() {
9
return id;
10
}
11
public void setId(String id) {
12
this.id = id;
13
}
14
public String getNum() {
15
return num;
16
}
17
public void setNum(String num) {
18
this.num = num;
19
}
20
public Student getStudent() {
21
return student;
22
}
23
public void setStudent(Student student) {
24
this.student = student;
25
}
26
27
}
Student.hbm.xml
?
1 <hibernate-mapping package=“com.baosight.model”>
2 <class dynamic-update=“true” name=“Student”>
3 <id name=“id”>
4 <generator class=“native”></generator>
5 </id>
6 <property name=“name”></property>
7 <property name=“age”></property>
8 </class>
9 </hibernate-mapping>
StudentCard.hbm.xml
?
1 <hibernate-mapping package=“com.baosight.model”>
2 <class dynamic-update=“true” name=“StudentCard”>
3 <id name=“id”>
4 <generator class=“native”></generator>
5 </id>
6 <property name=“num”></property>
7 <many-to-one column=“studentId” name=“student”
8 unique=“true”></many-to-one>
9 </class>
</hibernate-mapping>
使用JUnit测试以及结果见1中的描述
3.OneToOne的外键双向映射
看看annotation版本
本例使用Husband和Wife为例，需要在Husband里面引用Wife，并在getWife上使用
@OneToOne@JoinColumn(name=“wifeId”)，并在Wife里面引用Husband，并在getHusband上使用
@OneToOne(mappedBy=“wife”)，需要注意的是，双向关联的映射一般需要在其中一个类中使用mappedBy=“wife”，表示
关联关系由Husband中的wife来维护。
Husband类与1中配置相同，这里不再赘述。
Wife类
?
1
package com.baosight.model;
2
3
import javax.persistence.Entity;
4
import javax.persistence.GeneratedValue;
5
import javax.persistence.Id;
6
import javax.persistence.OneToOne;
7
8
@Entity
9
public class Wife {
10
private String id;
11
private String name;
12
private Husband husband;
13
@Id
14
@GeneratedValue//auto
15
public String getId() {
16
return id;
17
}
18
public void setId(String id) {
19
this.id = id;
20
}
21
public String getName() {
22
return name;
23
}
24
public void setName(String name) {
25
this.name = name;
26
}
27
@OneToOne(mappedBy=“wife”)
28
public Husband getHusband() {
29
return husband;
30
}
31
public void setHusband(Husband husband) {
32
this.husband = husband;
33
}
34
}
使用JUnit测试，与1中配置相同，不再赘述。测试结果如下：
\
4.OneToOne的外键双向映射
看看xml版本
使用Student和StudentCard,.，需要在StudentCard里面引用Student，并在StudentCard.hbm.xml使用，另外需要在
Student里面引用StudentCard，并在Student.hbm.xml使用，其中property-ref=“student"表示关联关系由StudentCard
的student来维持，同样地，在双向关联中这种配置是比较常见的。
StudentCard和StudentCard.hbm.xml的配置与2中完全相同，这里不再赘述。
Student类
?
1
package com.baosight.model;
2
3
4
public class Student {
5
private String id;
6
private String name;
7
private int age;
8
private StudentCard studentCard;
9
public String getId() {
10
return id;
11
}
12
public void setId(String id) {
13
this.id = id;
14
}
15
public String getName() {
16
return name;
17
}
18
public void setName(String name) {
19
this.name = name;
20
}
21
22
public int getAge() {
23
return age;
24
}
25
public void setAge(int age) {
26
this.age = age;
27
}
28
public StudentCard getStudentCard() {
29
return studentCard;
30
}
31
public void setStudentCard(StudentCard studentCard) {
32
this.studentCard = studentCard;
33
}
34
35
}
Student.hbm.xml
?
1 <hibernate-mapping package=“com.baosight.model”>
2 <class dynamic-update=“true” name=“Student”>
3 <id name=“id”>
4 <generator class=“native”></generator>
5 </id>
6 <property name=“name”></property>
7 <property name=“age”></property>
8 <one-to-one name=“studentCard” property-
9 ref=“student”></one-to-one>
10 </class>
</hibernate-mapping>
仍然使用JUnit进行测试（详见1），结果为：
\
5.OneToOne的主键单向映射
先看annotation版本
本例使用Husband和Wife为例，需要在Husband里面引用Wife，并在getWife上使用@OneToOne@PrimaryKeyJoinColumn
Husband类
?
1
package com.baosight.model;
2
3
import javax.persistence.Entity;
4
import javax.persistence.GeneratedValue;
5
import javax.persistence.Id;
6
import javax.persistence.JoinColumn;
7
import javax.persistence.OneToOne;
8
import javax.persistence.PrimaryKeyJoinColumn;
9
10
@Entity
11
public class Husband {
12
private String id;
13
private String name;
14
private Wife wife;
15
@Id
16
@GeneratedValue//auto
17
public String getId() {
18
return id;
19
}
20
public void setId(String id) {
21
this.id = id;
22
}
23
public String getName() {
24
return name;
25
}
26
public void setName(String name) {
27
this.name = name;
28
}
29
@OneToOne
30
@PrimaryKeyJoinColumn
31
public Wife getWife() {
32
return wife;
33
}
34
public void setWife(Wife wife) {
35
this.wife = wife;
36
}
37
}
Wife类
?
1
package com.baosight.model;
2
3
import javax.persistence.Entity;
4
import javax.persistence.GeneratedValue;
5
import javax.persistence.Id;
6
7
@Entity
8
public class Wife {
9
private String id;
10
private String name;
11
@Id
12
@GeneratedValue//auto
13
public String getId() {
14
return id;
15
}
16
public void setId(String id) {
17
this.id = id;
18
}
19
public String getName() {
20
return name;
21
}
22
public void setName(String name) {
23
this.name = name;
24
}
25
}
仍然使用1中的JUnit进行测试，结果为：
\
6.OneToOne的主键单向映射
看看xml版本
使用Student和StudentCard,.，需要在StudentCard里面引用Student，并在StudentCard.hbm.xml使用
student
和，表示主键生成参考Student类色主键
StudentCard、Student和Student.hbm.xml的配置与2中完全相同，不再赘述
StudentCard.hbm.xml
?
1 <hibernate-mapping package=“com.baosight.model”>
2 <class dynamic-update=“true” name=“StudentCard”>
3 <id name=“id”>
4 <generator class=“foreign”><param
5 name=“property”>student
6 </generator>
7 </id>
8 <property name=“num”></property>
9 <one-to-one constrained=“true” name=“student”></one-
10 to-one>
</class>
</hibernate-mapping>
测试方法与5中相同，不再赘述，测试结果见5中
7.OneToOne的主键双向映射
看看annotation版本
本例使用Husband和Wife为例，需要在Husband里面引用Wife，并在getWife上使用@OneToOne@PrimaryKeyJoinColumn，
并在Wife里面引用Husband，并在getHusband上使用@OneToOne@PrimaryKeyJoinColumn。
Husband类
?
1
package com.baosight.model;
2
3
import javax.persistence.Entity;
4
import javax.persistence.GeneratedValue;
5
import javax.persistence.Id;
6
import javax.persistence.JoinColumn;
7
import javax.persistence.OneToOne;
8
import javax.persistence.PrimaryKeyJoinColumn;
9
10
@Entity
11
public class Husband {
12
private String id;
13
private String name;
14
private Wife wife;
15
@Id
16
@GeneratedValue//auto
17
public String getId() {
18
return id;
19
}
20
public void setId(String id) {
21
this.id = id;
22
}
23
public String getName() {
24
return name;
25
}
26
public void setName(String name) {
27
this.name = name;
28
}
29
@OneToOne
30
@PrimaryKeyJoinColumn
31
public Wife getWife() {
32
return wife;
33
}
34
public void setWife(Wife wife) {
35
this.wife = wife;
36
}
37
}
Wife类
?
1
package com.baosight.model;
2
3
import javax.persistence.Column;
4
import javax.persistence.EmbeddedId;
5
import javax.persistence.Entity;
6
import javax.persistence.GeneratedValue;
7
import javax.persistence.GenerationType;
8
import javax.persistence.Id;
9
import javax.persistence.IdClass;
10
import javax.persistence.OneToOne;
11
import javax.persistence.PrimaryKeyJoinColumn;
12
import javax.persistence.SequenceGenerator;
13
import javax.persistence.TableGenerator;
14
15
@Entity
16
public class Wife {
17
private String id;
18
private String name;
19
private Husband husband;
20
@Id
21
@GeneratedValue//auto
22
public String getId() {
23
return id;
24
}
25
public void setId(String id) {
26
this.id = id;
27
}
28
public String getName() {
29
return name;
30
}
31
public void setName(String name) {
32
this.name = name;
33
}
34
@OneToOne
35
@PrimaryKeyJoinColumn
36
public Husband getHusband() {
37
return husband;
38
}
39
public void setHusband(Husband husband) {
40
this.husband = husband;
41
}
42
}
JUnit测试同上，结果为：
\
\
8.OneToOne的主键双向映射
看看xml版本
使用Student和StudentCard,.，需要在StudentCard里面引用Student，并在StudentCard.hbm.xml使用
student
和，表示主键生成参考Student类色主键
，另外需要在Student里面引用StudentCard，并在Student.hbm.xml使用，其中property-ref=“student"表示关联关系
由StudentCard的student来维持，同样地，在双向关联中这种配置是比较常见的。
StudentCard和StudentCard.hbm.xml的配置与6中完全相同，这里不再赘述。
Student类
?
1
package com.baosight.model;
2
3
4
public class Student {
5
private String id;
6
private String name;
7
private int age;
8
private StudentCard studentCard;
9
public String getId() {
10
return id;
11
}
12
public void setId(String id) {
13
this.id = id;
14
}
15
public String getName() {
16
return name;
17
}
18
public void setName(String name) {
19
this.name = name;
20
}
21
22
public int getAge() {
23
return age;
24
}
25
public void setAge(int age) {
26
this.age = age;
27
}
28
public StudentCard getStudentCard() {
29
return studentCard;
30
}
31
public void setStudentCard(StudentCard studentCard) {
32
this.studentCard = studentCard;
33
}
34
35
}
Student.hbm.xml
?
1 <hibernate-mapping package=“com.baosight.model”>
2 <class dynamic-update=“true” name=“Student”>
3 <id name=“id”>
4 <generator class=“native”></generator>
5 </id>
6 <property name=“name”></property>
7 <property name=“age”></property>
8 <one-to-one name=“studentCard” property-
9 ref=“student”></one-to-one>
10 </class>
</hibernate-mapping>
测试结果见7中
9.OneToOne的使用联合主键的类的外键映射
看看annotation版本
本例使用Husband和Wife为例，在Wife使用联合主键，创建联合住建磊WifePK，其需要implements Serializable和重写
equals和hashCode方法，Wife中使用@IdClass(WifePK.class)和@Id。需要在Husband里面引用Wife，并在getWife上使
用@OneToOne
@JoinColumns(
{
@JoinColumn(name=“wifeId”,referencedColumnName=“id”),
@JoinColumn(name=“wifeName”,referencedColumnName=“name”)
}
)
WifePK类
?
1 package com.baosight.model;
2
3 import java.io.Serializable;
4
5 import javax.persistence.Embeddable;
6
7 /**
8 * 联合主键类
9
*
Title:WifePK
*
Description:TODO
*
Company:
* @author yuan * @date 2016-4-19 下午8:25:56 */ //@Embeddable public class WifePK implements
Serializable{ private String id; private String name; public String getId() { return id; } public void
setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String
name) { this.name = name; } @Override public boolean equals(Object obj) { // TODO Auto-generated method
stub if(obj instanceof StudentPK){ StudentPK pk = (StudentPK)obj;
if(this.id.equals(pk.getId())&&this.name.equals(pk.getName())){ return true; } } return false; }
@Override public int hashCode() { // TODO Auto-generated method stub return this.id.hashCode(); } } Wife
类
?
1
package com.baosight.model;
2
3
import javax.persistence.Entity;
4
import javax.persistence.GeneratedValue;
5
import javax.persistence.Id;
6
import javax.persistence.IdClass;
7
8
@Entity
9
@IdClass(WifePK.class)
10
public class Wife {
11
private String id;
12
private String name;
13
private String age;
14
@Id
15
@GeneratedValue//auto
16
public String getId() {
17
return id;
18
}
19
public void setId(String id) {
20
this.id = id;
21
}
22
@Id
23
public String getName() {
24
return name;
25
}
26
public void setName(String name) {
27
this.name = name;
28
}
29
public String getAge() {
30
return age;
31
}
32
public void setAge(String age) {
33
this.age = age;
34
}
35
}
测试类同上，结果为：
\
\
\
10.OneToOne的使用联合主键的类的外键映射
看看xml版本
使用Student和StudentCard,.，在Student使用联合主键，创建联合住建磊StudentPK，其需要implements
Serializable和重写equals和hashCode方法，需要在Student中引用StudentPK，并在Student.hbm.xml中使用
，不要再使用id了，需要注意。
需要在StudentCard里面引用Student，并在StudentCard.hbm.xml使用
StudentPK
?
1 package com.baosight.model;
2
3 import java.io.Serializable;
4
5 /**
6 *
Title:StudentPK
*
Description:TODO
*
Company:
* @author yuan * @date 2016-4-15 下午8:08:16*/ public class StudentPK implements Serializable{ private
String id; private String name; public String getId() { return id; } public void setId(String id) {
this.id = id; } public String getName() { return name; } public void setName(String name) { this.name =
name; } @Override public boolean equals(Object obj) { // TODO Auto-generated method stub if(obj
instanceof StudentPK){ StudentPK pk = (StudentPK)obj;
if(this.id.equals(pk.getId())&&this.name.equals(pk.getName())){ return true; } } return false; }
@Override public int hashCode() { // TODO Auto-generated method stub return this.id.hashCode(); } }
Student
?
1
package com.baosight.model;
2
3
import javax.persistence.Column;
4
import javax.persistence.OneToOne;
5
6
public class Student {
7
// private String id;
8
// private String name;
9
private int age;
10
private StudentPK pk;
11
/* public String getId() {
12
return id;
13
}
14
public void setId(String id) {
15
this.id = id;
16
}
17
public String getName() {
18
return name;
19
}
20
public void setName(String name) {
21
this.name = name;
22
}*/
23
24
public int getAge() {
25
return age;
26
}
27
public void setAge(int age) {
28
this.age = age;
29
}
30
public StudentPK getPk() {
31
return pk;
32
}
33
public void setPk(StudentPK pk) {
34
this.pk = pk;
35
}
36
37
}
StudentCard
?
1
package com.baosight.model;
2
3
4
public class StudentCard {
5
private String id;
6
private String num;
7
private Student student;
8
public String getId() {
9
return id;
10
}
11
public void setId(String id) {
12
this.id = id;
13
}
14
public String getNum() {
15
return num;
16
}
17
public void setNum(String num) {
18
this.num = num;
19
}
20
public Student getStudent() {
21
return student;
22
}
23
public void setStudent(Student student) {
24
this.student = student;
25
}
26
27
}
Student.hbm.xml
?
1
<hibernate-mapping package="com.baosight.model">
2
<class dynamic-update="true" name="Student">
3
<!-- <id name="id" >
4
<generator class="native"></generator>
5
</id> -->
6
<composite-id class="StudentPK" name="pk">
7
<key-property column="stu_id" name="id"></key-
8
property>
9
<key-property column="stu_name" name="name"></key-
10
property>
11
</composite-id>
12
<!-- <property name="name"></property> -->
13
<property name="age"></property>
</class>
</hibernate-mapping>
StudentCard.hbm.xml
?
1 <hibernate-mapping package=“com.baosight.model”>
2 <class dynamic-update=“true” name=“StudentCard”>
3 <id name=“id”>
4 <generator class=“native”></generator>
5 </id>
6 <property name=“num”></property>
7 <many-to-one class=“Student” insert=“false”
8 name=“student” update=“false”>
9 <column name=“stu_id”></column>
10 <column name=“stu_name”></column>
11 </many-to-one>
12 </class>
</hibernate-mapping>
使用上面的JUnit进行测试，结果为：
\
\
\
\
\
以上即为OneToOne映射的内容，其实在实际使用中OneToOne用的不多，不过学习OneToOne对于学习后面的ManyToOne和
ManyToMany有帮助，可以看作是它们的特殊情形。总之，上述各种映射关系需要在实际的使用中仔细体会。