Hibernate框架(3) - 对象状态 / 一级缓存 / 映射

对象的状态

Hibernate中对象的状态 : 临时/瞬时状态、持久化状态、游离状态
- 临时状态
  - 特点：
    - 直接new出来的对象;
    - 不处于session的管理;
    - 数据库中没有对象的记录;
- 持久化状态 : 当调用session的save/saveOrUpdate/get/load/list等方法的时候，对象就是持久化状态。处于持久化状态的对象，当对对象属性进行更改的时候，会反映到数据库中!
  - 特点：
    - 处于session的管理;
    - 数据库中有对应的记录;
- 游离状态
  - 特点
    - 不处于session的管理
    - 数据库中有对应的记录
    - Session关闭后，对象的状态
对象状态的转换 :

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
    //1. 对象状态的转换
    @Test
    public void testSaveSet() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 创建对象                     【临时状态】
//      User user = new User();
//      user.setUserName("Jack22222");
        // 保存                           【持久化状态】
//      session.save(user);     
//      user.setUserName("Jack333333");  // 会反映到数据库
        
        // 查询
        User user = (User) session.get(User.class, 5);
        user.setUserName("Tomcat");// hibernate会自动与数据库匹配（一级缓存），如果一样就更新数据库
        
        session.getTransaction().commit();
        session.close();
    
        user.setUserName("Jack444444444");
        // 打印                           【游离状态】
        System.out.println(user.getUserId());
        System.out.println(user.getUserName());
    }

一级缓存

为什么要用缓存？
- 目的：减少对数据库的访问次数！从而提升hibernate的执行效率！
Hibernate中缓存分类 :
- 一级缓存
- 二级缓存
一级缓存概念 :
1）Hibenate中一级缓存，也叫做session的缓存，它可以在session范围内减少数据库的访问次数! 只在session范围有效！ Session关闭，一级缓存失效!
2）当调用session的save/saveOrUpdate/get/load/list/iterator方法的时候，都会把对象放入session的缓存中。
3）Session的缓存由hibernate维护，用户不能操作缓存内容；如果想操作缓存内容，必须通过hibernate提供的evit/clear方法操作。
特点：
- 只在(当前)session范围有效，作用时间短，效果不是特别明显！
- 在短时间内多次操作数据库，效果比较明显！
缓存相关几个方法的作用
- session.flush() : 让一级缓存与数据库同步
- session.evict(arg0) : 清空一级缓存中指定的对象
- session.clear() : 清空一级缓存中缓存的所有对象
在什么情况用上面方法？
- 批量操作使用使用：
  - Session.flush(); // 先与数据库同步
  - Session.clear(); // 再清空一级缓存内容
查询方法:
- list : 会放入缓存，但不会从缓存中获取数据

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
@Test
    public void list() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        // HQL查询
        Query q = session.createQuery("from User ");
        // list()方法
        List<User> list = q.list();
        
        for (int i=0; i<list.size(); i++){
            System.out.println(list.get(i));
        }
        
        session.getTransaction().commit();  
        session.close();
    }

iterator : 会放入缓存，也会从缓存中获取数据

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
@Test
    public void iterator() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        // HQL查询
        Query q = session.createQuery("from User ");
        // iterator()方法
        Iterator<User> it = q.iterate();
        while(it.hasNext()){
            // 得到当前迭代的每一个对象
            User user = it.next();
            System.out.println(user);
        }

        session.getTransaction().commit();  
        session.close();
    }

懒加载(lazy)

概念：当用到数据的时候才向数据库查询，这就是hibernate的懒加载特性。
目的：提供程序执行效率！
lazy 值
- true : 使用懒加载
- false : 关闭懒加载
- extra : 在集合数据懒加载时候提升效率
  - 在真正使用数据的时候才向数据库发送查询的sql；如果调用集合的size() / isEmpty()方法，只是统计，不真正查询数据！

<?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">
<hibernate-mapping package="cn.itcast.b_one2Many">
    <class name="Dept" table="t_dept" >
        <id name="deptId">
            <generator class="native"></generator>
        </id>   
        <property name="deptName" length="20"></property>
        
        <!-- 
            集合属性，默认使用懒加载 
            lazy
                true 懒加载
                extra 懒加载(智能)
                false 关闭懒加载
        
        -->
         <set name="emps" lazy="extra">
             <key column="dept_id"></key>
             <one-to-many class="Employee"/>
         </set>
    </class>
</hibernate-mapping>

//1. 集合的查询()
    @Test
    public void set() {
        Session session = sf.openSession();
        session.beginTransaction();
        Dept dept = (Dept) session.get(Dept.class, 10);
        System.out.println(dept.getDeptName());
        System.out.println("------");
        System.out.println(dept.getEmps().isEmpty());  //  SQL
        
        session.getTransaction().commit();
        session.close();    
    }

懒加载异常
- Session关闭后，不能使用懒加载数据; 如果session关闭后，使用懒加载数据报错：
  org.hibernate.LazyInitializationException: could not initialize proxy - no Session
