hibernate框架学习笔记

第一天1

Hibernate框架的作用，优点：1

Hibernate设计原理：2

Hibernate主要API：2

Hibernate使用步骤：3

插入一条数据的过程：3

第二天3

Hibernate映射类型：3

2.Hibernate主键生成方式4

3.Hibernate框架的基本特性（默认的情况下采用的是批处理）5

1.一级缓存：5

2.对象持久性：6

3.延迟加载：7

如何使用同一个Session8

第三天9

1.一对多关系映射9

2.多对一关系映射9

2.Inverse属性10

第四天10

1.如何利用MyEclipse根据数据库生成实体类和映射描述文件10

2.多对多关系映射11

3.继承关系映射11

第五天11

---------总结---------11

1)继承关系映射12

2)Hibernate查询13

第六天-14

1.Hibernate高级特性14

1)二级缓存技术14

2)查询缓存技术14

*3)悲观锁和乐观锁15

第一天

Hibernate框架的作用，优点：

主要是用于负责对数据库的操作（增删改查的操作），使用该框架可以简化数据操作代码量，要程序员将更多的精力放在业务的编写上。业务复杂的情况下对数据的操作就不单纯只是DAO的操作了。本质上是对JDBC技术的封装。封装了很多智能的功能。原有的JDBC方式访问数据库的时候的不足之处有：a.需要编写大量复杂的SQL语句。

B.需要做大量的对象和记录之间关系的转换。c.数据库之间的转换使用的时候（也就是数据库的移植），要更换的SQL语句。需要变更的是分页语句，使用数据库函数的语句。

使用了Hibernate框架可以解决上面的三个问题。

Hibernate设计原理：

　Hibernate框架是一款ORM工具。基于ORM设计思想开发出来的。ORM（Object—Relation--Mapping）基于ORM思想设计出来的还有：Hibernate,IBATIS,JPA等。他们都是需要文件信息进行操作，文件信息是必不可少的。

对象：指的就是Java的entity对象，

关系：指的是关系数据库，

映射：就是对象和数据库的对应关系。

　思想是：将程序中对象和数据库中数据记录自动映射转换。利用ORM工具，在查询的时候，可以自动将记录封装成Java对象返回，在更新，插入操作时，可以将对象自动写入数据表。向中间的SQL+JDBC操作细节，完全封装在工具底层。要做框架的话都要学JAVA反射技术：通过反射技术可以获取类的所有信息，包括类的结构和字段属性，方法等。

Hibernate框架的主要结构：a.java实体类（n个）用于封装数据表记录的java对象类型。b.hibernate.cfg.xml(1个)Hibernate的主配置文件，里面主要定义数据库的连接参数。还可以定义框架的参数。刚启动的时候就会加载进去的。c.文件名.hbm.xml()，Hibernate映射描述文件，里面定义了实体类和数据库之间的对应关系，比如：哪类和哪个表，属性和表字段之间的对应关系。

Hibernate主要API：

使用的时候，需要使用Hibernate提供的API，他们将sql+jdbc操作细节封装起来了。a.Configuration:主要用于加载配置文件Hibernate.cfg.xmlb.SessionFactory:通过Configuratioin获取，主要用于创建hibernate中的session对象。和servelt里面的session是一点关系都没有的，servlet里面的是客户和服务器的会话。Hibernate中的是程序和数据中的会话。c.Session:代表java程序与数据库之间的一次连接。负责对数据库进行增删改查操作。提供的方法有：save(),update(),load(),get(),list(),load()和get()是对主键进行触发。d.Transaction:负责事务管理。Hibernate是没有自动提交的。注意的是：每次做增删查改操作必须要显示提交事务，因为：Hibernate将默认提交功能关闭。e.Query：负责执行Hibernate查询语句。

Hibernate使用步骤：

