hibernate笔记1

1.  数据库中的表关系

一对一、一对多（多对一）、多对一

2.  如何确立表中的表关系

一对多的关系如何实现：使用外键约束，一的方称为主表，多的方称为从表。

外键：从表中有一列，该列的取值除了null之外，只能来源于主表的主键，默认情况下，外键字段的值是可以重复的

多对多的表关系如何实现？

使用中间表，中间表只能有两个外键，引用两个多对多表的主键，不能有其他字段信息，中间表的主键采用联合主键

如果任何一个多方的表和中间表比较，都是一对多的关系。

一对一的表关系在数据库中如何实现？两种

1.建立外键的方式：

使用外键约束、唯一约束、非空约束，他是把外键约束加了唯一约束和非空约束，从而实现一对一。

2.使用主键的方式：

让其中一张表既是主键，又是外键

如何确定两张表之间的关系：找外键

3.  多表映射遵循的步骤

第一步：确立两张表之间的关系

第二步：在数据库中实现多对多的表关系的建立

第三步：在实体类中描述出两个实体类之间的关系

第四步：在映射配置中建立两张表和两个实体之间的关系

4.  一对多关系映射配置及其操作

实例：客户和联系人两张表

第一步：确立两张表之间的关系

  一个客户可以包含多个联系人，多个联系人可以属于同一个客户，所以客户和联系人是多对多的关系

第二步：在数据库中实现多对多的表关系的建立

  实现一对多的关系靠的是外键，客户是主表，联系人是从表，需要在联系人表中添加外键

第三步：在实体类中描述出两个实体类之间的关系

  主表的实体类包含从表实体类的集合引用

<!-- 一对多主表实体的配置

        标签

           Set

           用于配置set集合属性

           属性：

           name：指定实体类中set集合的属性名称

           table:指定从表的名称，在一对多配置时候，可以不写

           key

           作用：用于映射外键字段

           属性：

           column：指定外键字段名称

           one-to-many:

           作用：用于建立一对多的映射配置

           属性：

           class：用于指定从表实体的名称

        -->

        <set name="linkmans" table="cust_linkman">

            <key column="lkm_cust_id" ></key>

            <one-to-many class="LinkMan"></one-to-many>

        </set>

  从表的实体类应该包含主表实体类的对象引用

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

    <hibernate-mapping package="com.wbs.domain">

        <class name="LinkMan" table="cust_linkman">

        <id name="lkmId" column="lkm_id">

            <generator class="native"></generator>

        </id>

        <property name="lkmName" column="cust_lkmName"></property>

        <property name="lkmGender"  column="cust_lkmGender"></property>

        <property name="lkmPhone" column="cust_lkmPhone"></property>

        <property name="lkmMobile" column="cust_lkmMobile"></property>

        <property name="lkmEmail" column="cust_lkmEmail"></property>

        <property name="lkmPosition" column="cust_lkmPosition"></property>

        <property name="lkmMemo" column="cust_lkmMemo"></property>

        <!-- 一对多关系映射：从表实体的映射配置 -->

        <!-- many-to-one建立一对多的映射配置

        属性：

        name 从表实体中引用实体对象引用的名称

        class 指定这个属性对应的实体类名称

        column 指定从表中外键字段的名称

         -->

        <many-to-one name="customer" class="Customer" column="lkm_cust_id"></many-to-one>

        </class>

第四步：在映射配置中建立两张表和两个实体之间的关系

字符在数据库中用char或者varchar,但是在实体类中用String或者Criteria

1. 1.  多对多关系映射配置及其操作
   1. 1.  确定两张表之间的关系

一个用户可以有多个角色

一个角色可以赋给多个角色

所以用于和角色之间是多对多

1. 2.  数据库中两张表之间的关系建立

在数据库中实现多对多要靠中间表

中间表只能出现用户和角色的主键

1. 3.  在实体类中描述出两个实体类之间的关系

各自包含对方一个集合引用

下边是多对多关系中的一个映射配置文件中的一部分

<!--

        set

        用于映射集合属性

            属性：

            name:用于指定集合名称

            table:指的是中间表的名称（多对多的表中间一定要写）

        key：用于映射外键字段

            key中的属性column指的是当前实体在中间表的外键字段名称

        many-to-many:用于映射多对多关系

            属性：

            column：对方在中间表中的外键字段名称

            class:对方的实体类名称

         -->

        <set name="roles" table="user_role_ref">

            <key column="user_id"></key>

            <many-to-many class="SysRole" column="role_id"></many-to-many>

    </set>

上边是数据库里面创建联合主键的方式

1. 2.  进行多对多之间的保存操作

需要在任何一个set配置inverse=true,让某个实体类放弃维护关系，才可以正常的执行保存功能。

public class HibernateDemo1 {

    /**

     * 保存操作；

     * 创建两个用户和三个角色

     * 让1号用户具备具备1号和2号角色

     * 让2号用户具备具备3号和2号角色

     * 保存用户和角色

     */

    @Test

    public void test1(){

       SysUser u1=new SysUser();

       u1.setUserName("用户1");

       SysUser u2=new SysUser();

       u1.setUserName("用户2");

       SysRole r1=new SysRole();

       r1.setRoleName("角色1");

       SysRole r2=new SysRole();

       r1.setRoleName("角色2");

       SysRole r3=new SysRole();

       r1.setRoleName("角色3");

       //建立双向关联关系

       u1.getRoles().add(r1);

       u1.getRoles().add(r2);

       u2.getRoles().add(r2);

       u2.getRoles().add(r3);

       //再建立角色

       r1.getUsers().add(u1);

       r2.getUsers().add(u1);

       r2.getUsers().add(u2);

       r3.getUsers().add(u2);

       Session s=HibernateUtils.getCurrentSession();

       Transaction tx=s.beginTransaction();

       s.save(r3);

       s.save(r2);

       s.save(r1);

       s.save(u1);

       s.save(u2);

       tx.commit();

    }

1. 删除操作（实际开发禁止使用）

但是需要级联删除的时候需要配置级联的任一个配置文件的inverse=true，需要在两个多对多的实体类的配置文件中写出cascade=delete，不然不会级联删除

<set name="users" table="user_role_ref" inverse="true" cascade="delete">

            <key column="role_id"></key>

            <many-to-many class="SysUser" column="user_id"></many-to-many>

    </set>

 /**

     * 删除操作

     * 实际开发中多对多的双向级联删除是禁止的

     */

    @Test

    public void test2(){

       Session s=HibernateUtils.getCurrentSession();

       Transaction tx=s.beginTransaction();

       //查询ID为103的用户

       SysUser u=s.get(SysUser.class, 115L);

       System.out.println(u);

       s.delete(u);

       tx.commit();

}