hibernate

简介：

      Hibernate是一个数据持久化的框架,封装了jdbc简化了对数据库相关的访问和操作,     通过对象-关系映射(orm)可以使用面向对象的方式非常方便操作关系型数据库.hibernate提供了丰富的查询方式（hql,本地sql,craitail）和多种数据加载方式以及数据缓存机制提高程序的效率,减少系统的开销,项目移植方便

hibernate原理:

      通过java的类和数据库表的映射配置,依赖java的反射机制,xml解析技术,jdbc完成对象与数据库之间数据的转换操作,以及对象的关系操作,运行机制是通过发出的数据库操作指令通过配置文件解析转换成相应的sql语句,完成操作。

hibernate操作数据库基本步骤：

1. 读取并解析配置文件

   Configuration conf = newConfiguration().configure();

2. 读取并解析映射信息，创建SessionFactory

   SessionFactory sf = conf.buildSessionFactory();

3. 打开Session

   Session session = sf.openSession();

4. 开始一个事务（增删改操作必须，查询操作可选）

   Transaction tx = session.beginTransaction();

5. 数据库操作

   session.save(user);//或其它操作

6. 提交事务（回滚事务）

   tx.commit();(tx.rollback();)

7. 关闭session

session.close();

hibernate查询

一、 通过id查询单个数据有load和get方式

get load:

   get不支持延迟加载,不使用数据也会从数据库中查询数据

   load支持延迟加载,不使用数据(创建一个代理对象,但是没有数据)则不会从数据中查询数据

   get方法如果该对象不存在则返回空

   load方法如果该对象不存在则返回ObjectNotFoundException

get  load首先都会从缓存区中查询数据

二、 hql查询:是一种面向对象的查询语言，其中没有表和字段的概念，只有类、对象和属性的概念,hibernate中常用的查询方式,

list方法和itrator方法的区别:

list:直接从数据库查询出所有的符合条件的数据

itrator方法:直接从数据库中查询出符合条件的数据的主键,然后根据主键在缓存区中查找主键与该主键一样的对象,如果没有则到数据库中查询,如果有则直接从缓存区取出数据

 

1.1查询--

1. 查询对象

String hql ="from Book as b where b.name='java’";

Query query = session.createQuery(hql);

List<Book> bookList = query.list();

2. 查询对象某个属性

   String hql ="select b.price,b.publish from Book as b where b.name=”sql”;

Query query = session.createQuery(hql);

List list = query.list();

Iterator it = list.iterator();

//取数据

3. 绑定参数

String hql ="from Book as b where b.name=?"

query.setString(0, "java");

 

String hql ="from Book as b where b.name=:name"

query.setString(“name”, "java");

 

String hql="from Book as b where b.name=:name and b.price between :min and :max"

Class Properties(){

Private String name;

Private int min;

Private int max

}

query.setProperties(q p);

4. 聚合函数

select count(house) from Book

5. 排序

        from Book b order by b.price (asc 升序、desc降序)

6. 分组

   select count(b.id) from Book b group by b.typeId having sum(b.price) > 1000

7. 子查询

    select * from Book as b1 where b1.price > ( select avg(b2.price) from Book b2 where b2.typeId = '1')    

8. 连接查询

Fetch:迫切连接方式

//这种查询方式得到的每行数据时一个object类型的数组

from Book b inner join fetch b.type t

//这种查询方式查询得到的每行数据时二个对象Book和type对象

from Book b inner join b.type t

9. 分页

query.setFirstResult((pageIndex-1)*pageSize);

query.setMaxResults(pageSize);

1.2对象查询

1. 查询对象

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

List<Book> result = criteria.list();

2. 条件查询

3. 条件查询绑定参数:

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

    criteria.add(Restrictions.eq("name", "java"));

List result = criteria.list();

4. 使用对象模板查询

 Bookbook = new Book();

book.setPrice(200);

book.setName(“java”);

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

criteria.add(Example.create(book));

List results = criteria.list();

5. 查询排序

criteria.addOrder(Order.desc("price"));

6. 分页

criteria.setFirstResult(3);

criteria.setMaxResults(2);

1.3、本地查询

      Hibernate 对本地SQL查询提供了内置的支持,Session的createSQLQuery()方法返回SQLQuery对象,SQLQuery接口继承了Query接口,使用本地查询必须要绑定对象存储查询后的数据结果SQLQuery接口的addEntity()

 SQLQuery query =  session.createSQLQuery(“select * from Book”);

1.4命名查询：

   

把数据库操作语句定义在程序的外部配置文件中,然后在程序中使用这种方式更加的灵活

<hibernate-mapping>

<class name="com.book.bean.Book" table="BOOK">

<!--省略其他配置-->

</class>

<query name="bookQuery">

<![CDATA[

            from Book b where b.name =:name and b.price =:price

        ]]>

</query>

</hibernate-mapping>

Query query = session.getNamedQuery("bookQuery ");

1.5、 查询方法list()方法和iterate()

1.使用list()方法获取查询结果，每次发出一条查询语句，获取全部数据

2.使用iterate()方法获取查询结果，先发出一条SQL语句用来查询满足条件数据的id，然后依次按这些id查询记录，也就是要执行N+1条SQL语句（N为符合条件的记录数）

二级缓存:

使用缓存主要的目的是提高程序的效率,但是缓存数据存在安全隐患.hibernate默认的二级缓存由ehcache提供(provider),当然也可以使用其他的缓存框架和自定义缓存程序

使用ehcache来实现hibernate的缓存

  1.导入相关的包

  2.配置ehcache缓存框架

<?xml version="1.0" encoding="UTF-8"?>

<ehcache>

<!--缓存目录-->

<diskStore path="d:\\temp" />

<defaultCache maxElementsInMemory="10000" eternal="false"

timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true" />

</ehcache>

  3. 配置hibernate

<!—配置缓存实现程序-->

<property name="hibernate.cache.provider_class">

org.hibernate.cache.EhCacheProvider

</property>

<!-- 启用查询缓存 -->

<property name="hibernate.cache.use_query_cache">true</property>

 4.配置哪些查询使用缓存

<hibernate-mapping>

<class name="com.book.bean.Type" table="Type">

<cache usage="read-write" />

<property name="name" type="java.lang.String">

<column name="NAME" length="100" />

</property>

<set name="books" inverse="true" lazy="false">

<cache usage="read-only" />

<key>

<column name="type_id" precision="22" scale="0" />

</key>

<one-to-many class="com.book.bean.Book " />

</set>

</class>

</hibernate-mapping>

Hibernate与Mybatis对比总结

   Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。其中SessionFactoryBuider，SessionFactory，Session的生命周期都是差不多的。

· Hibernate和MyBatis都支持JDBC和JTA事务处理。

· 都是属于持久层的框架

Mybatis优势

· MyBatis可以进行更为细致的SQL优化，可以减少查询字段。

· MyBatis容易掌握，而Hibernate门槛较高。

Hibernate优势

· Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。

· Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。

· Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。

· Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

他人总结：

· Hibernate功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。 

· Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。 

· iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。 

iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。