a.创建工程，引入hibernate和驱动开发包，b.在src下追加hibernate.cfg.xml主配置方言设置：diarect:用于封装指定数据库的SQL方言加载映射描述文件：c.根据数据表创建entity实体类。d.编写实体类和数据表的映射文件hbm.xml<calss>属性里面有name:类名，属性名，，，table:对应的表名。Class里面有一个<id>是定义的主键映射，属性有name:属性名，column:对应表中的字段名，type:属性类型，要全部小写，如果是写成java的话要写成包名点类名点属性类型这种形式的方式写。可以指定主键的生成方式,<genderatioin>class:生成方式，非主键的用<property>来写，属性也是一样的。e.利用hibernateAPI实现增删改查操作

插入一条数据的过程：

1.创建一个实体类对象，2.调用hibernate的API用于装载配置文件，Configurationconf=newConfiguration();如果是默认的配置文件hibernate.cfg.xml则直接调用，conf.configure();如果不是的话则conf.configure(newFile(“abc.xml”));3.创建SessionFactory:SessionFactoryfactory=conf.buildSessionFactory();4.创建Session:Sessionsession=factory.openSession();5.获得事务：Transactiontx=session.getTransaction();6.开启事务：tx.begin();7.插入数据：session.save(user);8.提交事务：tx.commit();9.关闭session:session.close();

　　　　　　　----------------课后练习------------------

1.基于Cost表做增删改查练习

2.重构资费管理模块的添加、开启、删除功能

第二天

Hibernate映射类型：

在hbm.xml中，描述属性和字段之间映射的时候，可以使用type属性指定映射类型。Type属性可以指定java类型和hibernate类型，主要作用是指定属性值和字段值之间转换的时候，采用的转换类型。这里建议使用hibernate映射类型。hibernate映射类型主要有下面的几种：a.整数类型：byte,short,integer,long;b.浮点数类型：float,double;c.字符串类型：string;d.日期类型：date:只取年月日，time时分秒把年月日忽略，timestamp:年月日时分秒。e.boolean类型：yes_no.将true/false转换成Y/Ntrue_false;将true/false转换成T/F;;有些数据库没有boolean类型。可以通过和字符类型的转换。

f.其他：big_decimal:----Bigdecimal,big_integer—Biginteger,colb:比较大的字符信息。Blob：字节信息的存储

2.---------------------------------------------------案例------------------------------------------------------

createtablet_foo(

t_idnumberprimarykey,

t_namevarchar2(50),

t_salarynumber(8,2),

t_marrychar(1),

t_hiredatedate,

t_last_login_timedate

)

-------------mysql----------------

createtablet_foo(

t_idintauto_incrementprimarykey,

t_namevarchar(50),

t_salarydouble,

t_marrychar(1),

t_hiredatedate,

t_last_login_timetimestamp

)defaultcharset=utf8;

2.Hibernate主键生成方式

在hbm.xml中，可以为主键指定生成方式。

具体如下：

*a.sequence：采用指定序列生成，适用于Oracle数据库。使用格式

<generatorclass="sequence">

<paramname="sequence">

foo_seq

</param>

</generator>

*b.identity:采用数据库自增涨机制生成。适用于MySQL,SQLServer数据库。

<generatorclass="identity">

</generator>

*c.native:根据方言自动选择identity,

sequence等生成方式。

<generatorclass="native">

</generator>

*d.increment:首先获取最大主键值，然后加1，再执行插入操作。适用于各种数据库。

先执行selectmax(id)fromt_foo;

再执行insertinto...

<generatorclass="increment">

</generator>

e.assigned:Hibernate忽略主键生成，不负责管理。需要程序员在程序中指定主键值

<generatorclass="assigned">

</generator>

f.其他

uuid：采用UUID算法生成一个字符串主键值

hilo：采用高地位算法生成一个数值主键值

3.Hibernate框架的基本特性（默认的情况下采用的是批处理）

1.一级缓存：

（session级别缓存，默认情况开启）持久态：每次创建一个Session对象，会为这个session对象提供一个缓存区，用于缓存该session查询出来的单个对象。Session关闭的时候它就会消失。一级缓存主要是针对单个对象的。不同的session访问同一个对象的时候，要访问数据库两次，每个session只能访问自己的缓存区的对象，同一个session不同的结果对象，会对数据库访问两次。

