hibernate笔记

Hibernate的工作原理：

读取并解析配置文件
2.读取并解析映射信息，创建SessionFactory
3.打开Sesssion
4.创建事务Transation
5.持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory

1.       启动Hibernate

2.       构建Configuration实例，初始化该实例中的所有变量 Configuration cfg = new Configuration().configure();

3.       加载hibernate.cfg.xml文件至该实例内存

4.       通过hibernate.xfg.xml文件中的mapping节点配置，加载hbm.xml文件至该实例内存

5.       利用上面创建的Configuration实例构建一个SessionFactory实例 SessionFactory sf = cfg.buildSessionFactory();

6.       由上面得到的SessionFactory实例创建连接 Session s = sf.openSession();

7.       由上面得到的Session实例创建事务操作接口Transaction的一个实例tx Transaction tx = s.beginTransaction();

8.       通过Session接口提供的各种方法操作数据库的访问

9.       提交数据库的操作结果 tx.commit();

10.   关闭Session链接 s.close();

 

为什么要用：

1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作

3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

2． Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

2. Hibernate3 提供了属性的延迟加载功能

当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

4． 说下Hibernate的缓存机制

1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

2. 二级缓存：
a) 应用及缓存
b) 分布式缓存
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据
c) 第三方缓存的实现

5． Hibernate的查询方式

Sql、Criteria,object  comptosition  Hql：
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数

6． 如何优化Hibernate？

1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰

 

五、 Hibernate主键策略(上面的步骤三的一部分)

<id><generator class=“主键策略” /></id>

主键：在关系数据库中，主键用来标识记录并保证每条记录的唯一性(一般可保证全数据库唯一)。必须满足以下条件：

1)不允许为空。

2)不允许主键值重复。

3)主键值不允许改变。

1.自然主键：以有业务含义的字段为主键，称为自然主键。

优点：不用额外的字段。

缺点：当业务需求发生变化时，必须修改数据类型，修改表的主键，增加了维护数据库的难度。

2.代理主键：增加一个额外的没有任何业务含义的一般被命名为ID的字段作为主键。

缺点：增加了额外字段，占用部分存储空间。

优点：提高了数据库设计的灵活性。

Hibernate用对象标识(OID)来区分对象:

Student stu = (Student)session.load(Student.class,101); //这代码加载了OID为101的Student对象

Hibernate推荐使用代理主键，因此Hibernate的OID与代理主键对应，一般采用整数型，包括：short、int、long。

1、主键生成策略： (Hibernate支持多种主键生成策略)

generator节点中class属性的值：

1) assigned：assigned：由用户自定义ID，无需Hibernate或数据库参与。是<generator>元素没有指定时的默认生成策略。

<id name="id" column="id"><generator class="assigned"/></id>

2) hilo：通过hi/lo(高/低位)算法生成主键，需要另外建表保存主键生成的历史状态(这表只需要一个列和高位初始值)。

hi/lo算法产生的标识只在一个特定的DB中是唯一的。所有数据库都可用。

如果同一个数据库里多张表都需要用；可以建多张主键表，也可以共用同一字段，但最好是用同一张主键表的不同字段。

<id name="id" column="id">

<generator class="hilo">

<!--指定高位取值的表-->

<param name="table">high_val</param>

<!--指定高位取值的列-->

<param name="column">nextval</param>

<!--指定低位最大值，当取到最大值是会再取一个高位值再运算-->

<param name="max_lo">5</param>

</generator>

</id>

3) sequence：采用数据库提供的Sequence机制。

Oracle,DB2等数据库都提供序列发生器生成主键，Hibernate也提供支持。

<id name="id" column="id">

<generator class="sequence">

<param name="sequence">序列名</param>

</generator>

</id>

4) seqhilo：功能同hilo，只是自动建表保存高位值。主键生成的历史状态保存在Sequence中。

只能用于Oracle等支持Sequence的数据库。

