hibernate学习总结

hibernate是java的一个开源的对象映射框架，将java对象和关系型数据库按照特定的关系映射起来，大大简便了java对数据库的操作，体现了java语言面向对象编程的思想。这种映射关系基本有，类名和表名的映射、属性和主键的映射、属性和字段的映射。

使用hibernate框架的步骤是：

1、导入hibernate.jar包，这里不再述说。

2、编写主配置XML文件，文件名为hibernate.cfg.xml，此文件若放在与实体类同根目录下，在创建Configuration对象时可以不声明文件路径；否则，需要声明XML路径

配置文件中包含以下几类信息：数据库连接信息、hibernate配置信息、连接池相关配置信息、实体映射文件路径（相对路径），我们最应该关心的是实体文件路径可以添加多条。

3、编写实体映射XML文件，建议和实体类名相同，文件内必须编码实现上边所说的三种映射关系以及实体之间的一对多、多对一和多对多的关系映射。

4、用hibernate方法实现数据库操作，这个又有以下步骤：

1）创建Configuration对象，读取主配置文件  Configuration cfg=new  Configuration().configure()

2）创建SessionFactory工厂，用于生成session   SessionFactory factory = cfg.buildSessionFactory();

3）打开Session     Session s = factory.openSession()

4）开启事务  Transaction tx = session.beginTransaction()

5）数据库操作  sava()    update()   delete()   find()

6）提交事务 ts.commit()

7）关闭Session  s.close()

hibernate的核心接口介绍：

1、Configuration接口，用于读取主配置XML文件，一个Hibernate应用使用一个Configuration实例来指定主配置文件的位置，

2、SessionFactory接口，一个Hibernate应用从SessionFactory里获得会话实例，创建该对象耗费叫多的资源，所以一个应用中使用唯一一个SessionFactory 对象即可，设计为单例模式。

3、Session接口，它拥有操作持久化对象的一系列API，被称为“持久化管理器”，完成数据库操作后关闭Session

4、Transaction接口，是事务管理的接口，主要有commit()和rollback()两个方法。

5、Query接口，实现对数据库的查询，Query实例可用来绑定查询参数，限定查询返回的结果数，并且最终执行查询，调用list()方法返回结果结合。

hibernate中实体对象状态介绍：

hibernate中实体对象的三种状态在执行hibernate的过程中起着非常关键的作用，以下是对这三种状态的说明：

1、Transient（瞬时状态），新创建的实体实例，没有被持久化，且不处于Session的缓存中，不能进行关联查询；通过save()和saveOrUpdate()方法转换为持久态‘’

2、Persistent（持久状态），已经持久化，而且加载到Session缓存中，这样就能进行实体间的关联查询；通过调用close()、clear()、evict()方法成为游离态，也可以通过delete()方法将实例变为瞬时态。

3、Detached（游离状态），已经被持久化，但不再处于Session的缓存中（Session已关闭；通过update()、saveOrUpdate()、lock()方法变为持久态。

hibernate关联映射：

hibernate的关联映射的前提是实体的关联映射，实体间的关联映射通过一个实体持有另一个实体对象作为属性体现，主要有以下三种关联映射：

1、many-to-one 多对一关联，many的一端应持有one的一端的对象，在many一端的映射文件中添加映射关系，

  <many-to-one name="type" class="entity.Type">  

<column name="type_id"></column>  

</many-to-one>

2、one-to-many 一对多关联，one的一端应持有many端的对象集合，在one的一端的映射文件中添加映射关系，

		<set name="books">
			<key column="type_id"></key>
			<one-to-many class="entity.Book" ></one-to-many>
		</set>

 

 

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

中间实体映射文件：

		<composite-id>
		
			<key-many-to-one name="book" column="book_id" class="entity.Book" ></key-many-to-one>
			<key-many-to-one name="stu" column="stu_id" class="entity.Student" ></key-many-to-one>
		</composite-id>

select b.name,b.count from Book b

 

 

两端实体映射文件：

   	 <set name="record">
            <key column="stu_id"></key>
            <one-to-many class="entity.Record" ></one-to-many>
        </set>

        <set name="record">
            <key column="book_id"></key>
            <one-to-many class="entity.Record" ></one-to-many>
        </set>	 <set name="record">
            <key column="stu_id"></key>
            <one-to-many class="entity.Record" ></one-to-many>
        </set>

        <set name="record">
            <key column="book_id"></key>
            <one-to-many class="entity.Record" ></one-to-many>
        </set>

4、关联查询操作
HQL查询：

HQL查询是一种面向对象的查询语言，其中没有表和字段的概念，只有类、对象和属性的概念，这种查询语句和SQL语句极为相似，因为SQL里的如select、from、where、order by、 group by、between、and、or、in、is、like等等关键字和count()、min()、max()、sum()、avg()等分组函数都适用于HQL，适合对SQL较为熟悉的人使用；

HQL的使用步骤如下：

1） 得到Session 实例，前面已述 

2）编写HQL语句，HQL语句所有操作对象为实体类，所以编写HQL语句时要用类名和属性名

3）创建Query对象

4）执行查询，处理结果

下面是一段使用HQL查询的示例代码：

 	 Configuration cfg = new Configuration().configure();
        sessionFactory = cfg.buildSessionFactory();
        Query query = session.createQuery("from Book");
        List<Book> book = query.list();
        session.close();	 Configuration cfg = new Configuration().configure();
        sessionFactory = cfg.buildSessionFactory();
        Query query = session.createQuery("from Book");
        List<Book> book = query.list();
        session.close();

 

HQL 的查询方式：
1） 投影查询，查询实体某些属性时直接用类名的别名调用实体下的属性名即可如：

   select b.name,b.count from Book b

 

 

2）参数绑定，有两种方法，分别是利用定位参数和利用命名参数，

定位参数采用占位符“？“如下：

 	 String hql="from Book b where b.name like ? ";
        Query query=session.createQuery(hql);
        String name="java";
        query.setString(0, "%"+name+"%");
        List<Book> book=query.list();
        System.out.println(book);
	 String hql="from Book b where b.name like ? ";
        Query query=session.createQuery(hql);
        String name="java";
        query.setString(0, "%"+name+"%");
        List<Book> book=query.list();
        System.out.println(book);

命名参数是用参数占位，示例如下：

 

 	String hql="from Book b where b.name like :name ";
        Query query=session.createQuery(hql);
        String name="%java%";
        query.setString("name",name);
        List<Book> book=query.list();
        System.out.println(book);	String hql="from Book b where b.name like :name ";
        Query query=session.createQuery(hql);
        String name="%java%";
        query.setString("name",name);
        List<Book> book=query.list();
        System.out.println(book);

3） HQL的分页处理，是查询数据表中的某些行取出，如：

query.setFirstResult(40);
query.setMaxResults(20);

输出结果就是数据表中的第41行到60行数据。

4）连接查询，基于实体间的关联关系和映射文件的，在查询结构中对应的包含两个表中的信息，如：

 

        String hql = "select b ,t from Book b join b.type t";
        Query query = session.createQuery(hql);
        List list=query.list();
        for(Object ob:list){
            Object[] ss=(Object[]) ob;
            Book book=(Book) ss[0];
            Type type=(Type) ss[1];
            System.out.println(book.getName()+"\t"+type.getName());
        }

hibernate延迟加载策略

hibernate延迟加载策略：hibernate默认的是延迟加载策略，即按需加载，这种加载策略大大减少了资源的浪费，提高了系统的效率，如果要改变这种策略，只需在实体的映射文件中设置lazy="false"即可，但必须慎用。