Hibernate总结

Hibernate学习总结

一.Hibernate入门：

了解Hibernate：hibernate是一个优秀的持久化框架，也是一个主流的ORM框架。

 

1.              持久化：在Java中说持久化，通常指的是使用SQL将数据存储在关系型数据库中。

1.1    持久化层：

：

 

2.              ORM：是持久化的一种解决方案，主要是把对象模型和关系型数据库关系模型映射起来，并且使用元数据对这些映射进行描述。

2.1        映射：

 

3.  创建Hibernate主配置文件（默认文件名为：hibernate.cfg.xml）：

  1)  数据库连接信息，驱动，链接URL，数据库用户名.密码

  2)  相关配置

  3)  连接池配置

  4)  实体类映射文件的路径

4.  学会使用Hibernate完成数据增删改操作

1)  创建实体类（也叫持久化类）

  2)  创建和配置映射文件

       <?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

[...]

</hibernate-mapping>

 

3)  把实体类放入主配置文件中将映射文件的路径信息添加到hibernate.cfg.xml中。<mapping resource=“***/***/***.hbm.xml" />

  4)  测试

  5)  数据库操作

 

                      

 

 

5.  Hibernate核心接口

  1) Configuration接口 2)SessionFactory接口 3) Session接口 4) Transaction

5) Query和Criteria接口

 

6.  实体对象的三种状态：

1) 瞬时状态(Transient)刚用new语句创建，还没有被持久化，且不处于Session的缓存中

2) 持久状态(Persistent)已经被持久化，且加入到Session的缓存中

3) 游离状态(Detached)已经被持久化，但不再处于Session的缓存中

6.1 三种状态的转化：

 

二．Hibernate关联映射

1．实体关联关系

关联关系：通过一个对象持有另一个对象的实例

泛化关系：通过对象之间的继承方法来实现

2．单向多对一关联（many-to-one）

many的一端应持有one的一端的对象（引用）映射文件体现多对一关联操作

映射文件例：

<hibernate-mapping>

       <class name="org.ijob.bean.Resume" table="ijob_resume">

              <!—省略主键映射及属性映射 -->

              <!-- 多对一关联 -->

              <many-to-one name="seeker" class="org.ijob.bean.Seeker">(1)      

                     <column name="seeker_id"></column>(2)

              </many-to-one>

       </class>

</hibernate-mapping>

(1)、name为属性名，class为“one”端类名

(2)、外键列列名

3.  单向一对多关联（one-to-many）

one的一端应持有many端的对象集合映射文件体现一对多关联操作

       映射文件例：

<hibernate-mapping>

       <class name="org.ijob.bean.Seeker" table="ijob_seeker">

              <!—省略主键映射及属性映射 -->

              <set name="resumes">       (1)

                     <key column="seeker_id"></key>    (2)

                     <one-to-many class="org.ijob.bean.Resume"/>   (3)

              </set>

</class>

</hibernate-mapping>

代码解析：

(1)、set集合节点适用于配置一对多关联关系， name属性指定one的一端对应属性名。(2)、外键列列名。(3)、class属性指定many端的全限定类名。

4.  多对多关联（many-to-many）

将多对多转换成两个一对多为中间表建立实体类及映射文件，两个端点和中间端分别建立双向一对多关联

如果中间表是联合主键：

<!-- 联合主键 -->

<composite-id>

       <!--同时表达这是外键-->

       <key-many-to-one name=“**” column=“***" class=“***" ></key-many-to-one>

       <key-many-to-one name=“**” column=“**" class=“**" ></key-many-to-one>

</composite-id>

三．Hibernate开发模式与工具

       1.  选择开发过程，最常见的开发过程有两种：自上而下和自下而上。

       1.1 自上而下：在自上而下的开发过程中，由业务分析和建立领域模型开始，用Java实现实体类。然后构建映射元数据（映射文件），通常是XML文件，也可以是注解，然后用Hibernate的hbm2ddl工具产生数据库模式（hbm指的是hibernate-mapping，2代表的是to，ddl是数据定义语言）。

1.2  自下而上：反之，自下而上开发由一个现成的数据库模式开始，可以利用反向工程提取数据库中的元数据。利用hbm2hbmxml可生成XML映射文件；利用hbm2java，由Hibernate映射元数据生成实体类，利用hbm2dao可生成数据访问对象（DAO）。但是，这种方式生成的代码并不一定能很好地适应于应用的具体要求，有时需要一些手工的修改。

步骤：1）插件安装 2）自动生成主配置文件（也可手工创建） 3)创建Hibernate Console  4）反向工程生成代码

 

四．HQL实用技术

1.  Hibernate 支持两种主要的查询方式：HQL查询是一种面向对象的查询语言，其中没有表和字段的概念，只有类、对象和属性的概念，HQL是应用较为广泛的方式。Criteria 查询，又称为“对象查询”，它用面向对象的方式将构造查询的过程做了封装。

1.1  如何使用HQL（四步）：

1）得到Session  2）编写HQL语句  3）创建Query对象

4）Query接口是HQL查询接口。它提供了各种的查询功能

5）执行查询，得到结果

6）设置别名（alias）

 

 

 

注：b 是Book的别名，通过as 关键字指定，关键字as是可选的

 

1.2  基本语法

HQL看上去很像SQL，但是我们不要被语法结构上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的查询。HQL中没有表和字段的概念，只有类、对象和属性的概念。

1.2.1实体查询

String hql = " from TUser";

