Hibernate5

转自：点击打开链接

通过asm和cglib二个包实现；Domain是非final的。

1.session.load懒加载。

2.one-to-one(元素)懒加载：

必需同时满足下面三个条件时才能实现懒加载

(主表不能有constrained=true,所以主表没有懒加载)

lazy!=false 2)constrained=true 3)fetch=select

3.one-to-many (元素)懒加载：1)lazy!=false 2)fetch=select

4.many-to-one (元素) ：1)lazy!=false 2)fetch=select

5.many-to-many (元素) ：1)lazy!=false 2)fetch=select

6.能够懒加载的对象都是被改写过的代理对象，当相关联的session没有关闭时，访问这些懒加载对象（代理对象）的属性（getId和getClass除外）hibernate会初始化这些代理，或用Hibernate.initialize(proxy)来初始化代理对象；当相关联的session关闭后，再访问懒加载的对象将出现异常。

缓存的作用主要用来提高性能，可以简单的理解成一个Map；使用缓存涉及到三个操作：把数据放入缓存、从缓存中获取数据、删除缓存中的无效数据。

一级缓存，Session级共享。

save,update,saveOrUpdate,load,get,list,iterate,lock这些方法都会将对象放在一级缓存中，一级缓存不能控制缓存的数量，所以要注意大批量操作数据时可能造成内存溢出；可以用evict,clear方法清除缓存中的内容。

二级缓存，SessionFactory级共享。

实现为可插拔，通过修改cache.provider_class参数来改变;

hibernate内置了对EhCache,OSCache,TreeCache,SwarmCache的支持，可以通过实现CacheProvider和Cache接口来加入Hibernate不支持的缓存实现。

在hibernate.cfg.xml中加入:

<class-cache class="className" usage="read-only"/>

或在映射文件的class元素加入子元素:

<cache usage="read-write"/>

其中usage:read-only,read-write,nonstrict-read-write,transactional

 

Session的:save(这个方法不适合native生成方式的主键),

update,saveOrUpdate,list,iterator,get,load,以及Query,Criteria都会填充二级缓存，但只有(没打开查询缓存时)Session的iterator,get,load会从二级缓存中取数据(iterator可能存在N+1次查询)。

Query,Criteria(查询缓存)由于命中率较低，所以hibernate缺省是关闭；修改cache.use_query_cache为true打开对查询的缓存，并且调用query.setCacheable(true)或criteria.setCacheable(true)。

SessionFactory中提供了evictXXX()方法用来清除缓存中的内容。

统计信息打开generate_statistics，用sessionFactory.getSatistics()获取统计信息

分布式缓存和中央缓存。

使用缓存的条件

1.读取大于修改。

2.数据量不能超过内存容量。

3.对数据要有独享的控制。

4.可以容忍出现无效数据。

JDBCTransaction

单个数据库（一个SesisonFactory对应一个数据库），由JDBC实现。

Session session = null;

Transaction tx =null;

try {

session = sessionFactory.openSession();

tx = session.beginTransaction();

//process

tx.commit();

} catch(HibernateException e){

if(tx != null)tx.rollback();throw e;

}finally {

if (session != null)session.close();

}

connection.setAutoCommit(false);

connection.commit();conn.rollback();

JTATransaction

可以简单的理解成跨数据库的事物，由应用JTA 容器实现；使用JTATransaction需要配置hibernate.transaction.factory_class参数，该参数缺省值是org.hibernate.transaction. JDBCTransactionFactory，当使用JTATransaction时需要将该参数改成org.hibernate.transaction.JTATransactionFactory，并配置jta.UserTransaction参数JNDI名(Hibernate在启动JTATransaction时要用该值到JNDI的上下文Context中去找javax.transaction.UserTransaction)。

javax.transaction.UserTransactin tx = context.lookup(“jndiName”);

try{

tx.begin();

//多个数据库的session操作;

//session1….

//session2….

tx.commit();

}catch(Exception e){

tx.rollback(); throw e;

}

lsession context和事务边界

用current_session_context_class属性来定义context（用sessionFactory.getCurrentSession()来获得session），其值为：

1.thread：ThreadLocal来管理Session实现多个操作共享一个Session，避免反复获取Session，并控制事务边界，此时session不能调用close当commit或rollback的时候session会自动关闭(connection.release_mode:after_transaction)。