（session要负责将持久态对像的变化更新到数据库，在flush()的时候更新，tx在提交的时候会自动调用session的flush()）.

一级缓存区的管理方法：游离态：session.evict(obj);将obj从一级缓存移除。session.clear();

如果session被查询，session将先到缓存中查找是否有被查询的对象，找到则直接取出，找不到则访问数据库。

Session需要负责实时维护在缓存中的数据，保证缓存中的数据与数据库中的数据的一致性，一旦用户对缓存中的数据做了修改，当commit提交事务或者执行flush()时候session会立刻将数据更新到数据库中。Commit()方法默认调用flush，然后提交事务，而flush()是将缓存区的数据同步到数据库。

一级缓存的优点：

当利用同一个session对象多次查询同一个数据对象时，仅第一次从数据库查询，后续几次从缓冲区中取。如果缓存的对象过多会造成溢出，通过下面的方法处理。

Sessionsession=

HibernateUtil.getSession();

Transactiontx=

session.beginTransaction();

for(inti=1;i<100000;i++){

Useruser=newUser();

//......

session.save(user);

//20条调用一次flush

if(i%20==0){

session.flush();//同步到数据库

session.clear();//清空缓存

}

}

tx.commit;

HibernateUtil.close();

2.对象持久性：

Hibernate框架用于实现对数据库的操作，为应用程序构建一个持久层，（由持久对象构成）

在hibernate使用中，实体对象有三种状态：

临时状态：new

采用session对象查询出来的，受session对象管理的对象。比如：load,get,save,update方法后的对象，处在持久性的对象的特点：数据状态可以更新到数据库；对象不能被垃圾回收器回收；对象会一直在一级缓存区存放，由session管理。

游离/脱管状态：脱离了session的管理，如：调用了session.evict(),session.clear();

3.延迟加载：

Hibernate提供一些方法，利用这些方法返回的对象，并没有立刻加载数据库的数据，而是在调用对象的gertter方法时才触发数据库查询，加载数据记录。

使用延迟加载的好处是；可以降低并发量，减少资源占用，如果同步查询的数量很多，session会溢出，如果是延迟加载，可以让程序支持更多的用户。

哪些方法具有延迟加载：session.load();query.iterator(),关联属性。这些方法返回的对象里面没有数据，数据在使用的时候（调用getXXX方法时）才取。他们返回的不是实体类，而是该实体类动态子类对象，该子类重写了getXXX方法。在这个方法中触发了对数据库的访问。当调用load(),iterator()方法时，具体hibernate调用了GBLIB的功能实现了动态生成子类。Get方法查询的时候没有记录返回Null,load()方法没有记录时会异常。

Query.iterator()这个方法是和query.list()这个方法是对应的一个是返回实体类，一个是延时机制返回动态子类对象。get()和load()方法的区别：相同点：按照主键ID当条件查询某个对象。不同点：load()采用了延迟加载机制，get()为立刻加载；load如果没有符合记录会抛出异常，get方法会返回null；load方法返回的是动态子类对象，get方法返回的是实体类。

使用延时加载方法的时候要注意避免出现nosession的异常。

动态生成子类对象的原理：具体的说是动态代理技术。注意：在自定义的类的时候不要做成final类型的，因为在很多框架中会有类似的动态生成机制

　d)延迟加载实现原理（动态代理技术）--采用延迟加载方法后，Hibernate会在底层动态的创建一个新的实体类，动态编译成class.publicclassFoo$$CGLIB...extendsFoo{

//重写foo中属性的getter方法

publicStringgetName(){

//判断是否有name值，没有查询DB

returnname;

}

}

--Hibernate采用了cglib.jar和asm.jar两个开发包。实现了动态生成新类和编译操作

课堂补充注解：如果不是主键查询的时候用hql：from类名where属性名。Query.setstring(0,);？号是从0开始，不是从1开始。

分页查询的时候：设置分页查询的参数：query.setFisrtResult(begin);设置抓取记录起点；query.setMaxResult(pageSize);设置最大抓取记录。结束点它会自己计算。

如果是在响应jsp之后要关闭session的话可以通过拦截器或者过滤器来在最后进行关闭

