目标:

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

多对一

一对多

多对多

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

组件

继承

hibernate笔记(三)的更多相关文章

  1. Oracle学习笔记三 SQL命令

    SQL简介 SQL 支持下列类别的命令: 1.数据定义语言(DDL) 2.数据操纵语言(DML) 3.事务控制语言(TCL) 4.数据控制语言(DCL)  

  2. Hibernate的三种状态及对象生命周期

        理解Hibernate的三种状态,更利于理解Hibernate的运行机制,这些可以让你在开发中对疑点问题的定位产生关键性的帮助. 三种状态 临时状态(Transient):在通过new关键字, ...

  3. 《CMake实践》笔记三:构建静态库(.a) 与 动态库(.so) 及 如何使用外部共享库和头文件

    <CMake实践>笔记一:PROJECT/MESSAGE/ADD_EXECUTABLE <CMake实践>笔记二:INSTALL/CMAKE_INSTALL_PREFIX &l ...

  4. 框架Hibernate笔记系列 基础Session

    标题:框架Hibernate笔记 资料地址: 1. www.icoolxue.com 孔浩 1.背景简介 Hibenate是JBoss公司的产品.它是数据持久化的框架.Usually,我们使用JDBC ...

  5. Mastering Web Application Development with AngularJS 读书笔记(三)

    第一章笔记 (三) 一.Factories factory 方法是创建对象的另一种方式,与service相比更灵活,因为可以注册可任何任意对象创造功能.例如: myMod.factory('notif ...

  6. Python 学习笔记三

    笔记三:函数 笔记二已取消置顶链接地址:http://www.cnblogs.com/dzzy/p/5289186.html 函数的作用: 給代码段命名,就像变量給数字命名一样 可以接收参数,像arg ...

  7. hibernate的三种状态(儿)

    第五讲:hibernate的三种状态 瞬时:bean对象与session,与数据库无关.在session对象的save方法保存之前. 持久状态(托管):bean对象与session有关,数据库中有对应 ...

  8. 第五讲:深入hibernate的三种状态

    学过hibernate的人都可能都知道hibernate有三种状态,transient(瞬时状态),persistent(持久化状态)以及detached(离线状态),大家伙也许也知道这三者之间的区别 ...

  9. [转]深入hibernate的三种状态

    学过hibernate的人都可能都知道hibernate有三种状态,transient(瞬时状态),persistent(持久化状态)以及detached(离线状态),大家伙也许也知道这三者之间的区别 ...

随机推荐

  1. oracle-sql优化-通过分组和缓存减少不必要的读

    环境:aix 7.1,oracle12.1.0.2 cdb 优化前SQL select * from (select row_.*, rownum rownum_ from (select '弱覆盖' ...

  2. Django---URL、Views

    1.Django URL(路由系统) URL配置(URLconf)就像Django 所支撑网站的目录.它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表:你就是以这种方式告诉Djang ...

  3. Node.js(一)----安装

    1.下载 地址 https://nodejs.org/en/download/ 注: 系统为ubuntu 下载的源码包 tar.gz 或者 wget https://nodejs.org/dist/v ...

  4. 阅读《大型网站技术架构》,并结合"重大需求征集系统"有感

    今天阅读了<大型网站技术架构:核心原理与案例分析>的第五.六.七章.这三张主要是讲述了一个系统的可用性.伸缩性和可扩展性.而根据文中所讲述的,一个系统的可用性主要是体现在这个系统的系统服务 ...

  5. struts2学习

    struts2是一种基于mvc模式的轻量级web框架,它本质上相当于一个servlet,在mvc设计模式中,struts2作为控制器(Controller)来建立模型与视图的数据交互,struts2采 ...

  6. java元注解(注解在注解上的注解)

    //ElementType.TYPE 给类.接口.枚举上使用 @Target(ElementType.TYPE)//给注解进行注解,表示该注解可以用在什么地方 //@Retention(Retenti ...

  7. go学习笔记-结构体

    结构体 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合 定义 格式 type struct_variable_type struct { member definition; member ...

  8. android staido 断点遇到的坑

    今天排查数据布点问题,发现sd卡上面的文件莫名消失. 怎么可能?系统不可能删除你的文件,但是我调试,删除文件的代码, 一直都没有执行啊. 后来发现,子线程里面代码,android stadio 可能断 ...

  9. 58HouseSearch项目迁移到asp.net core

    前言 58HouseSearch这个项目原本是基于ASP.NET MVC 4写的,开发环境是Windows+VS2015,发布平台是linux+mono+jexus,这样看来整个项目基本已经满足跨平台 ...

  10. Mysql数据库的压力

    rationalError: (2006, 'MySQL server has gone away') 2017年10月10日 20:04:43 阅读数:377 问题描述 使用django+celer ...