Hibernate的状态，缓存和映射
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中的映射关系已经全部学完，他们是：
多对一
一对多
多对多
一对一(多对一的特殊应用)
组件
继承
|
作者：岑宇 出处：http://www.cnblogs.com/cenyu/ 本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 如果文中有什么错误，欢迎指出。以免更多的人被误导。 |
>
|
