Hibernate框架--对象的状态，缓存， 映射

回顾Hibernate第二天：

1.  一对多与多对一

2. 多对多

3. inverse/cascade

4. 关联关系的维护

一对多:

<set name="映射的集合属性" table="(可选)集合属性对应的外键表">

<key column="外键表的，外键字段" />

<one-to-many class="集合元素的类型" />

</set>

多对一：

<many-to-one name="对象属性" class="对象类型" column="外键字段字段" />

多对多

<set name="" table="">

<key column="" />

<many-to-many column="" class="">

</set>

目标：

第1部分: 对象的状态：

第2部分：缓存

1) 一级缓存

2) 相关知识

----懒加载---

第3部分：映射

一对一映射

组件映射

继承映射

一、对象的状态

举例： User   user   = new User();

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

1. 临时状态

　　特点：

　　直接new出来的对象;

　　不处于session的管理;

　　数据库中没有对象的记录;

1. 持久化状态

　　当调用session的save/saveOrUpdate/get/load/list等方法的时候，对象就是持久化状态。

　　处于持久化状态的对象，当对对象属性进行更改的时候，会反映到数据库中!

　　特点：

　　处于session的管理;

　　数据库中有对应的记录;

3. 游离状态

　　特点：

不处于session的管理；

数据库中有对应的记录

Session关闭后，对象的状态；

对象状态的转换 

public class User {

    private int userId;
    private String userName;
    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + "]";
    }

}

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

    <class name="User" table="t_user">
        <id name="userId" column="id">
            <generator class="native"></generator>
        </id>
        <property name="userName"></property>
    </class>

</hibernate-mapping>

public class App1_status {

    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.);
        user.setUserName("Tomcat");// hibernate会自动与数据库匹配（一级缓存），如果一样就更新数据库

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

        user.setUserName("Jack444444444");
        // 打印                            【游离状态】
        System.out.println(user.getUserId());
        System.out.println(user.getUserName());
    }

    @Test
    public void bak() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        session.getTransaction().commit();
        session.close();
    }
}

二、一级缓存

为什么要用缓存？

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

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

User1  u1 = Session1.get(User.class,1);   把u1对象放入session1的缓存

Session2.update(u1);     把u1放入session2的缓存

U1.setName(‘new Name’);

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

public class App2_cache {

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

    @Test
    public void testCache() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        User user = null;
        // 查询
        user = (User) session.);// 先检查缓存中是否有数据，如果有不查询数据库，直接从缓存中获取
        user = (User) session.);// 这一句就不再向数据库发送查询命令了，减少了与数据库的交互。

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

    @Test
    public void flush() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        User user = null;
        user = (User) session.);
        user.setUserName("Jack");
        // 缓存数据与数据库同步
        session.flush();

        user.setUserName("Jack_new");

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

    @Test
    public void clear() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        User user = null;
        // 查询
        user = (User) session.);
        // 清空缓存内容
//        session.clear(); // 清空所有
        session.evict(user);// 清除指定

        user = (User) session.);

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

    @Test
    public void sessionTest() throws Exception {
        Session session1 = sf.openSession();
        session1.beginTransaction();
        Session session2 = sf.openSession();
        session2.beginTransaction();

        // user放入session1的缓存区
        User user = (User) session1.);
        // user放入session2的缓存区
        session2.update(user);

        // 修改对象
        user.setUserName("New Name");  // 2条update

        session1.getTransaction().commit();  // session1.flush();
        session1.close();
        session2.getTransaction().commit();  // session2.flush();
        session2.close();
    }
}

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

list()  一次把所有的记录都查询出来，

　　   会放入缓存，但不会从缓存中获取数据

Iterator     N+1查询； N表示所有的记录总数

即会先发送一条语句查询所有记录的主键（1），再根据每一个主键再去数据库查询（N）！

　　   会放入缓存，也会从缓存中取数据！ 

public class App3_list_iterator {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
    /**
     * list与iterator区别
     * 1. list 方法
     * 2. iterator 方法
     * 3. 缓存
     * @throws Exception
     */
    //1.  list 方法
    @Test
    public void list() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        // HQL查询    这句不会向数据库发送sql语句查询
        Query q = session.createQuery("from User ");
        // list()方法   执行q.list()才会会向数据库发送查询的sql语句
        List<User> list = q.list();

        ; i<list.size(); i++){
            System.out.println(list.get(i));
        }

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

    //2. iterator 方法
    @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();
    }

    //3. 缓存
    @Test
    public void cache() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        /**************执行2次list*****************
        Query q = session.createQuery("from User");
        List<User> list = q.list();      // 【会把list查询结果放入缓存】
        for (int i=0; i<list.size(); i++){
            System.out.println(list.get(i));
        }
        System.out.println("=========list===========");
        list = q.list();                // 【不会从上面的缓存中去取list，而是再向数据库发送查询语句】
        for (int i=0; i<list.size(); i++){
            System.out.println(list.get(i));
        }
        上面总共会向数据库发送两次查询语句。

        /**************执行2次iteator******************/
        Query q = session.createQuery("from User ");
        Iterator<User> it = q.iterate();        // 【查询结果会放入缓存】
        while(it.hasNext()){
            User user = it.next();
            System.out.println(user);
        }
        System.out.println("==========iterate===========");
        it = q.iterate();                        // 【这里不再向数据库发送查询语句了，而是直接从上面的缓存中取】
        while(it.hasNext()){
            User user = it.next();
            System.out.println(user);
        }

        session.getTransaction().commit();
        session.close();
    }
    
