Hibernate之关联映射（上）

关联映射可分为四种：
分别为：一对一，一对多，多对一，多对多。
1、一对多和多对一：适用于一个部门有多个员工等场景。
用买家与订单的关系来做演示：
买家：User.java

public class User {    private int uId;    private String uPassword;    private Set<String> addresses=new HashSet<String>();    private Set<Good> goods=new HashSet<Good>();    public int getuId() {        return uId;    }    public void setuId(int uId) {        this.uId = uId;    }    public String getuPassword() {        return uPassword;    }    public void setuPassword(String uPassword) {        this.uPassword = uPassword;    }    public Set<String> getAddresses() {        return addresses;    }    public void setAddresses(Set<String> addresses) {        this.addresses = addresses;    }    public Set<Good> getGoods() {        return goods;    }    public void setGoods(Set<Good> goods) {        this.goods = goods;    }    @Override    public String toString() {        return "User [uId=" + uId + ", uPassword=" + uPassword + ", addresses=" + addresses + ", goods=" + goods + "]";    }}

User的映射文件：User.hbm.xml

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <!--package是否可以省略?            可以            省略之后类的名字 编写全路径就OK了                   default-lazy="false" -->        <hibernate-mapping  package="com.wc.entity"  >     <!--一个class就相当于对应了一张表         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)         abstract="true" lazy="true"         table:是否可以省略?                        可以的                        省略之后默认的表明就是实体的名字    -->    <class name="User" table="u_user">       <!--配置的主键          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性           column:这个是用来定义这个列的列名的          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型          column:可以省略 默认的字段就是属性的名字            type:也可以省略:默认的类型和实体的数据类型是一样的        -->        <id name="uId">            <generator class="native"></generator>        </id>        <!--配置的是普通的列            property:设置的是普通的列              column:列名(当前对象的属性在数据库中对应的列名)  可以省略            lazy:是否支持懒惰性的加载  :也默认值            not-null:是否可以为null            unique:是否这个列的值是唯一的            type:可以省略 默认数据类型和实体中的属性的类型一直            length:设置的是长度(有点必须的)        -->        <property name="uPassword"></property>        <set name="addresses" table="t_address" cascade="save-update">            <key column="uId"></key>             <element column="address" type="java.lang.String"></element>        </set>        <set name="goods" table="t_good" cascade="save-update">            <key column="uId"></key>            <one-to-many class="Good" />        </set>    </class></hibernate-mapping>

一对多的主要代码：当用一的一边去维护多的一边，配置该关联。（用买家去维护订单）

    <set name="goods" table="t_good" cascade="save-update">            <key column="uId"></key>            <one-to-many class="Good" />        </set>

订单：Good.java

public class Good {    private int gId;    private String gName;    private User user;    private String address;    public int getgId() {        return gId;    }    public void setgId(int gId) {        this.gId = gId;    }    public String getgName() {        return gName;    }    public void setgName(String gName) {        this.gName = gName;    }    public User getUser() {        return user;    }    public void setUser(User user) {        this.user = user;    }    public String getAddress() {        return address;    }    public void setAddress(String address) {        this.address = address;    }    public Good(String gName, String address) {        super();        this.gName = gName;        this.address = address;    }    @Override    public String toString() {        return "Good [gId=" + gId + ", gName=" + gName + ", address=" + address + "]";    }    public Good() {        super();    }}

订单的配置文件：Good.hbm.xml

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <!--package是否可以省略?            可以            省略之后类的名字 编写全路径就OK了        -->        <hibernate-mapping  package="com.wc.entity">     <!--一个class就相当于对应了一张表         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)         abstract="true" lazy="true"         table:是否可以省略?                        可以的                        省略之后默认的表明就是实体的名字    -->    <class name="Good" table="u_good">       <!--配置的主键          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性           column:这个是用来定义这个列的列名的          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型          column:可以省略 默认的字段就是属性的名字            type:也可以省略:默认的类型和实体的数据类型是一样的        -->        <id name="gId">            <generator class="native"></generator>        </id>        <!--配置的是普通的列            property:设置的是普通的列                    column:列名(当前对象的属性在数据库中对应的列名)  可以省略            lazy:是否支持懒惰性的加载  :也默认值            not-null:是否可以为null            unique:是否这个列的值是唯一的            type:可以省略 默认数据类型和实体中的属性的类型一直            length:设置的是长度(有点必须的)        -->        <property name="gName"></property>        <many-to-one name="user" class="User" column="uId" cascade="all"></many-to-one>       <property name="address"></property>    </class></hibernate-mapping>

