Hibernate级联之一对多和inverse解析

hibernate的级联可以说是hibernate最重要的部分，只有深入了解了级联的特性与用法，才能运用自如。

　　这次讨论一对多的情况，所以就使用博客项目的用户表和博客表作为示例，来一起学习hibernate的级联

基本准备

文件结构：

hibernate核心配置文件hibernate.cfg.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    
<hibernate-configuration>
    <!-- 先配置SessionFactory标签，一个数据库对应一个SessionFactory标签 -->
    <session-factory>
        <!-- 必须的配置的参数5个，4个连接参数，1个数据库方言 -->
        <!--
        #hibernate.connection.driver_class com.mysql.jdbc.Driver
        #hibernate.connection.url jdbc:mysql:///test
        #hibernate.connection.username gavin
        #hibernate.connection.password 
        数据库方言
        #hibernate.dialect org.hibernate.dialect.MySQLDialect
         -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///blog</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 可选配置 -->
        <!-- 显示sql语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化sql语句 -->
        <property name="hibernate.format_sql">false</property>
        <!-- 生成数据库的表结构 
        (hbm2dd全称hibernate mapping to db define language auto create)
        update 没表会自动创建，有表添加数据。
            如果开发中间需要添加字段，可以在实体类添加属性。update会自动在数据库添加字段，并且不改变原来数据库值
        validate 校验实体属性和数据库是否一致
        -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        
        <!-- 映射配置文件，可以在map配置文件右键copy qualified name-->
        <mapping resource="com/cky/domain/User.hbm.xml"/>
        <mapping resource="com/cky/domain/Blog.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

如果对hibernate的配置还不是很清楚，可以看看这里

实体类的创建

　　Hibernate中，可以直接将表的关系用对象表示。

　　如本例中，一个博客只能有一个作者，所以Blog就可以添加一个User对象。

　　一个用户有多个博客，所以可以在User中添加一个Blog的Set集合。

　　这里需要注意的是如果关联的是一个对象，那么不能在类中进行初始化new操作。

　　如果关联的是一个集合，那么必须用HashSet在类中进行初始化new操作

实体类Blog.java

package com.cky.domain;

import java.sql.Timestamp;

public class Blog {
    private int bId;
    private String bSubject;
    private String bContent;
    private Timestamp createtime;
    private Timestamp updatetime;
    //hibernate中关联对象不能初始化
    private User user;
    
    //...getter setter 方法省略
    public int getbId() {
        return bId;
    }
    public void setbId(int bId) {
        this.bId = bId;
    }
    public String getbSubject() {
        return bSubject;
    }
    public void setbSubject(String bSubject) {
        this.bSubject = bSubject;
    }
    public String getbContent() {
        return bContent;
    }
    public void setbContent(String bContent) {
        this.bContent = bContent;
    }
    public Timestamp getCreatetime() {
        return createtime;
    }
    public void setCreatetime(Timestamp createtime) {
        this.createtime = createtime;
    }
    public Timestamp getUpdatetime() {
        return updatetime;
    }
    public void setUpdatetime(Timestamp updatetime) {
        this.updatetime = updatetime;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    
    
}

实体类User.java

package com.cky.domain;

import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Set;

public class User {
    private Integer uId;
    private String uEmail;
    private String uName;
    private String uUsername;
    private String uPassword;
    private String uAge;
    private String uDetail;
    private String uAvatar;
    private String isAdmin;
    private Timestamp createtime;
    private Timestamp updatetime;
    //hibernate的集合必须初始化
    private Set<Blog> blogs=new HashSet<Blog>();
    