=========案例练习==========

1.重构资费列表显示示例

为了支持延迟加载方法，需要在项目中采用OpenSessionInView思想。可以利用Filter和Interceptor技术实现。

*.action-->拦截器前期（无）

-->Action-->DAO-->Result

-->JSP(通过标签和EL获取对象数据)

-->拦截器后期（关闭Session）

-->将HTML结果响应

如何使用同一个Session

处理的情况下：拦截器中使用的session一定要是同一个session这样对于事务的处理才是同一个事务。要使用线程池技术来获取同一个session。

方案一:利用ThreadLocal机制，实现Session与当前线程绑定ThreadLocal<Session>sessionLocal=newThreadLocal<Session>();

获取session的时候要先判断session是不是存在，然后再创建新的session。

方案二:利用Hibernate框架封装的机制,实现Session与当前线程绑定

返回当前线程绑定的session,需要在hibernate.cfg.xml增加配置

//如果没有的新建一个,然后和线程绑定

//该Session对象在事务结束自动关闭

//该Session对象必须在一个事务中使用

returnsf.getCurrentSession();

//创建一个新的Session对象,

//必须手动关闭

第三天

Hibernate关系映射的作用：利用关联映射，Hibernate可以帮着查询加载对象相关的数据，可以简化查询代码，此外还可以基于关系进行增删查改操作。

一对多关系映射：

由一条字段找到多条记录。要设成set<>的属性a.确定1的一方和多的一方，1的一般是主键，多的一般是外键，b.由1的一方对象查询出多的一方的记录。c.首先在1的那方实体类中添加集合属性setd.然后在1的那方的hbm.xml中定义一对多关系映射的描述<setname="关系属性">

<keycolumn="关联条件的外键字段"/>

<one-to-manyclass="关联的另一方类型,即n方类型"/>

</set>e.使用的时候，通过1的那方对象.关系属性获取多的那方的数据

多对一关系映射：

a.需要由多方对象查询1放对象信息。b.在多方实体类中添加属性，属性类为1方类型c.在多方hbm.xml文件中，添加属性的映射描述信息。d.清楚多方的实体类中外键字段描述信息和属性。就是重复出现的字段描述e.使用时，通过多方对象.关联属性获取相关信息。

关联操作注意事项：要避免频繁使用，默认情况下，

A.在hbm.xml中为属性添加lazy=”false”（关联属性数据在主对象加载的时候加载）在为这个属性追加fetch=”join”（指定关联属性加载方式，可以指定为select,join,subselect）默认的是select表示的是需要的时候加载，jion表示的是同时加载使用的是表连接的语句加载。

写一个HQL，采用joinfetch关键字加载关联属性，需要自己写一个sql语句，这样可以自己来决定是什么加载注意：a方案会影响所有service对象操作，不推荐使用，如果需要关联属性随着主对象加载而加载推荐使用b方案实现。

5.级联查询：

6.级联添加：先插入数据在添加级联关系。

7.级联删除：

删除的时候不能用new出来的的对象，要使用缓存的形式进行查询了再session.ldelete();

对主对象做删除操作的时候，关联属性电视剧也做相应的删除操作。先解除关联关系然后再删除。a.需要在hbm.xml中的关联属性开启级联删除操作。b.在执行session.delete(obj)操作时，删除的obj对象时龙session先查询出来。不要使用new出来的对象，因为不具有关联的数据，hibernate找不到相关数据。

缺点：级联删除采用n+1个delete删除数据，因此关联数据对象n过多的时候，不推荐使用，而是采用hql语句进行批量删除。

Inverse属性：可以控制关系字段值维护的操作是由哪一方负责的，也就是两个表的关联条件字段。默认情况下由具有关系的对象双方负责，也就是不管是哪个做了操作都要对字段进行维护，让哪一方负责维护就在哪一方添加这个属性就额可以。一般是在1方关联属性中使用inverse=true，意思是要1方放弃关系维护操作，不会出现update维护关系的这种语句。只要是一对多的情况下建议使用inverse=true这个属性，

第四天

1.如何利用MyEclipse根据数据库生成实体类和映射描述文件