- 如何解决session关闭后不能使用懒加载数据的问题？
  - 方式1：先使用一下数据 : dept.getDeptName();
  - 方式2：强迫代理对象初始化 : Hibernate.initialize(dept);
  - 方式3：关闭懒加载, 设置lazy=false;
  - 方式4：在使用数据之后，再关闭session！
get与load方法:

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Dept.class)   
            .addClass(Employee.class)   // 测试时候使用
            .buildSessionFactory();
    }
    //1. 主键查询，及区别
    @Test
    public void get_load() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        Dept dept = new Dept();
        // get： 及时查询
//      dept = (Dept) session.get(Dept.class, 9);
//      System.out.println(dept.getDeptName());
        
        // load，默认懒加载， 及在使用数据的时候，才向数据库发送查询的sql语句！
        dept = (Dept)session.load(Dept.class, 9);
        // 方式1： 先使用一下数据
        //dept.getDeptName();
        // 方式2：强迫代理对象初始化
        Hibernate.initialize(dept);
        // 方式3：关闭懒加载
        
        session.getTransaction().commit();
        session.close();
        
        // 在这里使用
        System.out.println(dept.getDeptName());
    }

一对一映射

基于外键的映射
- IdCard.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">
<hibernate-mapping package="cn.itcast.c_one2one">
    <class name="IdCard" table="t_IdCard">
        <id name="cardNum">
            <generator class="assigned"></generator>
        </id>   
        <property name="place" length="20"></property>
        
        <!-- 
            一对一映射，有外键的类
            unique="true"   给外键字段添加唯一约束
         -->
         <many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update"></many-to-one>
    </class>
</hibernate-mapping>

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">
<hibernate-mapping package="cn.itcast.c_one2one">
    <class name="User" table="t_user">
        <id name="userId">
            <generator class="native"></generator>
        </id>   
        <property name="userName" length="20"></property>
        <!-- 
            一对一映射： 没有外键的类
         -->
         <one-to-one name="idCard" class="IdCard"></one-to-one> 
    </class>
</hibernate-mapping>

java类

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(IdCard.class)   
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }

    @Test
    public void getSave() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 用户
        User user = new User();
        user.setUserName("Jack");
        // 身份证
        IdCard idCard = new IdCard();
        idCard.setCardNum("441202XXX");
        idCard.setPlace("广州XXX");
        // 关系
        idCard.setUser(user);
        
        // ----保存----
        session.save(idCard);
        
        session.getTransaction().commit();
        session.close();    
    }

基于主键的映射
- IdCard.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">
<hibernate-mapping package="cn.itcast.c_one2one2">
    <class name="IdCard" table="t_IdCard">
        <id name="user_id">
            <!-- 
                id 节点指定的是主键映射, 即user_id是主键
                主键生成方式： foreign  即把别的表的主键作为当前表的主键；
                        property (关键字不能修改)指定引用的对象     对象的全名 cn..User、  对象映射 cn.User.hbm.xml、   table(id)
             -->
            <generator class="foreign">
                <param name="property">user</param>
            </generator>
        </id>   
        <property name="cardNum" length="20"></property>
        <property name="place" length="20"></property>
        
        <!-- 
            一对一映射，有外键方
            （基于主键的映射）
             constrained="true"  指定在主键上添加外键约束
         -->
        <one-to-one name="user" class="User" constrained="true"  cascade="save-update"></one-to-one>
            
    </class>
</hibernate-mapping>

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">
<hibernate-mapping package="cn.itcast.c_one2one">
    <class name="User" table="t_user">
        <id name="userId">
            <generator class="native"></generator>
        </id>   
        <property name="userName" length="20"></property>
        <!-- 
            一对一映射： 没有外键的类
         -->
         <one-to-one name="idCard" class="IdCard"></one-to-one> 
    </class>
</hibernate-mapping>

java类

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(IdCard.class)   
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
    @Test
    public void getSave() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 用户
        User user = new User();
        user.setUserName("Jack");
        // 身份证
        IdCard idCard = new IdCard();
        idCard.setCardNum("441202XXX");
        idCard.setPlace("广州XXX");
        // 关系
        idCard.setUser(user);
        
        // ----保存----
        session.save(idCard);
        
        session.getTransaction().commit();
        session.close();    
    }

组件映射与继承映射

类的关系
- 组合关系 : 一个类中包含了另外一个类, 这两个类就是组合关系 (汽车与车轮)
- 继承关系 : 一个类继承另外一个类, 这两个类就是继承关系
组件映射 : 类组合关系的映射, 也叫做组件映射 (组件类和被包含的组件类，共同映射到一张表)
- javaBean

public class Car {
          private int id;
          private String name;
          // 车轮
          private Wheel wheel;
}
public class Wheel {
          private int count;
          private int size;
}

Car.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">
<!-- 
    组件映射
 -->
<hibernate-mapping package="cn.itcast.d_component">
    <class name="Car" table="t_car">
        <id name="id">
            <generator class="native"></generator>
        </id>   
        <property name="name" length="20"></property>
        
        <!-- 组件映射 -->
        <component name="wheel">
            <property name="size"></property>
            <property name="count"></property>
        </component>         
    </class>