<id name="id" column="id"><generator class="hilo">

<param name="sequence">high_val_seq</param>

<param name="max_lo">5</param>

</generator></id>

5) increment：主键按数值顺序递增。

作用类型：long,short,int

使用场景：在没有其他进程同时往同一张表插数据时使用，在cluster下不能使用

6) indentity：采用数据库提供的主键生成机制。特点：递增。(Oracle不支持)

通常是对DB2,Mysql, MS Sql Server, Sybase, Hypersonic SQL(HSQL)内置的标识字段提供支持。

返回类型：long,short, int

<id name="id" column="id"><generator class="identity"/></id>

注：使用MySql递增序列需要在数据库建表时对主健指定为auto_increment属性。用Hibernate建表则不需要写。

(oid int primary key auto_increment)

7) native：由Hibernate根据底层数据库自行判断采用indentity, hilo或sequence中的一种。

是最通用的实现，跨数据库时使用。Default.sequence为hibernate_sequence

<id name="id" column="id"><generator class="native"/></id>

8) foreign：由其他表的某字段作为主键，通常与<one-to-one>联合使用；共享主健(主键与外键)，两id值一样。

<id name="id" column="id" type="integer">

<generator class="foreign">

<param name="property">car</param>

</generator>

</id>

9) UUID：

uuid.hex：由Hibernate基于128位唯一值产生算法生成十六进制数(长度为32的字符串---使用了IP地址)。

uuid.string：与uuid.hex一样，但是生成16位未编码的字符串，在PostgreSQL等数据库中会出错。

特点：全球唯一；ID是字符串。

10)select：通过DB触发器(trigger)选择一些唯一主键的行，返回主键值来分配主键

11)sequence-identity：特别的序列发生策略，使用DB序列来生成值，通常与JDBC3的getGenneratedKeys一起用，使得在执行insert时就返回生成的值。Oracle 10g(支持JDK1.4)驱动支持这一策略。

2、复合主键策略

步骤一：创建数据库表，设定联合主键约束

步骤二：编写主持久化类以及主键类；编写主键类时，必须满足以下要求：

1)实现Serializable接口

2)覆盖equals和hashCode方法

3)属性必须包含主键的所有字段

步骤三：编写*.hbm.xml配置文件

<composite-id name="dogId" class="composite.vo.DogId">

<key-property name="name" type="string"><column name="d_name"/></key-property>

<key-property name="nick" type="string"><column name="d_nick"/></key-property>

</composite-id>

 

六、 Hibernate的查询方案(应该熟悉各种查询的使用方法)

1、利用Session接口提供的load方法或者get方法

2、Hibernate提供的主要查询方法

1)Criteria Query(条件查询)的步骤：

(1)通过Session来创建条件查询对象Criteria

Criteria criteria = session.createCriteria(Course.class);

(2)构建条件---创建查询条件对象Criterion

Criterion criterion1 = Property.forName("id").ge(39);//通过Property来创建

Criterion criterion2 = Restrictions.le("cycle", 5); //通过Restrictions来创建

(3)查询对象关联条件

criteria.add(criterion1);

(4)执行条件查询

List<Course> courses = criteria.list();

2)HQL(Hibernate Qurey Language)

特点： 语法上与SQL类似； 完全面向对象的查询； 支持继承、多态、关联

(1) FROM子句

例如：查询所有的学生实例

Query query=session.createQuery("from Student");

query.list();

(2) SELECT子句

选择哪些对象和属性返回到结果集

A、SELECT语句后可以跟多个任意类型的属性，返回结果保存在Object类型的数组中

//A、B、C、都是查询学生的姓名和年龄

Query query=session.createQuery("select stu.name,stu.age from Student as stu");

List<Object[]> os=query.list();//返回的Object数组中有两个元素，第一个是姓名，第二个是年龄

B、SELECT语句后可以跟多个任意类型的属性，返回结果也可以保存在List中