执行这条语句会返回TUser以及TUser子类的纪录。hql = "from java.lang.Object"

会返回数据库中所有库表的纪录。

where 语句：hql = "from TUser as user where user.name='yyy'";其中，as可以省略也一样。hql = "from TUser user where user.name='yyy'";

where子句中，我们可以通过比较运算符设定条件，如：

=, <>, >, <, >=, <=, between, not between, in, not in, is, like等。

1.2.2参数绑定

通过顺序占位符?来填充参数：

 1)hibernate 中通过session.find方法来填充

 session.find("from TUser user where user.name=?", "Erica", Hibernate.STRING);

  多个参数的情况：

    Object[] args = new Object[] {"Erica", new Integer(20)};

    Type[] types = new Type{Hibernate.STRING, Hibernate.INTEGER};

    session.find("from TUser user where user.name=? and user.age=?", args, types);

2)通过Query接口进行参数填充：

  Query query =session.createQuery("from TUser user where user.name=? and user.age>?");

        query.setString(0,"Erica");

        query.setInteger(1, 20);

通过引用占位符来填充参数：

        String hql = "from TUser where name=:name";

        Query query = session.createQuery(hql);

        query.setParameter("name","Erica");

 

甚至可以将查询条件封装为一个JavaBean

class UserQuery {

    private String name;

    private Integer age;

    //getter and setter

}

 String hql = "from TUser where name=:name and age=:age";

Query query = session.createQuery(hql);

UserQuery uq = new UserQuery();

uq.setName("Erica");

uq.setAge(new Integer(20));

query.setProperties(uq); //会调用里面的getter?

query.iterate();

 

1.2.3连接查询

也可以使用 inner join,left outer join, right out join, full join

排列组合：form TUser, TAddress

 

五．Criteria查询

       1.1  使用iteria查询：

建立DetchedCriteria实例

DetachedCriteria detchedCriteria = DetachedCriteria.forClass(**.class);

省略加入查询条件的代码

Session session = sessionFactory.openSession();

绑定Session并返回一个Criteria实例

Criteria criteria = detchedCriteria.getExecutableCriteria(session);

List users = criteria.list();

 

1.2  Rstriction常用的查询条件：

        方法

说  明

Restrictions.eq()

对应SQL的等于（’=’）

Restrictions.gt()

对应SQL的大于 (‘>’)

Restrictions.ge()

对应SQL的大于等于 (‘>=’)

Restrictions.lt()

对应SQL的小于 (‘<’)

Restrictions.le()

对应SQL的小于等于 (‘<=’)

Restrictions.between()

对应SQL的between子句

Restrictions.like()

对应SQL的like子句

Restrictions.in()

对应SQL的in子句

Restrictions.and()

对应SQL的and

Restrictions.or()

对应SQL的or

Restrictions.not()

对应SQL的not

 

1.3排序：

我们可以使用org.hibernate.criterion.Order对结果进行排序：Criteria criteria = session.createCriteria(Seeker.class);criteria.addOrder(Order.asc("birth"));List users = criteria.list();

注意，在加入Order条件时，使用的是addOrder()方法，而不是add()方法，产生SQL语句时，会使用order by与asc（desc）来进行排序指定。

 

1.3  分页：

Criteria接口的setMaxResults()方法可以限定查询回来的笔数，如果配合setFirstResult()设定查询的起始位置的话，就可以实现简单的分页。

例如：要查询从第51个求职者开始的40个求职者信息，代码如下：

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

criteria.setFirstResult(50);

criteria.setMaxResults(40);

List users = criteria.list();

 

2.  加载计划：

涉及到加载计划（何时加载）的关注点有以下几个：

1）主对象的关联对象何时被加载

2）主对象的关联集合何时被加载

3）主对象本身何时被加载

4）主对象的属性何时被加载

2.1  改变默认加载计划：

通过修改对应类的实体映射文件，改变默认的加载计划。

 

3.              Hibernate 高速缓存

3.1 Hibernate一级缓存：

Hibernate一级缓存的生命周期跟Session的生命周期一样，所以也可以将Hibernate一级缓存称为Session缓存。Hibernate一级缓存是一个强制的高速缓存。get()方法会去一级缓存中查找获取数据（又称命中数据），并且将查询结果放置在一级缓存中。load()也一样。list()方法会将查询结果放置在一级缓存中，但是它不会去一级缓存中查找获取数据，原因是list()方法不是通过id加载的。iterate方法

Iterator<Seeker> iter = session.createQuery(“from **").iterate();

该语句只把ID的值放到迭代器中，当遍历的时候，会根据ID的值再去数据库中查。并且该语句会产生N+1次查询。

3.2 Hibernate 二级缓存：

二级缓存是一个可选的缓存插件，它由SessionFactory负责管理，所以也常将二级缓存称为SessionFactory缓存。由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此二级缓存是进程范围的缓存，可以被线程共享，所以可能存在并发问题，因此需要采用适当的并发访问策略。二级缓存对实体类是可选的，可以在每个类或每个集合的粒度上配置二级缓存。Hibernate的二级缓存策略，是针对于id查询的缓存策略，对于条件查询则毫无作用。

 

 

 

六．延迟加载

   1.1 Hibernate 使用默认延迟加载，第一层称为主对像，主对像的关联对象或者集合不是立即抓取的，加载主对象时他们还是一个代理，只有当需要使用关联对象和关联集合时才会加载，又称为代理对象的初始化。

 

 

 

 

 

以上是我认为本章的重点知识，敬请查阅。