1)在DBBrowser中建立一个与数据库的连接

2)新建一个WebProject工程

3)为工程添加Hibernate开发框架

（导入包，添加主配置及其参数设置）

选中工程-->右键-->MyEclipse-->AddHibernateCapabilities...

4)按MyEclipse向导添加Hibernate框架开发包，添加主配置文件，设置连接参数，创建一个HibernateUtil工具类.

----------生成实体类和hbm.xml-------------

5)进入DBBrowser，选中要操作的数据表，右键-->HibernateReverseEngineering.按向导生成实体类和hbm.xml.

6)向导界面1：选择存放实体类和hbm文件的工程和package。

选择要生成文件:hbm.xml，pojo，dao

7)向导界面2:将TypeMapping选中为HibernateTypes

向导界面3:点击Finish完成

2.多对多关系映射

多对多关系在数据库中需要3张表表示。

例如AdminInfo-->Admin_Role<--Role

如果需要根据Admin查找Role，可以建立Admin到Role的多对多关系映射。具体过程如下：

a.在Admin实体类中追加一个集合属性，用于存储相关联的Role对象信息

b.在Admin的hbm.xml中描述集合属性映射

<setname="关系属性"table="关系表">

<keycolumn="与当前类型联的关系表字段">

</key>

<many-to-manyclass="关联的另一方类型"

column="与另一方类型关联的关系表字段">

</many-to-many>

</set>

3.继承关系映射

第五天

---------总结---------

1.第一天

理论：Hibernate作用和原理

应用：Hibernate对单表的基本操作

2.第二天

理论：了解什么是一级缓存，对象持久性，延迟加载

应用：掌握OpenSessionInView模式控制Session关闭。将Session与请求处理线程绑定。使用ThreadLocal自己封装，也可以使用Hibernate3封装的getCurrentSession();

3.第三天

理论：关联映射的作用

应用：掌握一对多，多对一基本映射

基于关系*查询，添加，*删除等操作

4.第四天

理论：利用Myeclipse生成实体类和映射描述

应用：掌握多对多基本映射和操作

掌握继承基本映射和操作

5.第五天

理论：了解其他的查询方式，高级特性

应用：Hibernate的HQL查询

==============================

1)继承关系映射

a.父类一张表，每个子类一个表，主键对等

b.可以采用<joined-subclass>进行继承关系映射，具体如下

--在子类追加extends父类

--在子类hbm.xml中定义

<joined-subclassname="子类类型"

extends="父类类型"table="子类表">

<keycolumn="子类哪个字段与父类关联">

</key>

//子类中属性的property映射

</joined-subclass>

######示例表Oracle######

CREATETABLEPRODUCT

(

IDNUMBER(5)CONSTRAINTPRODUCT_ID_PKPRIMARYKEY,

NAMEVARCHAR2(20),

PRICENUMBER(15,2),

PRODUCT_PICVARCHAR2(100)

);

CREATESEQUENCEproduct_seq;

CREATETABLEBOOK

(

IDNUMBER(5)CONSTRAINTBOOK_ID_PKPRIMARYKEY,

AUTHORVARCHAR2(20),

PUBLISHINGVARCHAR2(50),

WORD_NUMBERVARCHAR2(20),

TOTAL_PAGEVARCHAR2(20)

);

CREATETABLECAR

(

IDNUMBER(5)CONSTRAINTCAR_ID_PKPRIMARYKEY,

BRANDVARCHAR2(20),

TYPEVARCHAR2(1),

COLORVARCHAR2(50),

DISPLACEMENTVARCHAR2(20)

);

##############################

2)Hibernate查询

*a.HQL查询

HibernateQueryLanguage

HQL与SQL语句结构相似，SQL语句是面向数据表和字段进行查询，而HQL语句是面向Hibernate映射过来的对象和属性进行查询，因此HQL被称为是一种面向对象查询语言

HQL和SQL共同点：

--都支持select,from,where,orderby,

having,groupby等子句。

--都支持运算符表达式，例如+,-,*,/,>,<等

--都支持in,notin,betweenand,like等过滤条件关键字