Query query=session.createQuery ("select new List(stu.name,stu.age) from Student as stu");

List<List> lists=query.list();

C、SELECT语句后可以跟多个任意类型的属性，返回结果也可以是一个类型安全的POJO对象

Query query=session.createQuery

("select new Student(stu.name,stu.age) from Student as stu");

List<Student> stuList=query.list();//注意：Student类必须有Student(String,int)的构造方法

D、SELECT子句中可以使用聚集函数、数学操作符、连接

支持的聚集函数：avg、sum、min、max、count ….

(3) WHERE子句，限制返回结果集的范围

(4) ORDER BY子句，对返回结果集进行排序

3)Native SQL(原生SQL查询)

可移植性差：资源层如果采用了不同的数据库产品，需要修改代码---非不得已，不推荐使用

步骤一：调用Session接口上的createSQLQuery(String sql)方法,返回SQLQuery

步骤二：在SQLQuery对象上调用addEntity(Class pojoClass) //设置查询返回的实体

例如：

SQLQuery query =session.createSQLQuery(“select * from student limit 2,10”)

query.addEntity(Student.class);

List<Student> stuList=query.list();

 

七、 Hibernate对象的状态

实体对象的三种状态：

1) 暂态(瞬时态)(Transient)---实体在内存中的自由存在，它与数据库的记录无关。

po在DB中无记录(无副本)，po和session无关(手工管理同步)

如：

Customer customer = new Customer();

customer.setName("eric");

这里的customer对象与数据库中的数据没有任何关联

2) 持久态(Persistent)---实体对象处于Hibernate框架的管理中。

po在DB中有记录，和session有关(session自动管理同步)

3)游离态(脱管态)(Detached)

处于Persistent状态的实体对象，其对应的Session实例关闭之后，那么，此对象处于Detached状态。

po在DB中有记录，和session无关(手工管理同步)

无名态：po处于游离态时被垃圾回收了。没有正本，只有DB中的副本。

po处于暂态时被垃圾回收了，则死亡。(唯一可以死亡的状态)

实质上，这三个状态是：持久对象的正副本与同步的关系

原则：尽量使用持久态。

三态的转换：

暂态--->持久态

A.调用Session接口上的get()、load()方法

B.调用Session接口上的save()、saveOrUpdate()方法

持久态--->暂态

delete();

游离态--->持久态

update()、saveOrUpdate()、lock();

(lock不建议用，危险；肯定没变化时用，有则用updata)

持久态--->游离态

evict()、close()、clear()

(一般用evict，只关闭一个实体的连接；close关闭整个连接，动作太大)

 

八、 映射(重点掌握和理解，注意配置的细节)

关联关系：A有可能使用B，则AB之间有关联关系(Java里指A有B的引用)。

双边关系、传递性、方向性、名称、角色(权限)、数量(1:1；1:m；n:m)、关联强度

委托：整体跟部分之间是同一类型。

代理：整体跟部分之间不是同一类型。

A. 单一实体映射：最简单、基本映射(最重要)；任何其他映射种类的基础。

原则：

1.类->表；一个类对应一个表。

2.属性->字段：普通属性、Oid；一个属性对应一个字段。

B. 实体关系映射：

a.关联关系映射：(最难、量最多)

1.基数关系映射：

一对一(one to one) (共享主键、唯一外键)

一对多(one to many) (1:m) 作级联，删one后连着删many

多对一(many to one) (m:1) 不作级联，删many中一个，不删one

多对多(many to many)(n:m = 1:n + m:1)

2.组件关系映射：(一个类作为另一个类的零件，从属于另一个类，没有自己的XML)

单一组件关系映射

集合组件关系映射

b.继承关系映射：(最普遍。两个类有继承关系，在本质上他们就是一对一关系。共享主健。)

有三种映射方案：

1.一个类一个表(效率很低；最后考虑使用，一般是数据量较大和父子类重复字段不多的时候用)