多对一的主要代码：当用多的一边去维护一的一边，配置该关联。（订单去维护买家）

 <many-to-one name="user" class="User" column="uId" cascade="all"></many-to-one>

注意：多对一与一对多，用哪一边去维护另一边，就用哪一边来配置映射文件的关系。也可以两边都配。（T维护t：就是通过T去绑定t,换句话说，就是在创建T对象的时候，把t作为T的属性）

2、多对多：适用于老师与学生的这种关系
老师有多个学生，学生有多个老师。
实例：
学生类：Student.java

public class Student {    private int sId;    private String sPassword;    private Set<Teacher> teachers=new HashSet<Teacher>();    public int getsId() {        return sId;    }    public void setsId(int sId) {        this.sId = sId;    }    public String getsPassword() {        return sPassword;    }    public void setsPassword(String sPassword) {        this.sPassword = sPassword;    }    public Set<Teacher> getTeachers() {        return teachers;    }    public void setTeachers(Set<Teacher> teachers) {        this.teachers = teachers;    }}

学生映射文件：Student.hbm.xml

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <!--package是否可以省略?            可以            省略之后类的名字 编写全路径就OK了        -->        <hibernate-mapping  package="com.wc.entity"  default-lazy="false">     <!--一个class就相当于对应了一张表         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)         abstract="true" lazy="true"         table:是否可以省略?                        可以的                        省略之后默认的表明就是实体的名字    -->    <class name="Student" table="u_student">       <!--配置的主键          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性           column:这个是用来定义这个列的列名的          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型          column:可以省略 默认的字段就是属性的名字            type:也可以省略:默认的类型和实体的数据类型是一样的        -->        <id name="sId">            <generator class="native"></generator>        </id>        <!--配置的是普通的列            property:设置的是普通的列              column:列名(当前对象的属性在数据库中对应的列名)  可以省略            lazy:是否支持懒惰性的加载  :也默认值            not-null:是否可以为null            unique:是否这个列的值是唯一的            type:可以省略 默认数据类型和实体中的属性的类型一直            length:设置的是长度(有点必须的)        -->        <property name="sPassword"></property>        <set name="teachers" table="t_real" cascade="save-update">            <key column="sId"></key>            <many-to-many class="Teacher" column="tId"></many-to-many>        </set>    </class></hibernate-mapping>

主要代码：

    <set name="teachers" table="t_real" cascade="save-update">            <key column="sId"></key>            <many-to-many class="Teacher" column="tId"></many-to-many>        </set>

老师类：Teacher.java

public class Teacher {    private int tId;    private String tName;    private Set<Student> students=new HashSet<Student>();    public int gettId() {        return tId;    }    public void settId(int tId) {        this.tId = tId;    }    public String gettName() {        return tName;    }    public void settName(String tName) {        this.tName = tName;    }    public Set<Student> getStudents() {        return students;    }    public void setStudents(Set<Student> students) {        this.students = students;    }}

映射文件：Teacher.hbm.xml

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <!--package是否可以省略?            可以            省略之后类的名字 编写全路径就OK了        -->        <hibernate-mapping  package="com.wc.entity"  default-lazy="false">     <!--一个class就相当于对应了一张表         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)         abstract="true" lazy="true"         table:是否可以省略?                        可以的                        省略之后默认的表明就是实体的名字    -->    <class name="Teacher" table="u_user">       <!--配置的主键          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性           column:这个是用来定义这个列的列名的          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型          column:可以省略 默认的字段就是属性的名字            type:也可以省略:默认的类型和实体的数据类型是一样的        -->        <id name="tId">            <generator class="native"></generator>        </id>        <!--配置的是普通的列            property:设置的是普通的列              column:列名(当前对象的属性在数据库中对应的列名)  可以省略            lazy:是否支持懒惰性的加载  :也默认值            not-null:是否可以为null            unique:是否这个列的值是唯一的            type:可以省略 默认数据类型和实体中的属性的类型一直            length:设置的是长度(有点必须的)        -->        <property name="tName"></property>        <set name="students" table="t_real" cascade="save-update">            <key column="tId"></key>            <many-to-many class="Student" column="sId"></many-to-many>        </set>     </class></hibernate-mapping>

主要代码：

<set name="students" table="t_real" cascade="save-update">            <key column="tId"></key>            <many-to-many class="Student" column="sId"></many-to-many>        </set> 

T维护t，就在T的映射文件中配置多对多的映射关系。也可以两边都配。