--都支持分组函max,min,sum,avg,count

HQL和SQL不同点：

--HQL是大小写敏感的，类名和属性名严格区分大小写

--HQL不支持select*写法

--HQL不支持join...on...中的on子句

--HQL不支持表名和字段名

HQL案例：

--查询所有:fromAccount

--参数查询:fromAccountwherestatus=?

fromAccountwherestatus=:stat

--查询部分字段:

selectid,osUsernamefromService

返回ist<Object[]>

selectnewService(id,osUsername)fromService

返回List<Service>

--在hbm.xml中定义hql：

Queryquery=session.getNamedQuery("标识符")

--分页查询用法：

query.setFirstResult(抓取起点从0开始计算)

query.setMaxResult(抓取最大数量);

Listlist=query.list();

b.Criteria查询(QBC)

了解，参考示例和Hibernate帮助文档

c.NativeSQL查询

了解，参考示例和Hibernate帮助文档

第六天-

1.Hibernate高级特性

1)二级缓存技术

SessionFactory级别的缓存，受SessionFactory管理，可以被不同Session访问和操作。默认是关闭。一般在使用时需要利用SessionFactory.evict()等方法显式的管理该缓存

a.什么情况可以考虑使用二级缓存

--该对象被多个不同用户频繁使用

--该对象更新操作不频繁

b.如何使用二级缓存

--添加ehcache.jar开发包和src/ehcache.xml配置

--在hibernate.cfg.xml中开启二级缓存，指定采用哪种二级缓存组件

--需要缓存哪个对象，就在hbm.xml中添加<cache>元素配置

<cacheusage="read-only或read-write"

　region="采用ehcache.xml哪组参数缓存该对象"/>

c.二级缓存管理

sessionFactory.evict方法

2)查询缓存技术

一级和二级缓存只能缓存单个对象，查询缓存可以缓存一个select查询结果。

a.查询缓存的使用

--要对查询的目标对象开启二级缓存

--在hibernate.cfg.xml中开启查询缓存设置

--在执行query.list()查询之前，

调用query.setCacheable(true);

b.适合使用查询缓存的情况

--不同用户都执行相同的SQL查询和相同结果

--查询结果集不发生改变

注意：在使用关联映射时，关系属性数据默认不参与缓存，即使访问对象在缓存中存在，当访问该对象的关联属性数据时，还得去数据库查询。如果需要缓存关联属性数据，需要对关联属性和hbm.xml都设置<cache>元素

*3)悲观锁和乐观锁

当出现多个用户同时执行更新等操作时，会出现事务交叉更新操作的冲突，会破坏业务和数据的完整性。可以使用悲观锁和乐观锁解决这类问题。

a.悲观锁机制：在进行数据查询时追加一个锁机制，进行业务操作，此时其他用户不能进行增删改操作，在事务结束时会自动将锁释放，其他用户可以继续执行此类操作。

悲观锁特点：将用户操作一个一个处理，可以解决更新并发问题，缺点是处理效率比较低。

Hibernate悲观锁机制一般是借助于数据库锁机制。

session.load(Train.class,1,);

session.get(Train.class,1);

b.乐观锁机制：多个不同用户都可以同时对数据库记录进行查看和更新操作，但是最先commit提交的用户会执行成功，后续用户会以异常形式提示失败。

乐观锁是借助于一个版本字段进行控制，当并发操作中一个用户成功提交了，版本字段值会自动加1，后续提交的对象版本信息小于数据库版本字段值会被hibernate阻止掉。

乐观锁特点：允许多个用户同时操作，处理效率相对较高。

乐观所使用步骤：

--将原有数据表追加一列版本字段，初始值0

--在实体类中添加版本属性

--在映射描述文件中采用<version>元素定义版本属性和版本字段的映射

--当发生多个事务并行交叉执行时，第一个提交的成功，后续提交的会抛出异常。可以异常捕获给用户一个友善的提示。

==============示例表=================

createtabletrain(

t_idnumberprimarykey,

t_valuenumber,

t_versionnumber);

insertintotrainvalues(1,100,0);