    //...getter setter 方法省略
    public Integer getuId() {
        return uId;
    }
    public void setuId(Integer uId) {
        this.uId = uId;
    }
    public String getuEmail() {
        return uEmail;
    }
    public void setuEmail(String uEmail) {
        this.uEmail = uEmail;
    }
    public String getuName() {
        return uName;
    }
    public void setuName(String uName) {
        this.uName = uName;
    }
    public String getuUsername() {
        return uUsername;
    }
    public void setuUsername(String uUsername) {
        this.uUsername = uUsername;
    }
    public String getuPassword() {
        return uPassword;
    }
    public void setuPassword(String uPassword) {
        this.uPassword = uPassword;
    }
    public String getuAge() {
        return uAge;
    }
    public void setuAge(String uAge) {
        this.uAge = uAge;
    }
    public String getuDetail() {
        return uDetail;
    }
    public void setuDetail(String uDetail) {
        this.uDetail = uDetail;
    }
    public String getuAvatar() {
        return uAvatar;
    }
    public void setuAvatar(String uAvatar) {
        this.uAvatar = uAvatar;
    }
    public String getIsAdmin() {
        return isAdmin;
    }
    public void setIsAdmin(String isAdmin) {
        this.isAdmin = isAdmin;
    }
    public Timestamp getCreatetime() {
        return createtime;
    }
    public void setCreatetime(Timestamp createtime) {
        this.createtime = createtime;
    }
    public Timestamp getUpdatetime() {
        return updatetime;
    }
    public void setUpdatetime(Timestamp updatetime) {
        this.updatetime = updatetime;
    }
    public Set<Blog> getBlogs() {
        return blogs;
    }
    public void setBlogs(Set<Blog> blogs) {
        this.blogs = blogs;
    }

    
}

编写基础映射文件

　　多对一情况映射文件的编写

　　多对一时，使用<many-to-one>标签，只需要指定三个属性：

　　name：指定此标签所映射的属性名

　　class：关联的表所对应的实体类的全限定类名

　　column：关联表的外键名

　　Blog.hbm.xml文件具体内容

<?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>
    <class name="com.cky.domain.Blog"  table="blog">
        <id name="bId" column="b_id">
            <generator class="native"></generator>
        </id>
        <!-- 普通属性 -->
        <property name="bSubject" column="b_subject"></property>
        <property name="bContent" column="b_content"></property>
        <property name="createtime" column="createtime"></property>
        <property name="updatetime" column="updatetime"></property>
        <!-- 
        private User user; 
        多对一 配置-->
        <many-to-one name="user" class="com.cky.domain.User" column="u_id" ></many-to-one>
    </class>
</hibernate-mapping>

　　一对多情况映射文件的编写

　　与多对一情况不同的是，一对多时关联对象是一个set集合。

　　配置文件需要使用<set>标签来和集合对象建立联系，其中的name指定对应的属性名

　　在<set>中，需要指定查询关联对象所需要的表（实体类）和比较字段（外键）

　　User.hbm.xml具体如下：

　　

<?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>
<class name="com.cky.domain.User" table="user">
<!-- 配置id
    name实体类属性，column表字段，如果一样，column可以省略。-->
    <id name="uId" column="u_id">
    <!-- 主键生成策略 -->
        <generator class="native"></generator>
    </id>
    <!-- 普通属性-->
    <property name="uEmail" column="u_email"></property>
    <property name="uName" column="u_name"></property>
    <property name="uUsername" column="u_username"></property>
    <property name="uPassword" column="u_password"></property>
    <property name="uAge" column="u_age"></property>
    <property name="uDetail" column="u_detail"></property>
    <property name="uAvatar" column="u_avatar"></property>
    <property name="isAdmin" column="is_admin"></property>
    <property name="createtime" column="createtime"></property>
    <property name="updatetime" column="updatetime"></property>
    <!-- private Set<Blog> blogs=new HashSet<Blog>();
        集合的配置
        name:这个类中对应的属性名
     -->
     <set name="blogs">
         <!--column： 外键，hibernate会根据这个字段来查询与这个对象对应的多端的所有对象 -->
         <key column="u_id"></key>
         <!--class：集合代表的实体类，同时也代表要查询的表。
                 与上面的条件结合，就可以查询出表中所有外键字段为指定值的所有结果的集合。
             -->
         <one-to-many class="com.cky.domain.Blog"/>
     </set>
</class>
</hibernate-mapping>

