Hibernate的状态，缓存和映射

最新推荐文章于 2024-10-16 10:13:45 发布

weixin_34177064

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量81

点赞数

文章标签： java 数据库

原文链接：http://www.cnblogs.com/cenyu/p/6284894.html

版权

Hibernate的状态，缓存和映射

1.对象的状态

1.1.对象状态的概念和分类

在使用Hibernate操作数据库的时候，我们先创建了JavaBean对象，然后使用session来保存或者更新到数据库，然后使用事务来提交更新。在这整个过程中，JavaBean中的对象经历了几个不同的状态，这些状态都是针对持久层的。

Hibernate中对象的状态分为：临时/瞬时状态，持久化状态，游离状态

1.临时状态
在JavaBean创建了一个对象，在Hibernate中，如果想用这个对象，就需要new一下：User user = new User();。
在new完这个对象之后，session还没有操作这个对象之前，这个对象是的状态就叫临时状态。此时的对象还没有根数据库产生关联。
特点：

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

2.持久化状态
当对对象调用session的save/saveOrUpdate/get/load/list 等方法的时候，对象就是持久化状态。处于持久化状态的对象，当对对象属性进行更改的时候，就会反映到数据库中！

特点：

处于session的管理
数据库中有对应的记录
session对数据库的操作在事务提交的时候一起对数据库进行操作

3.游离状态
session关闭之后，持久化对象就变成离线对象，离线表示这个对象不能再与数据库保持同步，他们不再受Hibernate的管理
特点：

不处于session的管理
数据库中有对应的记录
session关闭后，对象的状态就是游离状态

1.2.状态之间的相互转化

2.缓存

2.1.一级缓存

1.Session缓存：
Hibernate的一级缓存是由Session提供的，也就是说Hibernate的一级缓存就是Session的缓存，它存在与Session的整个生命周期，当程序调用save()/update()/saveOrupdate()/get()等，以及调用查询接口方法list()/iterator()方法的时候，如果Session中不存在该对象,那么会先将本次的对象存储到一级缓存中便于以后使用，当Session关闭时同时清空一级缓存数据clear()/evict().

2.Session的缓存作用：
减少访问数据库的次数，进而提高效率，保证缓存中的对象与数据库的记录保持同步，当魂村的对象改变后，Session不会立即执行sql，而是将多个sql语句合并为一条sql进行执行，提高效率

3.Session的缓存举例：
当用户需要对指定的对象进行修改的时候，如果对于同一个属性修改了多次，其实Hibernate的Session婚讯并不是执行多个Update语句，而是以最后一个更新为准而发送一条更新的sql。

2.2.几个方法的作用

1.缓存相关的几个方法的作用：
session.flush; 让一级缓存域与数据库同步
session.evict(arg0); 清空一级缓存中指定的对象
session.clear(); 清空一级缓存中缓存的素所有对象

什么情况会使用上面的方法呢？
在需要批量操作时使用。
session.flush(); 先与数据库同步
session.clear(); 再清空一级缓存内容

代码示例：



import java.util.HashSet;
import java.util.Set;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;

public class App2_cache {
    
    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .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);// 先检查数据库中是否有数据，如果有，不查询数据，直接从缓存中获取（此时缓存中有了）
        //此处只有一条向数据库查询的语句，当第二个get时，缓存中已经存在就不再从数据库中获取
        session.getTransaction().commit();
        session.close();
    }
    
    
    //flush数据库同步方法
    @Test
    public void flush() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        
        User user = null;
        user = (User) session.get(User.class, 5);
        user.setUserName("Jack555");
        //缓存数据与数据库同步

        //flush将缓存中的数据同步到数据库，如果此处没有使用flush方法，
        // 则只会把tomcat222更新到数据库，Jack555不会对数据库进行任何操作
        session.flush();
        user.setUserName("tomcat222");


        session.getTransaction().commit();  // session.flush();
        session.close();
    }
    
    //clear()和evict()清空方法
    @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();
    }
    
}

2.3.相关问题

1.不同的Session是否会共享缓存数据？

不会。在程序中，如果创建了两个Session中，然后分别存储了数据，则session有两个不同的缓存区，两者之间不会共享数据

2.list和Iterator查询的区别？

list():用一条sql语句把所有的记录都查询出来，查询的结果会放入缓存，但不会从缓存中获取数据
Iterator：N+1查询：N表示所有的记录总数。即会先发送一条语句查询所有记录的主键(1),再根据每一个主键去数据库查询(N).查询的结果会放入缓存，也会从缓存中取数据

代码示例：



import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;

public class App3_list_iterator {
    
    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .buildSessionFactory();
    }
    /**
     * list与iterator的区别
     * 1. list 使用方法
     * 2. iterator 使用方法
     */
    //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.懒加载

