《Hibernate学习笔记九》：多对一和一对多的关联关系

《Hibernate学习笔记九》：多对一和一对多的关联关系

前面介绍了一对一的关联关系在Hibernate应该如何来实现，这篇博文就来介绍下多对一和一对多的关联关系。

多对一和一对多的关联关系在我们的生活中也比较常见，例如，在我们学生时代，一个班级可以有多个学生，而一个学生只能属于一个班级，这就是一个多对一(一对多)的例子；

还有在我们的工作中，一个工作小组可以有多个用户，而一个用户只能属于一个小组，这也是一个多对一(一对多)的关系的例子。

1、多对一的单向关联关系

下面就以一个工作小组可以有多个用户，而一个用户只能属于一个小组，这个例子来进行设计介绍如何建立一个多对一的关联关系。

在类的层面上：在多的一方加另一个的引用

在数据库层面上：在”多对一”中”多”的一方设置外键即可

1.1、多对一单向的关联关系的Annotation实现

Group类

@Entity
    @Table(name="t_group")  //指定表名
    public class Group {
    private int idGroup;
    private String nameGroup;
    @Id
    @GeneratedValue
    public int getIdGroup() {
        return idGroup;
    }
    public void setIdGroup(int idGroup) {
        this.idGroup = idGroup;
    }
    public String getNameGroup() {
        return nameGroup;
    }
    public void setNameGroup(String nameGroup) {
        this.nameGroup = nameGroup;
    }

    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

User类

@Entity
    @Table(name="t_user")  //指定表名
    public class User {
    private int idUser;
    private String nameUser;
    private Group group;//指定外键
    @ManyToOne  //多对一  即一个组有多个用户，而一个用户只能属于一个组
    @JoinColumn(name="group_id")
    public Group getGroup() {
        return group;
    }
    public void setGroup(Group group) {
        this.group = group;
    }
    @Id
    @GeneratedValue
    public int getIdUser() {
        return idUser;
    }
    public void setIdUser(int idUser) {
        this.idUser = idUser;
    }
    public String getNameUser() {
        return nameUser;
    }
    public void setNameUser(String nameUser) {
        this.nameUser = nameUser;
    }
    }
 
 
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

由于User实体和Group实体，User是处于“多对一”中“多”的一方，因此，我们就在User类中设置一个Group的外键即可建立多对一的关联关系。

测试结果如下：

1.2、多对一单向的关联关系的XXX.hbm.xml实现

Group类和User类

Group和User类中，有相应的属性和get、set方法即可。
且User类中有一个Group的引用。

Group.hbm.xml

<?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="com.hibernate.model">
    <class name="Group" table="t_group" >
        <id name="idGroup" column="idGroup">
            <generator class="native"/>
        </id>
        <property name="nameGroup" column="nameGroup"/>   
    </class>
    </hibernate-mapping>
 
 
1
2
3
4
5
6
7
8
9
10
11
12

User.hbm.xml

<?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="com.hibernate.model">
    <class name="User" table="t_user" >
        <id name="idUser" column="id">
            <generator class="native"/>
        </id>
        <property name="nameUser" column="nameUser"/>  
        <!--  这样就构成了一个多对一的关系 -->
        <many-to-one name="group" column="groupId"></many-to-one> 
    </class>
    </hibernate-mapping>
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

通过在User.hbm.xml文件中，加入

 <many-to-one name="group" column="groupId"></many-to-one> 
 
 
1

就构建了多对一的关联关系。

2、一对多的单向关联关系

在类实体的层面上：在一的一方存在多方的集合

在数据库的层面上：在多方加外键

下面就以一个工作小组可以有多个用户，而一个用户只能属于一个小组，这个例子来进行设计介绍如何建立一个一对多的关联关系。

2.1、一对多单向的关联关系的Annotation实现

先看多的这方：User类

@Entity
    @Table(name="t_user")  //指定表名
    public class User {
    private int idUser;
    private String nameUser;
    @Id
    @GeneratedValue
    public int getIdUser() {
        return idUser;
    }
    public void setIdUser(int idUser) {
        this.idUser = idUser;
    }
    public String getNameUser() {
        return nameUser;
    }
    public void setNameUser(String nameUser) {
        this.nameUser = nameUser;
    }
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

再看一的这方：Group类

由于是一对多的关系，因此在一的这方必须要有一个容器，这里采用的Set，Set容器可以用来避免重复，数据库中也是不允许主键重复的，与我们数据库的逻辑是符合的。

然后在Set容器的get方法上采用@OneToMany注解来进行修饰。并通过@JoinColumn(name=”groupId”)来指定外键名(外键在多的一方的表中生成)。

@Entity
    @Table(name="t_group")  //指定表名
    public class Group {
    private int idGroup;
    private String nameGroup;
    private Set<User> set=new HashSet<User>();
    @OneToMany   //一对多关系的指定
    @JoinColumn(name="groupId")
    public Set<User> getSet() {
        return set;
    }
    public void setSet(Set<User> set) {
        this.set = set;
    }
    @Id
    @GeneratedValue
    public int getIdGroup() {
        return idGroup;
    }
    public void setIdGroup(int idGroup) {
        this.idGroup = idGroup;
    }
    public String getNameGroup() {
        return nameGroup;
    }
    public void setNameGroup(String nameGroup) {
        this.nameGroup = nameGroup;
    }


    }
 
 
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

测试结果如下：

如果我们不通过@JoinColumn(name=”groupId”)来指定外键名(外键在多的一方的表中生成)，则Hibernate会为我们生成一个中间表，即将一对多当成多对多来进行处理了。

测试结果如下：

2.2、一对多单向的关联关系的XXX.hbm.xml实现

Group类

public class Group {
    private int idGroup;
    private String nameGroup;
    private Set<User> set=new HashSet<User>();
    public Set<User> getSet() {
        return set;
    }
    public void setSet(Set<User> set) {
        this.set = set;
    }
    public int getIdGroup() {
        return idGroup;
    }
    public void setIdGroup(int idGroup) {
        this.idGroup = idGroup;
    }
    public String getNameGroup() {
        return nameGroup;
    }
    public void setNameGroup(String nameGroup) {
        this.nameGroup = nameGroup;
    }
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在Group.bhm.xml文件： 
主要是为Group类中的Set属性，添加如下的代码即可构成一对多的关联关系：

<set name="set" >
            <key column="groupId"></key>
            <one-to-many class="com.hibernate.model.User"/>
 </set> 
 
 
1
2
3
4

完整内容如下：

<?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="com.hibernate.model">
    <class name="Group" table="t_group" >
        <id name="idGroup" column="idGroup">
            <generator class="native"/>
        </id>
        <property name="nameGroup" column="nameGroup"/>  
        <set name="set" >
            <key column="groupId"></key>
            <one-to-many class="com.hibernate.model.User"/>
        </set> 
    </class>
    </hibernate-mapping>
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

User类

public class User {
    private int idUser;
    private String nameUser;
    public int getIdUser() {
        return idUser;
    }
    public void setIdUser(int idUser) {
        this.idUser = idUser;
    }
    public String getNameUser() {
        return nameUser;
    }
    public void setNameUser(String nameUser) {
        this.nameUser = nameUser;
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

User.hbm.xml文件

<?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="com.hibernate.model">
    <class name="User" table="t_user" >
        <id name="idUser" column="id">
            <generator class="native"/>
        </id>
        <property name="nameUser" column="nameUser"/>  
    </class>
    </hibernate-mapping>
 
 
1
2
3
4
5
6
7
8
9
10
11
12

一对多(多对一)双向关联

在我们了解了一对多和多对一的单向关联之后，双向关联就相当简单了，就是将这两者的单向关联进行合并即可。下面只介绍下使用Annotation来构建双向关联。

在一的一方：Group实体类

类似构建一对多。

只是有一点需要注意：指定mappedBy

代码如下：

@Entity
    @Table(name="t_group")  //指定表名
    public class Group {
    private int idGroup;
    private String nameGroup;
    private Set<User> set=new HashSet<User>();
    @OneToMany(mappedBy="group")   //一对多关系的指定   且由于是双向关联，必须指定mappedBy，否则会生成两个外键。
    public Set<User> getSet() {
        return set;
    }
    public void setSet(Set<User> set) {
        this.set = set;
    }
    @Id
    @GeneratedValue
    public int getIdGroup() {
        return idGroup;
    }
    public void setIdGroup(int idGroup) {
        this.idGroup = idGroup;
    }
    public String getNameGroup() {
        return nameGroup;
    }
    public void setNameGroup(String nameGroup) {
        this.nameGroup = nameGroup;
    }

    }
 
 
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

在多的一方的User类

类似构建多对一的关联即可。

@Entity
    @Table(name="t_user")  //指定表名
    public class User {
    private int idUser;
    private String nameUser;
    private Group group;
    @ManyToOne
    @JoinColumn(name="groupId")
    public Group getGroup() {
        return group;
    }
    public void setGroup(Group group) {
        this.group = group;
    }
    @Id
    @GeneratedValue
    public int getIdUser() {
        return idUser;
    }
    public void setIdUser(int idUser) {
        this.idUser = idUser;
    }
    public String getNameUser() {
        return nameUser;
    }
    public void setNameUser(String nameUser) {
        this.nameUser = nameUser;
    }
    }
 
 
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

这样就Ok了。

小结

多对一和一对多的单向关联关系的Annotation和XXX.hbm.xml文件的实现均比较简单。

from: http://blog.csdn.net/u010412719/article/details/51335064