java--Hibernate对象状态、一级缓存、映射

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_17503037/article/details/80944153

对象的状态

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

 临时状态

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

 持久化状态

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

 游离状态

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

示例

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


@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范围有效，作用时间短，效果不是特别明显！
    在短时间内多次操作数据库，效果比较明显！

示例

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.get(User.class, 5);// 先检查缓存中是否有数据，如果有不查询数据库，直接从缓存中获取
    user = (User) session.get(User.class, 5);// 先检查缓存中是否有数据，如果有不查询数据库，直接从缓存中获取

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



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

    User user = null;
    user = (User) session.get(User.class, 5);
    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.get(User.class, 5);
    // 清空缓存内容 
//      session.clear(); // 清空所有
    session.evict(user);// 清除指定

    user = (User) session.get(User.class, 5);


    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.get(User.class, 1);
    // 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();
}
}

 缓存相关几个方法的作用

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）！
会放入缓存，也会从缓存中取数据！

示例

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

//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();      // 【会放入】
    for (int i=0; i<list.size(); i++){
        System.out.println(list.get(i));
    }
    System.out.println("=========list===========");
    list = q.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();
}

// 测试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(); 
    for (int i=0; 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:默认使用懒加载，当用到数据的时候才向数据库查询。 

概念：当用到数据的时候才向数据库查询，这就是hibernate的懒加载特性。目的：提供程序执行效率！

 lazy 值

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！ 

---

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

---

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

一对一映射

基于外键的映射

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

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>

基于主键的映射

// 身份证
public class IdCard {

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

//用户
public class User {

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

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

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

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

组件映射

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

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

需求： 汽车与车轮

数据库
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;

<!-- 
    简单继承
 -->
<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<Animal> list = q.list();
    System.out.println(list);

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

}

总结：

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

继承映射

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

什么情况用？

子类教多，且子类较为简单，即只有个别属性！
好处：因为使用一个映射文件， 减少了映射文件的个数。
缺点：（不符合数据库设计原则）

一个映射文件： Animal.hbm.xml
(如何区分是哪个子类的信息？)

扫描二维码关注公众号，回复： 3610352 查看本文章

数据库:

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

Animal.hbm.xml:

    <!-- 
    继承映射， 所有的子类都映射到一张表
 -->
<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>

总结：

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

每个类映射一张表(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>
注意：主键不能是自增长！

Animal.hbm.xml：

<!-- 
继承映射， 每个类对应一张表(父类不对应表)
 -->
<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中映射：

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