get，load方法的区别？
get：及时加载，只要调用get方法就立刻向数据库查询
load：默认使用懒加载，只用当使用数据的时候才向数据库查询

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

lazy的值:
lazy的值在对象的映射文件中设置，例如：<class name="Dept" table="t_dept" lazy="false">
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

代码示例：



import org.hibernate.Hibernate;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;

public class App {
    
    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .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);//此时没有向数据库发送sql语句


        /**
         *  session关闭后想用懒加载数据的方法
         */

        //方式1.在session关闭前先使用一下数据
        dept.getDeptName();
        // 方式2，强迫代理对象初始化
        Hibernate.initialize(dept);
        // 方式3：关闭懒加载，在映射文件中设置lazy=false

        //方式4，在使用数据之后再关闭session
        
        session.getTransaction().commit();
        session.close();
        
        // session关闭后，在这里使用数据
        System.out.println(dept.getDeptName());
    }
    
}

4.一对一映射

之前讲过一对多或者多对一，以及多对多的映射配置方式，但是实际中有时候还需要使用到一对一的映射方式。
下面举个例子;
需求：火车票的用户与身份证信息，即一条用户记录对应一条身份证信息，一对一的关系！
设计数据库

javaBean
映射配置

4.1.基于外键的映射

思想：在t_idcard表中使用t_user表的外键来关联到身份证信息到用户。t_idcard有自己的主键和一个外键

javaBean对象：

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

4.2.基于主键的映射

思想：也是使用外键来关联到t_user表，同时将这个外键作为t_idcard的主键

// 身份证
public class IdCard {

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

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 (关键字不能修改)指定引用的对象   找到  对象的全名 ..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>

5.组件映射

java中类的关系有：
组合关系：一个类中包含了另外一个类，这2个类就是组合关系。
继承关系：一个类继承于另外一个类，这2个类就是继承关系

对于组合关系，在维护一个类的时候，如果一个类中包含了另一个类，需要按照使用组合映射将两个类生成到一个关系表中。即一类中包含了另外一个类，所以需要在映射文件中把这里两个类都映射出来。
举个例来解释
需求：汽车和车轮
数据:t_car（主键，汽车名称，轮子大小，个数）
JavaBean：

//汽车
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>

6.继承映射

6.1.简单继承映射

需求：动物，猫继承动物，映射出猫的表

JavaBean对象，Cat继承Animal父类

// 动物类
public abstract class Animal {

    private int id;
    private String name;

public class Cat extends Animal {
    //继承了Animal的一些基本属性

    //设置猫的一个属性，抓老鼠
    private String catchMouse;

简单继承映射:
Cat.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="e_extend">
    
    <class name="Cat" table="t_cat" >
        <!--简单继承映射：父类属性直接写-->

        <id name="id">
            <!--手动指定主键-->
            <generator class="native"></generator>
        </id>   
        <property name="name" length="20"></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();
        
    }

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

6.2.继承映射

需求：猫和猴子两个子类继承自动物。如何映射子类的表

1.所有子类映射到一张表(1张表)
什么情况用？
子类较多，且子类较为简单，即只有个别属性。
好处是：由于使用一个映射文件，减少了映射文件的个数
缺点是：不符合数据库设计原则

映射文件Animal.hbm.xml，需要区分是哪一个子类的信息。

在数据库设计的时候需要额外添加一个字段来表示是哪一个子类。不推荐使用

2.每个子类映射到一张表(3张表)

数据库：
t_animal(存储父类信息)

1 大花猫

t_cat（引用父类的主键)

1 抓小老鼠

t_monkey（引用父类的主键）

代码示例：
JavaBean设计是cat和monkey继承Animal。
所有子类都在一个映射文件中配置，但是数据是保存在三个不同的表中。
映射文件：
Animal.hbm.xml

<!-- 
    继承映射， 每个类对应一张表(父类也对应表)
 -->
<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 指定t_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：往父类插入，往子类插入。

3.(推荐)每个子类映射到一张表，父类不对应表(2张表)
父类不对应表，只需要每个子类对应一张表：
数据库：
t_cat表和t_monkey表
映射文件


<!--
    继承映射
    abstract="true" 表示这个类不对应表
 -->
<hibernate-mapping package="cn.itcast.e_extends3">
    
    <class name="Animal" abstract="true" >
        <id name="id">
<!-- 如果使用 union-subclass节点，主键生成策略不能为自增长 -->
            <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中的映射关系已经全部学完，他们是：
多对一
一对多
多对多
一对一(多对一的特殊应用)
组件
继承

转载于:https://www.cnblogs.com/cenyu/p/6284894.html