首先我们来看，Hibernate官方对于一对一单向关联的解释:
基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关
联中的外键字段具有唯一性约束。
ok,那我们也可以这样理解，一对一其实就是多对一关联的特殊形式，我们知道Hibernate的配置方式有两种，分别是Annotations，XML两种配置方式！
Annotations的一对一单向关联映射
人(User)和***号(Card)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
@Entity
@Table
(name=
"t_user"
)
publicclass User {
private
Integer id;
private
String name;
private
Card card;
@OneToOne
@JoinColumn
(name=
"card_id"
,unique=
true
)
//name是自定义关联外键的列名
public
Card getCard() {
returncard;
}
publicvoid setCard(Card card) {
this
.card = card;
}
@Id
@GeneratedValue
public
Integer getId() {
returnid;
}
publicvoid setId(Integerid) {
this
.id = id;
}
@Column
(name=
"name"
)
public
String getName() {
returnname;
}
publicvoid setName(Stringname) {
this
.name = name;
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@Entity
@Table
(name=
"t_card"
)
publicclass Card {
private
Integer id;
private
String num;
@Id
@GeneratedValue
public
Integer getId() {
returnid;
}
publicvoid setId(Integerid) {
this
.id = id;
}
@Column
(name=
"card_id"
)
public
String getNum() {
returnnum;
}
publicvoid setNum(Stringnum) {
this
.num = num;
}
}
|
XML一对一单向关联
Person和Group，一个人只能在一个组
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
publicclass Group {
private
Integer id;
private
String name;
public
Integer getId() {
returnid;
}
publicvoid setId(Integerid) {
this
.id = id;
}
public
String getName() {
returnname;
}
publicvoid setName(Stringname) {
this
.name = name;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
publicclass Person {
private
Integer id;
private
String name;
private
Integer age;
private
Group group;
public
Group getGroup() {
returngroup;
}
publicvoid setGroup(Groupgroup) {
this
.group = group;
}
public
Integer getId() {
returnid;
}
publicvoid setId(Integerid) {
this
.id = id;
}
public
String getName() {
return
name;
}
public
void
setName(Stringname) {
this
.name = name;
}
public
Integer getAge() {
return
age;
}
publicvoid setAge(Integer age){
this
.age = age;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<?
xml
version
=
"1.0"
?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<
hibernate-mapping
package
=
"csg.hibernate.entity"
>
<
class
name
=
"Group"
table
=
"t_group"
>
<
id
name
=
"id"
>
<
column
name
=
"id"
/>
<
generator
class
=
"native"
/>
</
id
>
<
property
name
=
"name"
/>
</
class
>
</
hibernate-mapping
>
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<?
xml
version
=
"1.0"
?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<
hibernate-mapping
package
=
"csg.hibernate.entity"
>
<
class
name
=
"Person"
table
=
"t_person"
>
<
id
name
=
"id"
>
<
column
name
=
"id"
/>
<
generator
class
=
"native"
/>
</
id
>
<
property
name
=
"name"
/>
<
property
name
=
"age"
/>
<
many-to-one
name
=
"group"
column
=
"group_id"
unique
=
"true"
not-null
=
"true"
/>
</
class
>
</
hibernate-mapping
>
|
Ok,到这里，大家就有点疑惑，为什么我们的Annotaions配置采用的是one-to-one而我们的xml配置采用的是many-to-one呢？
当然XML配置是我参考Hibernate的文档而来，因为一对一本身就是多对一的特殊形式，
但是配置many-to-one又给我们一种暗示，多个***号对应一个人，所以Hibernate根据这种情况提供unique唯一性来确认!
Annotations一对一双向关联映射
User和Card
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
@Entity
@Table
(name=
"t_user"
)
publicclass User {
private
Integer id;
private
String name;
private
Card card;
@OneToOne
@JoinColumn
(name=
"card_id"
,unique=
true
)
//name主要是自定义关联外键的列名
public
Card getCard() {
returncard;
}
publicvoid setCard(Cardcard) {
this
.card = card;
}
@Id
@GeneratedValue
public
Integer getId() {
returnid;
}
publicvoid setId(Integerid) {
this
.id = id;
}
@Column
(name=
"name"
)
public
String getName() {
returnname;
}
publicvoid setName(Stringname) {
this
.name = name;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
@Entity
@Table
(name=
"t_card"
)
publicclass Card {
private
Integer id;
private
String num;
private
User user;
@OneToOne
(mappedBy=
"card"
)
//mappedBy的意思是指定User中的card作为关联外键，否则User和Card都会出现外键
public
User getUser() {
returnuser;
}
publicvoid setUser(Useruser) {
this
.user = user;
}
@Id
@GeneratedValue
public
Integer getId() {
returnid;
}
publicvoid setId(Integerid) {
this
.id = id;
}
@Column
(name=
"card_id"
)
public
String getNum() {
returnnum;
}
publicvoid setNum(Stringnum) {
this
.num = num;
}
}
|
Ok？那么我们可以看到在Annotaions中的配置都是ont-to-one，那么我们在xml中的配置呢？
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<?
xml
version
=
"1.0"
?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<
hibernate-mapping
package
=
"csg.hibernate.entity"
>
<
class
name
=
"Person"
table
=
"t_person"
>
<
id
name
=
"id"
>
<
column
name
=
"id"
/>
<
generator
class
=
"native"
/>
</
id
>
<
property
name
=
"name"
/>
<
property
name
=
"age"
/>
<
many-to-one
name
=
"group"
column
=
"group_id"
unique
=
"true"
not-null
=
"true"
/>
</
class
>
</
hibernate-mapping
>
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
<?
xml
version
=
"1.0"
?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<
hibernate-mapping
package
=
"csg.hibernate.entity"
>
<
class
name
=
"Group"
table
=
"t_group"
>
<
id
name
=
"id"
>
<
column
name
=
"id"
/>
<
generator
class
=
"native"
/>
</
id
>
<
property
name
=
"name"
/>
<!-- many-to-one这种配置会分别在两个表中都产生外键，造成数据的多余，通常我们采用one-to-one的形式在xml中配置 -->
<
many-to-one
name
=
"Person"
column
=
"person_id"
unique
=
"true"
/>
<!-- <one-to-onename="person"property-ref="group"/> -->
</
class
>
</
hibernate-mapping
>
|
ok，到这里一对一的单双向关联映射基本上就是这样，随笔之作，有问题，请留言！
本文转自 小夜的传说 51CTO博客，原文链接：http://blog.51cto.com/1936625305/1567291，如需转载请自行联系原作者