 为了方便使用，还需要一个工具类HibernateUtils.java，很简单就不介绍了，下面是代码：

package com.cky.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {
    //ctrl+shift+x
    private static final Configuration CONFIG;
    private static final SessionFactory FACTORY;
    
    //编写静态代码块
    static {
        //加载XML的配置文件
        CONFIG =new Configuration().configure();
        //构造工作
        FACTORY=CONFIG.buildSessionFactory();
    }
    /**
     * 从工厂获取session对象
     */
    public static Session getSession() {
        return FACTORY.openSession();
    }
}

测试基础配置（不使用级联）

到这里，基本的配置都设置完了，接下来测试配置的怎么样

package com.cky.Demo;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.cky.domain.Blog;
import com.cky.domain.User;
import com.cky.utils.HibernateUtils;

public class CascadeTest {
    @Test
    public void testMTO2() {
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        //保存用户和博客
        User user=new User();
        user.setuName("王五");
        
        Blog blog1=new Blog();
        blog1.setbSubject("王五日常一");
        blog1.setbContent("看电视");
        
        Blog blog2=new Blog();
        blog2.setbSubject("王五日常二");
        blog2.setbContent("玩游戏");
       　//为用户添加博客
        user.getBlogs().add(blog1);
        user.getBlogs().add(blog2);
        //保存用户
        session.save(user);
        
        tr.commit();
        session.close();
    }       
}

什么，居然报错了：TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing

翻译一下，大致意思就是user对象引用了一个瞬时对象，因为当save(user)时，user已经被保存到缓存成为持久态对象，而给他添加的blog1和blog2，因为没有设置级联，所以不会被自动添加到缓存中，依然是瞬时态对象。

解决方法就是把两个blog1和blog2也进行save(),保存到session中：

@Test
    public void testMTO2() {
       //.....上面省略
        //保存用户
        session.save(user);
        session.save(blog1);
        session.save(blog2);
        tr.commit();
        session.close();
    }       

 关于级联

　　hibernate中用cascade属性设置级联。

　　在基础的配置中，因为没有设置级联，默认是none，也就是不进行级联操作。

　　就如上面的代码一样，我们需要手动的保证对象和他级联的对象都在同一状态，才能正确运行，这显然是很麻烦的，下面就看看如何通过设置级联属性来让代码更简单。

　　cascade取值共有5个：

　　　　none 　　　　默认值，不级联

　　　　save-update 　在保存、更新操作时自动级联保存更新关联对象

　　　　delete　　　　在删除时自动级联删除关联对象

　　　　all　　　　　　类似save-update-delete，即所以的操作都会级联

　　　　all-delete-orphan 解除某一节点的关系时删除该节点（默认只是清除外键关系）

　　接下来就在上面的基础配置上添加上面的属性看看有什么区别：

　　save-update：

　　为user配置文件的添加cascade属性

<set name="blogs" cascade="save-update">
    <key column="u_id"></key>
    <one-to-many class="com.cky.domain.Blog" />
</set>

此时我们运行上次报错的那段代码：

@Test
    public void testMTO() {
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        //保存用户和博客
        User user=new User();
        user.setuName("王五");
        
        Blog blog1=new Blog();
        blog1.setbSubject("王五日常一");
        blog1.setbContent("看电视");
        
        Blog blog2=new Blog();
        blog2.setbSubject("王五日常二");
        blog2.setbContent("玩游戏");
        
        user.getBlogs().add(blog1);
        user.getBlogs().add(blog2);
        
        blog1.setUser(user);
        blog2.setUser(user);
        //自动关联
        session.save(user);
                //删除掉保存blog的代码
        
        tr.commit();
        session.close();
    }

发现可以正确执行，因为保存user时，会自动级联保存两个blog，所以他们就全是持久态。

　　我们同时为blog配置文件添加cascade属性

<many-to-one name="user" 
　　class="com.cky.domain.User"   
　　column="u_id"  
　　cascade="save-update"></many-to-one>

然后保存一个blog看看会发生什么

@Test
    public void testMTO() {
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();

        User user=new User();
        user.setuName("王五");
        
        Blog blog1=new Blog();
        blog1.setbSubject("王五日常一");
        blog1.setbContent("看电视");
        
        Blog blog2=new Blog();
        blog2.setbSubject("王五日常二");
        blog2.setbContent("玩游戏");

        user.getBlogs().add(blog1);
        user.getBlogs().add(blog2);
        
        blog1.setUser(user);
        blog2.setUser(user);
        
        /*session.save(user);
        session.save(blog1);*/
        //只保存blog2
        session.save(blog2);
        
        tr.commit();
        session.close();
    }

运行成功，不过更有意思的是他保存了三条信息，而不是两条。

因为当保存 blog2 时，会级联保存 user ，而user又会级联把 blog1 保存

删除也是同样的道理，就不演示了，下面再研究一个all-delete-orphan，传说的孤儿删除

　　关于all-delete-orphan

all-delete-orphan上面已经简单介绍过，就是解除关系时会把节点删除而不只是删除外键。

我们把使用和不使用孤儿删除分别用代码实现，并做一次比较：

正常情况下的解除关系：

　　原来的blog表中两条数据都和user id=1产生关系

现在我们把user和其中一个blog id=1解除关系

//普通解除关系
    @Test
    public void testMTO4() {
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        
        User user=(User) session.get(User.class, 1);
        Blog blog=(Blog) session.get(Blog.class, 1);
        //解除关系只需要把user集合中的blog移除即可
        user.getBlogs().remove(blog);
        
        tr.commit();
        session.close();
    }

运行sql:

再看看表情况：

正常情况，解除关系只是删除外键。

使用all-delete-orphan时解除关系：

为user配置文件添加all-delete-orphan

