Hibernate（三）

对象的状态

举例： User   user   = new User();

Hibernate中对象的状态： 临时/瞬时状态、持久化状态、游离状态。

临时状态

特点： 
    直接new出来的对象;  
    不处于session的管理;
    数据库中没有对象的记录;

持久化状态

    当调用session的save/saveOrUpdate/get/load/list等方法的时候，对象就是持久化状态。
    处于持久化状态的对象，当对对象属性进行更改的时候，会反映到数据库中!
特点：
    处于session的管理;
    数据库中有对应的记录;

游离状态

特点
    不处于session的管理；
    数据库中有对应的记录
    Session关闭后，对象的状态；

一级缓存

为什么要用缓存？
    目的：减少对数据库的访问次数！从而提升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();   // 再清空一级缓存内容

面试题1： 不同的session是否会共享缓存数据?

不会。
User1  u1 = Session1.get(User.class,1);   把u1对象放入session1的缓存
Session2.update(u1);     把u1放入session2的缓存

U1.setName(‘new Name’);

如果生成2条update sql， 说明不同的session使用不同的缓存区，不能共享。

面试题2： list与iterator查询的区别？

list() 
    一次把所有的记录都查询出来，
    会放入缓存，但不会从缓存中获取数据
Iterator
    N+1查询； N表示所有的记录总数
    即会先发送一条语句查询所有记录的主键（1），
    再根据每一个主键再去数据库查询（N）！
    会放入缓存，也会从缓存中取数据！

懒加载

1. 懒加载：(lazy)
    概念：当用到数据的时候才向数据库查询，这就是hibernate的懒加载特性。

    目的：提供程序执行效率！

2. lazy 值
    true   使用懒加载
    false   关闭懒加载
    extra   (在集合数据懒加载时候提升效率)
    在真正使用数据的时候才向数据库发送查询的sql；
    如果调用集合的size()/isEmpty()方法，只是统计，不真正查询数据！

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

一对一映射

需求: 用户与身份证信息
     一条用户记录对应一条身份证信息！  一对一的关系！

基于外键的映射

// 身份证
public class IdCard {

    // 身份证号(主键)
    private String cardNum;// 对象唯一表示(Object Identified, OID)
    private String place; //  身份证地址
    // 身份证与用户，一对一的关系
    private User user;
}
// 用户
public class User {

    private int userId;
    private String userName;
    // 用户与身份证信息， 一对一关系
    private IdCard idCard;
}

<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>

        
         <many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update">many-to-one>
    class>
hibernate-mapping>

<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>

基于主键的映射

// 身份证
public class IdCard {

    private int user_id;
    // 身份证号
    private String cardNum;
    private String place; //  身份证地址
    // 身份证与用户，一对一的关系
    private User user;
}

<hibernate-mapping package="cn.itcast.c_one2one2">

    <class name="IdCard" table="t_IdCard">
        <id name="user_id">
            
            <generator class="foreign">
                <param name="property">userparam>
            generator>
        id>   
        <property name="cardNum" length="20">property>
        <property name="place" length="20">property>

        
        <one-to-one name="user" class="User" constrained="true"  cascade="save-update">one-to-one>            
    class>
hibernate-mapping>

组件映射与继承映射

组件映射

类组合关系的映射，也叫做组件映射！
    注意：组件类和被包含的组件类，共同映射到一张表！
    需求： 汽车与车轮
    数据库 
        T_car
            主键   汽车名称  轮子大小  个数

public class Car {

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

    private int count;
    private int size;
}

<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>

继承映射

需求：动物
     猫
     猴子

简单继承映射

// 动物类
public abstract class Animal {

    private int id;
    private String name;
}   
public class Cat extends Animal{

    // 抓老鼠
    private String catchMouse;
}

<hibernate-mapping package="cn.itcast.e_extends1">

    <class name="Cat" table="t_Cat">
        
        <id name="id">
            <generator class="native">generator>
        id>
        <property name="na">property>
        <property name="catchMouse">property>                  
    class>
hibernate-mapping>

@Test
    public void getSave() {

        Session session = sf.openSession();
        session.beginTransaction();

        // 保存
//      Cat cat = new Cat();
//      cat.setName("大花猫");
//      cat.setCatchMouse("抓小老鼠");
//      session.save(cat);

        // 获取时候注意：当写hql查询的使用，通过父类查询必须写上类的全名
        Query q = session.createQuery("from cn.itcast.e_extends1.Animal");
        List list = q.list();
        System.out.println(list);

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

总结：
    简单继承映射，有多少个子类，写多少个映射文件！

所有子类映射到一张表 (1张表)

什么情况用？
    子类教多，且子类较为简单，即只有个别属性！
    好处：因为使用一个映射文件， 减少了映射文件的个数。
    缺点：（不符合数据库设计原则）
一个映射文件： Animal.hbm.xml
            (如何区分是哪个子类的信息？)


数据库:
    T_animal （要存储所有的子类信息）                 “鉴别器”
        Id   name     catchMouse      eatBanana       type_(区别是哪个子类)
         1   大马猴       NULL        吃10个香蕉     猴子
         2   大花猫     不抓老鼠         NULL          猫

<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 name="Cat" discriminator-value="cat_">
            <property name="catchMouse">property>
         subclass>

         
          <subclass name="Monkey" discriminator-value="monkey_">
            <property name="eatBanana">property>
          subclass>       
    class>
hibernate-mapping>

总结：
    写法较为简单：所有子类用一个映射文件，且映射到一张表！
    但数据库设计不合理!
    （不推荐用。）

每个类映射一张表(3张表)

数据库
      T_anmal （存储父类信息）
        1   大花猫
      T_cat （引用父类的主键）
         1  抓小老鼠
      T_monkey（引用父类的主键）

<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>

        
        <joined-subclass name="Cat" table="t_cat">
            <key column="t_animal_id">key>
            <property name="catchMouse">property>
        joined-subclass>

        
        <joined-subclass name="Monkey" table="t_monkey">
            <key column="t_animal_id">key>
            <property name="eatBanana">property>
        joined-subclass>      
    class>
hibernate-mapping>

总结：
    一个映射文件，存储所有的子类； 子类父类都对应表；
缺点：表结构比较负责，插入一条子类信息，需要用2条sql： 往父类插入、往子类插入！

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

数据库：
    T_cat
        Id   name   catchMounse
    T_monkey
        Id    name   eatBanana

<hibernate-mapping package="cn.itcast.e_extends4">
    
    <class name="Animal" abstract="true">
        
        <id name="id">
            <generator class="uuid">generator>
        id>
        <property name="name">property>

        
        <union-subclass name="Cat" table="t_cat">
            <property name="catchMouse">property>
        union-subclass>

        
        <union-subclass name="Monkey" table="t_monkey">
            <property name="eatBanana">property>
        union-subclass>       
    class>
hibernate-mapping>

总结：
    所有的子类都写到一个映射文件；
    父类不对应表； 每个子类对应一张表