只有当子类中的属性过多时才考虑每个类建一个表的策略。

2.一个实体一个表(多表查询效率低，不考虑多态时用)

不考虑多态时，最好是用只针对具体类建表，而考虑多态时尽量使用所有类建一个表

3.所有类一个表(查询效率最高，结构简单；字段数不超过100个时使用，首选)

c.集合映射(值类型)

Set 不重复、无顺序

List 可重复、有顺序

Map

Bag 可重复、无顺序(bag本身也是list实现的)

双向关联(Bidirectional associations)(相当于两个单向关联)

单向关联(Unidirectional associations)

"一"方的配置：

<!-- 表明以Set集合来存放关联的对象，集合的属性名为orders；一个"customer"可以有多个"order" -->

<!-- inverse="true"表示将主控权交给order，由order对象来维护关联关系，

也就是说order对象中的关联属性customer的值的改变会反映到数据库中 -->

<set name="orders" cascade="save-update" inverse="true">

<!-- 表明数据库的orders表通过外键customer_id参照customer表 -->

<key column="customer_id"/>

<!-- 指明Set集合存放的关联对象的类型 -->

<one-to-many class="many_to_one.vo.Order"/>

</set>

"多"方的配置：

<many-to-one

name="customer"

class="many_to_one.vo.Customer"

column="customer_id"

not-null="true"

cascade="save-update"

/>

cascade属性：设定级联操作(插入、修改、删除)。

cascad属性值 描述

none       保存、更新或删除当前对象时，忽略其他关联对象，默认属性值

save-update     通过Session的save()、update()以及saveOrUpdate()方法来保持、更新当前对象时级联，所有关联的新建对象，并且级联更新所有有关联的游离对象

delete      当通过Session的delete()方法来删除当前对象时，级联删除所有关联对象

all    包含所有的save-update以及delete行为

delete-orphan  删除所有和当前对象解除关联关系的对象

all-delete-orphan    包含all与delete-orphan的动作

inverse属性：表示是否将当前属性的值的变化反映到数据库中去。

false --- 表示反映到数据库中

true ---表示不反映到数据库中

Set的lazy属性：

A.不设置lazy值，默认true 现象：查询Customer时，不会主动查询关联表Orders(SQL语句)

B.设置lazy=false 现象：出现查询Orders表的SQL语句

3、多对多

默认情况下，由两方共同维护关联关系。也就是两个对象关联属性的值的改变都会反映到数据库中。

 

九、 Hibernate控制的事务

事务保证原子操作的不可分，也就是操作的同时成功或同时失败。

hibernate的事务隔离级别和JDBC中大致相同。

设置时要在hibernate.cfg.xml配置

<property name="hibernate.connection.isolation">4</property>

1： 读未提交的数据(Read uncommitted isolation) 脏读

2： 读已提交的数据(Read committed isolation) 不可重复读

4： 可重复读级别(Repeatable read isolation) 幻读

8： 可串行化级别(Serializable isolation)

hibernate的锁(悲观锁，乐观锁)

1.悲观锁是由数据库本身所实现的，会对数据库中的数据进行锁定，也就是锁行。(更新期间不许其他人更改)

LockMode.UPGRADE,修改锁，在get()方法中加上这个设置作为第三个参数。

LockMode.NONE 无锁机制

LockMode.READ 读取锁

LockMode.WRITE 写入锁，不能在程序中直接使用

还可以使用Session.lock() Query.setLockMode() Criteria.setLockMode()方法来设置锁，检测版本号，一旦版本号被改动则报异常。

2.乐观锁，也就是通过对记录加上某些信息来解决并发访问的问题。(认为更新期间不会有其他更改)

版本检查；要在其表中多加上一列表示版本信息，会在读取时读到这个版本号，并在修改之后更新这个版本号；

更新瞬间加锁，并且只有版本号相同才会予以更新，如果版本号不同，就会抛出例外。

<version name="version" column="version" type="integer" />