上面也是向数据库发送两条sql查询语句，一个是查询总记录数，一个是第一次查询

    // 测试list方法会放入缓存
    @Test
    public void list_iterator() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        // 得到Query接口的引用
        Query q = session.createQuery("from User ");

        // 先list  【会放入缓存，但不会从缓存中获取数据】
        List<User> list = q.list();
        ; i<list.size(); i++){
            System.out.println(list.get(i));
        }

        // 再iteraotr  (会从缓存中取)
        Iterator<User> it = q.iterate();
        while(it.hasNext()){
            User user = it.next();
            System.out.println(user);
        }

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

三、懒加载

面试题3： get、load方法区别？

　　get: 及时加载，只要调用get方法立刻向数据库查询

　　load:默认使用懒加载，当用到数据的时候才向数据库查询。

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

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

lazy 值:在配置文件中设置(Dep.hbm.xml)

true   使用懒加载

false   关闭懒加载

extra   (在集合数据懒加载时候提升效率)，也属于懒加载，可以理解为是一种比较高级的懒加载

　　　　　　在真正使用数据的时候才向数据库发送查询的sql；

　　　　　　如果调用集合的size()/isEmpty()方法，只是统计，不真正查询数据！

懒加载异常

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

    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.);
        // 方式1： 先使用一下数据，会去查询数据库，这样就不会报错了。
        //dept.getDeptName();
        // 方式2：强迫代理对象初始化
        Hibernate.initialize(dept);
        // 方式3：关闭懒加载

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

        // session关闭后在这里使用数据而不报错的四种解决方式。
        System.out.println(dept.getDeptName());
    }

    //1. 主键查询，及区别
    @Test
    public void set() {
        Session session = sf.openSession();
        session.beginTransaction();
        Dept dept = (Dept) session.);
        System.out.println(dept.getDeptName());
        System.out.println("------");
        System.out.println(dept.getEmps().isEmpty());  //  SQL

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

    }

}

四、一对一映射（两种映射写法，基于外键，基于主键的映射）

需求: 用户与身份证信息

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

　　设计数据库：

　　JavaBean：

　　映射：

基于外键的映射：把当前表的主键作为其他表的外键

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

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

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

<?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。在加上一个唯一约束。这就变成了one-to-one
         <many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update"></many-to-one>
    </class>
</hibernate-mapping>

public class App {

    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();
    }
}

基于主键的映射：把当前表的主键作为其他表的主键

user类即映射不变，只要更改idcard及映射即可。

// 身份证
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">
            <!--
                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>

五、组件映射与继承映射

类的关系

组合关系

一个类中包含了另外一个类。这2个类中就是组合关系。

需求： 汽车与车轮

继承关系

一个类继承另外一个类。这2个类中就是继承关系。

需求：动物

组件映射

类组合关系的映射，也叫做组件映射！

注意：组件类和被包含的组件类，共同映射到一张表！

需求： 汽车与车轮

数据库:T_car

主键   汽车名称  轮子大小  个数

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

// 车轮
public class Wheel {
    private int count;
    private int size;
}

Car.hbm.xml

<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 class App {

    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();
        wheel.setCount();
        // 汽车
        Car car = new Car();
        car.setName("BMW");
        car.setWheel(wheel);

        // 保存
        session.save(car);

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

继承映射

需求：动物

　　　　猫

　　　　猴子

简单继承映射

// 动物类
public abstract class Animal {

    private int id;
    private String name;
    

public class Cat extends Animal{

    // 抓老鼠
    private String catchMouse;

    public String getCatchMouse() {
        return catchMouse;
    }

    public void setCatchMouse(String catchMouse) {
        this.catchMouse = catchMouse;
    }
}

Cat.hbm.xml

<!--
    简单继承
 -->
<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>

public class App {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Cat.class)
            .buildSessionFactory();
    }

    @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<Animal> 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          猫

总结：

写法较为简单：所有子类用一个映射文件，且映射到一张表！

但数据库设计不合理!

（不推荐用。）

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

数据库

T_anmal （存储父类信息）

1   大花猫

T_cat （引用父类的主键）

1  抓小老鼠

T_monkey（引用父类的主键）

Javabean设计一样，映射实现不同：

<!--

继承映射， 每个类对应一张表(父类也对应表)

-->

<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： 往父类插入、往子类插入！

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

数据库：

T_cat

Id   name   catchMounse

T_monkey

Id    name   eatBanana

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

<property name="catchMouse"></property>

</union-subclass>

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

总结：

所有的子类都写到一个映射文件；

父类不对应表； 每个子类对应一张表

Hibernate中映射：

多对一

一对多

多对多

一对一  （多对一的特殊应用）

组件

继承