hibernate笔记(三)

目标:

第1部分: 对象的状态:

第2部分:缓存

1) 一级缓存

2) 相关知识

----懒加载---

第3部分:映射

一对一映射

组件映射

继承映射

一、对象的状态

举例: User user = new User();

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

临时状态

特点:

直接new出来的对象;

不处于session的管理;

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

持久化状态

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

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

特点:

处于session的管理;

数据库中有对应的记录;

游离状态

特点

不处于session的管理;

数据库中有对应的记录

Session关闭后,对象的状态;

对象状态的转换,

二、一级缓存

为什么要用缓存?

目的:减少对数据库的访问次数!从而提升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使用不同的缓存区,不能共享。

面试题2: list与iterator查询的区别?

list()

一次把所有的记录都查询出来,

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

Iterator

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

即会先发送一条语句查询所有记录的主键(1),

再根据每一个主键再去数据库查询(N)!

会放入缓存,也会从缓存中取数据!

三、懒加载

面试题3: get、load方法区别?

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

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

懒加载:(lazy)

概念:当用到数据的时候才向数据库查询,这就是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!

四、一对一映射

需求: 用户与身份证信息

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

设计数据库:

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;

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

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

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

五、组件映射与继承映射

类的关系

组合关系

一个类中包含了另外一个类。这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>

继承映射

需求:动物

猴子

简单继承映射

// 动物类 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

(如何区分是哪个子类的信息?)

数据库:

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中映射:

多对一

一对多

多对多

一对一 (多对一的特殊应用)

组件

继承

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • hibernate笔记(二)

    在一对多与多对一的关联关系中,保存数据最好的通过多的一方来维护关系,这样可以减少update语句的生成,从而提高hibernate的执行效率!

    HUC思梦
  • C3P0连接池参数解释

    HUC思梦
  • 整合SSM框架应用

    settings-build-compiler->勾选build project autoxxx选项

    HUC思梦
  • Hibernate之关联关系映射(一对一主键映射和一对一外键映射)

    1:Hibernate的关联关系映射的一对一外键映射:   1.1:第一首先引包,省略   1.2:第二创建实体类:     这里使用用户信息和身份证信息的关系...

    别先生
  • 一套系统是不是“理论高可用”,就看能否解决这3个棘手问题

    两年前,我曾写过一篇 #有关理论型高可用# 的文章,目的是为了警示使用者,切莫重理论,轻实践,不把系统可用性当回事,这种思想很危险。

    吃草的罗汉
  • 命令行执行Django脚本的方法

    update.py import os import sys import django sys.path.append(r'C...

    用户1214487
  • 系统学习javaweb-10-Hibernate的配置与api操作

    名称:Hibernate的配置与api操作、关联映射 说明:直接执行代码,自动建表

    csxiaoyao
  • 技术雷达是如何建立的?

    ThoughtWorks一年发布两次技术雷达,在每次雷达的准备期,TAB(ThoughtWorks技术顾问委员会)成员都会全力以赴的投入其中,以至连睡觉都会变成...

    ThoughtWorks
  • Spring整合Redis

    爱撒谎的男孩
  • 2020-11-14:手写代码:怎么用数组实现不超过固定大小的队列?

    福大大架构师每日一题

扫码关注云+社区

领取腾讯云代金券