 <set name="blogs" cascade="all-delete-orphan">
     <key column="u_id"></key>
     <one-to-many class="com.cky.domain.Blog" />
</set>

执行同样的代码解除关系：

//孤儿删除
    @Test
    public void testMTO4() {
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        
        User user=(User) session.get(User.class, 1);
        Blog blog=(Blog) session.get(Blog.class, 1);
        //解除关系只需要把user集合中的blog移除即可
        user.getBlogs().remove(blog);
        
        tr.commit();
        session.close();
    }

sql的执行情况

数据表变化：

关于inverse(外键维护)

 什么是外键维护呢？

　　就是在两个关联对象中，如果关系发生改变需要修改外键。这么一说感觉这个功能肯定是必备的，要不然这么保证对象之间的关系呢？

　　在hibernate是根据对象关系来判断是否要维护外键。

　　这里有两个关键字，对象关系和外键。

　　什么是对象关系？在hibernate中就是你这个对象A存的有对象B的引用，那么对象A就有对象B的的对象关系。有趣的是，对象关系可以是单向的，即A有B的对象关系，B不一定有A的对象关系。Hibernate是根据对象的对象关系来进行外键处理的。如果两边的对象关系都改变，那么默认hibernate都会进行外键处理（处理两次）。

　　举个例子

　　user1有blog1和blog2俩对象关系  、user2有blog3和blog4俩对象关系

　　1.现在我们把blog3添加到user1中（对象关系改变）

　　2.因为这时blog3中的user还是user2，还要把blog3的user换成user1（对象关系改变）

　　上面两个操作都改变了对象关系，如之前说的，session的缓存和快照不一致了，对于User对象，需要更新外键，对于Blog对象，也需要更新外键。

　　但是，他们更新的是同一外键，也就是说对同一外键更新了两次，多了一个无意义的操作无疑增加了数据库的压力。

　　

　　也许有人可能会说，我不执行步骤2不就行了，结果还是正确的，还减少了sql。

　　但是按照人的思维定式，在不知道的情况还是会按上面两个步骤走，感觉更合理。

　　所以解决方法就在一方放弃外键维护。并且在多对多的情况下必须有一方需要放弃外键，否者程序无法运行。