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