</hibernate-mapping>

java

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Car.class)   
            .buildSessionFactory();
    }
    @Test
    public void getSave() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 轮子
        Wheel wheel = new Wheel();
        wheel.setSize(38);
        wheel.setCount(4);
        // 汽车
        Car car = new Car();
        car.setName("BMW");
        car.setWheel(wheel);
        
        // 保存
        session.save(car);
        
        session.getTransaction().commit();
        session.close();    
    }

继承映射
- 简单继承映射 : 有多少个子类，写多少个映射文件！

<?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">
<!-- 
    简单继承
 -->
<hibernate-mapping package="cn.itcast.e_extends1">
    <class name="Cat" table="t_Cat">
        <!-- 简单继承映射： 父类属性直接写 -->
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="name"></property>
        
        <property name="catchMouse"></property>                  
    </class>
</hibernate-mapping>

- 总结：写法较为简单, 所有子类用一个映射文件, 且映射到一张表; 但数据库设计不合理!(不推荐用)

一个映射文件存储所有子类, 子类父类都对应表(所有子类映射到一张表)

<?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">
<!-- 继承映射， 所有的子类都映射到一张表 -->
<hibernate-mapping package="cn.itcast.e_extends2">
    <class name="Animal" table="t_animal">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <!-- 指定鉴别器字段(区分不同的子类) -->
        <discriminator column="type_"></discriminator>
        
        <property name="name"></property>
        
        <!-- 
            子类：猫
                每个子类都用subclass节点映射
                注意：一定要指定鉴别器字段，否则报错！
                鉴别器字段：作用是在数据库中区别每一个子类的信息， 就是一个列
            discriminator-value="cat_"
                指定鉴别器字段,即type_字段的值
                如果不指定，默认为当前子类的全名
         -->
         <subclass name="Cat" discriminator-value="cat_">
            <property name="catchMouse"></property>
         </subclass>
         
         <!-- 
            子类：猴子
          -->
          <subclass name="Monkey" discriminator-value="monkey_">
            <property name="eatBanana"></property>
          </subclass>
    </class>
</hibernate-mapping>

- 总结 : 写法较为简单, 所有子类用一个映射文件, 且映射到一张表！但数据库设计不合理(不推荐用)

每个类都映射一张表

<?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">
<!-- 继承映射， 每个类对应一张表(父类也对应表) -->
<hibernate-mapping package="cn.itcast.e_extends3">
    <class name="Animal" table="t_animal">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="name"></property>
        
        <!-- 
            子类：猫  t_cat
            key 指定_cat表的外键字段
        -->
        <joined-subclass name="Cat" table="t_cat">
            <key column="t_animal_id"></key>
            <property name="catchMouse"></property>
        </joined-subclass>
        
        <!-- 子类：猴子  t_monkey -->
        <joined-subclass name="Monkey" table="t_monkey">
            <key column="t_animal_id"></key>
            <property name="eatBanana"></property>
        </joined-subclass>
    </class>
</hibernate-mapping>

- 总结 : 一个映射文件，存储所有的子类； 子类父类都对应表；
- 缺点：表结构比较复杂，插入一条子类信息，需要用2条sql(子类, 父类都需要插入数据)

推荐 : 每个子类映射一张表，父类不对应表

<?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">
<!-- 继承映射， 每个类对应一张表(父类不对应表) -->
<hibernate-mapping package="cn.itcast.e_extends4">
    <!-- abstract="true"  指定实体类对象不对应表，即在数据库段不生成表 -->
    <class name="Animal" abstract="true">
        <!-- 如果用union-subclass节点，主键生成策略不能为自增长！ -->
        <id name="id">
            <generator class="uuid"></generator>
        </id>
        <property name="name"></property>
        
        <!-- 
            子类：猫  t_cat
            union-subclass  
                table 指定为表名, 表的主键即为id列
        -->
        <union-subclass name="Cat" table="t_cat">
            <property name="catchMouse"></property>
        </union-subclass>
        
        <!-- 子类：猴子  t_monkey -->
        <union-subclass name="Monkey" table="t_monkey">
            <property name="eatBanana"></property>
        </union-subclass>
    </class>
</hibernate-mapping>

- 注意：主键不能是自增长！

Hibernate中映射分类：

多对一
一对多
多对多
一对一（多对一的特殊应用）
组件
继承

最后编辑于：2017.12.06 13:11:46

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,013评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,205评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 152,370评论 0赞 342
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,168评论 1赞 278
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,153评论 5赞 371
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,954评论 1赞 283
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,271评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,916评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,382评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,877评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,989评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,624评论 4赞 322
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,209评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,199评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,418评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,401评论 2赞 352
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,700评论 2赞 345

Hibernate框架(3) - 对象状态 / 一级缓存 / 映射

对象的状态

一级缓存

懒加载(lazy)

一对一映射

组件映射与继承映射

Hibernate中映射分类：

推荐阅读更多精彩内容