Open session in view：在生成（渲染）页面时保持 session打开。

2.jta：由JTA事务管理器来管理事务(connection.release_mode:after_statement)。

l悲观锁和乐观锁

悲观锁由数据库来实现；乐观锁hibernate用version和timestamp来实现

lhibernate.cfg.xml和hbm.xml内容解释

l数据类型

 1.<property name=“name” type=“java.lang.String”/>

  type可以是hibernate、java类型或者你自己的类型(需要实现hibernate的一个接口)。

2.基本类型一般不需要在映射文件(hbm.xml)中说明，只有在一个JAVA类型和多个数据库数据类型相对应时并且你想要的和hibernate缺省映射不一致时，需要在映射文件中指明类型(如:java.util.Date,数据库DATE,TIME,DATATIME,TIMESTAMP，hibernate缺省会把java.util.Date映射成DATATIME型，而如果你想映射成TIME，则你必须在映射文件中指定类型)。

3.数据类型的对应关系见参考文档5.2.2

Session是非线程安全的，生命周期较短，代表一个和数据库的连接，在B/S系统中一般不会超过一个请求；内部维护一级缓存和数据库连接，如果session长时间打开，会长时间占用内存和数据库连接。

SessionFactory是线程安全的，一个数据库对应一个SessionFactory，生命周期长，一般在整个系统生命周期内有效；SessionFactory保存着和数据库连接的相关信息（user，password，url）和映射信息，以及Hibernate运行时要用到的一些信息。

lflush时将一级缓存与数据库同步

大批处理

大量操作数据时可能造成内存溢出，解决办法如下：

1.清除session中的数据

for(int i=0;i<100000;i++)session.save(obj);

for(int i=0;i<100000;i++){

session.save(obj);

if(i% 50 == 0){session.flush(); session.clear();}

}

2.用StatelessSession接口：它不和一级缓存、二级缓存交互，也不触发任何事件、监听器、拦截器，通过该接口的操作会立刻发送给数据库，与JDBC的功能一样。

StatelessSession s = sessionFactory.openStatelessSession();该接口的方法与Session类似。

3.Query.executeUpdate()执行批量更新，会清除相关联的类二级缓存(sessionFactory.evict(class))，也可能会造成级联，和乐观锁定出现问题

HQL

1查询多个对象select art, user from Article art, User user where art.author.id=user.id and art.id=:id这种方式返回的是Object[]，Object[0]:article,Object[1]:user。

2分页query.setFirstResult,query.setMaxResults.

  查询记录总数query.iterate(“select count(*) from Person”).next()

3批量更新query.executeUpdate()可能造成二级缓存有实效数据。

Criteria

1排序Criteria.addOrder(Order.desc(propertyName));

2关联查询criteria.setFetchMode(“propertyName”, FetchMode.SELECT)与映射文件中关联关系的fetch作用一致。

3投影Projections.rowCount(),max(propertyName), avg, groupProperty…

4分页Projections.rowCount(),criteria.setFirstResult(),criteria.setMaxResults()

5DetachedCriteria可在session外创建（在其他层创建比如在Service中创建）然后用getExecutableCriteria(session)方法创建Criteria对象来完成查询。

6Example查询,Example.create(obj);criteria.add(example)。

N+1次查询和懒加载

1.用Query.iterator可能会有N+1次查询。

2.懒加载时获取关联对象。

3.如果打开对查询的缓存即使用list也可能有N+1次查询。

拦截器与事件

拦截器与事件都是hibernate的扩展机制，Interceptor接口是老的实现机制，现在改成事件监听机制；他们都是hibernate的回调接口，hibernate在save,delete,update…等会回调这些类。

SQL和命名查询

用Map代替Domain对象；将对象转化为XML。

Hibernate不适合的场景

不适合OLAP(On-Line Analytical Processing联机分析处理)，以查询分析数据为主的系统；适合OLTP（on-line transaction processing联机事务处理）。

对于些关系模型设计不合理的老系统，也不能发挥hibernate优势。

数据量巨大，性能要求苛刻的系统，hibernate也很难达到要求, 批量操作数据的效率也不高。