标签：

Hibernate

一、hibernate是什么

1. 一种框架，一种orm框架
   （objext relation mapping）对象关系映射框架。
2. hibernate处于项目的持久层位置，又叫持久化框架。
3. hibernate实际上是对jdbc进行轻量级的封装。

二、需求

1. 切换数据库需要重写编写sql。
2. 使用jdbc操作数据库语句编写比较麻烦。
3. 让程序员只关注业务逻辑，不再关心数据库。

三、快速入门案例

使用手动配置hibernate方式开发一个hibernate项目，完成相关操作。

开发流程

1. 创建一个项目
2. 画出简单的项目框架图
3. 引入Hibernate包

4. 开发Hibernate三种方式

   • 由Domain object --> mapping --> db。 (官方推荐)
   • 由DB开始，用工具生成Mapping的Domain object。（使用较多）
   • 由映射文件开始。

我们使用第二种方式
首先在hibernate数据库下创建student表

1. create table student(
2. id int primary key,
3. name varchar(20) not null,
4. age varchar(20) not null,
5. );

5.开发domain对象 和对象关系映射
对象关系映射文件，用于指定domain对象和表的映射关系，该文件的取名有规范，domain对象hbm.xml,一般和domain对象同一包下。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
6. <hibernate-mapping package="com.sun.hibernate.model">
7. <class name="Student">
8. <id name="id"></id>
9. <property name="name"></property>
10. <property name="age"></property>
11. </class>
12. </hibernate-mapping>

6.手动配置hibernate.cfg.xml文件,该文件用于配置连接的数据库类型，diver，用户名，密码....同时管理对象关系映射文件和该文件的名称，这个文件一般放在src目录下。

1. <?xml version=‘1.0‘ encoding=‘utf-8‘?>
2. <!DOCTYPE hibernate-configuration PUBLIC
3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
6. <hibernate-configuration>
7. <session-factory>
9. <!-- Database connection settings -->
10. <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
11. <property name="connection.url">jdbc:mysql://localhost/hibernate</property>
12. <property name="connection.username">root</property>
13. <property name="connection.password"></property>
15. <!-- JDBC connection pool (use the built-in) -->
16. <!-- <property name="connection.pool_size">1</property> -->
18. <!-- SQL dialect -->
19. <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
21. <!-- Echo all executed SQL to stdout -->
22. <property name="show_sql">true</property>
24. <!-- Enable Hibernate‘s automatic session context management -->
25. <!--<property name="current_session_context_class">thread</property>-->
27. <!-- Drop and re-create the database schema on startup -->
28. <!-- <property name="hbm2ddl.auto">create</property> -->
30. <!-- Disable the second-level cache -->
31. <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
33. <mapping resource="com/sun/hibernate/model/Student.hbm.xml"/>
35. </session-factory>
36. </hibernate-configuration>

7. 创建对应的student模型

1. package com.sun.hibernate.model;
3. public class Student {
4. private int id;
5. private String name;
6. private int age;
7. public int getId() {
8. return id;
9. }
10. public void setId(int id) {
11. this.id = id;
12. }
13. public String getName() {
14. return name;
15. }
16. public void setName(String name) {
17. this.name = name;
18. }
19. public int getAge() {
20. return age;
21. }
22. public void setAge(int age) {
23. this.age = age;
24. }
27. }

8.测试方法（向数据库中添加一条数据）

1. package com.sun.hibernate.model;
4. import org.hibernate.SessionFactory;
5. import org.hibernate.cfg.Configuration;
6. import org.hibernate.classic.Session;
8. public class StudentTest {
9. public static void main(String[] args){
10. Student s = new Student();
11. s.setId(1);
12. s.setName("s1");
13. s.setAge(2);
15. //1.创建Configuration ，该对象用于读取hibernate.cfg.xml，并完成初始化
16. Configuration cfg = new Configuration();
17. //2.创建SessionFactory<这是一个会话工厂，是一个重量级对象>
18. SessionFactory sf = cfg.configure().buildSessionFactory();
19. //3.创建一个session，相当于jdbc Connection<不是jsp中的那个session>
20. Session session = sf.openSession();
21. //4.对hibernate而言，要求程序员在进行增加，删除，修改时必须使用事物提交
22. session.beginTransaction();
23. session.save(s); //insert into ... <sql语句被hibernate封装了>
24. session.getTransaction().commit();
25. session.close();
26. sf.close();
27. }
28. }

直接运行StudentTest就可以将数据插入到数据库中了。

四、 hibernate缓存原理

详细信息

1.session缓存（一级缓存）

Session内置不能被卸载，Session的缓存是事务范围的缓存（Session对象的生命周期通常对应一个数据库事务或者一个应用事务）。
一级缓存中，持久化类的每个实例都具有唯一的OID。

2.二级缓存

第二级缓存是可选的，是一个可配置的插件，默认下SessionFactory不会启用这个插件。
Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器。

什么样的数据适合存放到第二级缓存中？ 　　
1) 很少被修改的数据 　　
2) 不是很重要的数据，允许出现偶尔并发的数据 　　
3) 不会被并发访问的数据 　　
4) 常量数据 　　
不适合存放到第二级缓存的数据？ 　　
1) 经常被修改的数据 　　
2) 绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　
3) 与其他应用共享的数据。

Hibernate查找对象如何应用缓存？
当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；
查不到，如果配置了二级缓存，那么从二级缓存中查；
如果都查不到，再查询数据库，把结果按照ID放入到缓存删除、更新、增加数据的时候，同时更新缓存。

五、 Query接口

通过Query接口我们可以完成更加复杂的查询任务

###快速入门

1. /*获取query应用【这里student不是表，而是domain】
2. where后面的条件可以是一个类的属性名，也可以是表的字段,按照hibernate规定，我们还是应该使用类的属性名*/
3. Query query = session.createQuery("from Teacher where id = 2");
4. //通过list方法获取结果,这个list会自动将封装成对应的dommain
5. //所以我们jdbc进行二次封装的工作没有
6. List<Teacher> list = query.list();
7. for(Teacher tea: list){
8. System.out.println(tea.getName() + " " + tea.getAge());
9. }

六、 criteria接口简单使用

快速入门

1. Criteria cri = session.createCriteria(Teacher.class).setMaxResults(4);
2. List<Teacher> list = cri.list();
3. for(Teacher tea:list){
4. System.out.println(tea.getId() + " " + tea.getName());
5. }

六、HQL

(hibernate query language)

1.需求

在现有的只是基础上，对对象的批量删除，修改，查询还不能很方便的实现。

模拟创建表

2.list

查询所有对象

1. List<Student> list = session.createQuery("from Student").list();

3.uniqueResult

如果检索一个对象，明确知道最多只有一个，则建议使用该方法。
具体用法：

1. Student stu = (Student) session.createQuery(" from Student where sid = 20040001").uniqueResult();

4.HQL常见用法

distinct的用法：(用于过滤重复记录)

1. List<Object[]> list = (List<Object[]>)session.createQuery(" select distinct ssex,sage from Student").list();

between...and的用法

1. List<Object[]> list = (List<Object[]>)session.createQuery(" select distinct sname,ssex,sage from Student where sage between 22 and 24").list();

in 和 not in的用法

1. List<Student> list = session.createQuery("from Student where sdept in (‘数学系‘,‘计算机系‘)").list();

group 和 having 和 order by
group用法：(查询各个系的学生的平均年龄)

1. List<Object[]> list = session.createQuery("select avg(sage),sdept from Student group by sdept").list();

having的使用（显示人数大于等于2的系）

1. List<Object[]> list = session.createQuery("select count(*),sdept from Student group by sdept having count(*) >= 2").list();

(查询各个系女生的人数)

1. List<Object[]> list = session.createQuery("select count(*),sdept from Student where ssex=‘M‘ group by sdept").list();

order by用法(查询所有学生的成绩拼按照成绩高低排序)

1. List<Object[]> list = session.createQuery("select student.sname,course.cname,grade from Studcourse order by grade DESC").list();

查询计算机系共有多少学生
如果返回一列数据，取出数据是必须用Object，而不是Object[]

1. List<Object[]> list = session.createQuery("select count(*) from Student where sdept=‘计算机系‘").list();

查询总成绩是多少

1. List<Object[]> list = session.createQuery("select sum(grade) from Studcourse").list();

查询课程号为1001的课程名称，最高分和最低分

1. List<Object[]> list = session.createQuery("select course.cname,min(grade),max(grade) from Studcourse where course.cid=1011").list();

查询各科大于80分的学生的名字，科目，分数

1. List<Object[]> list =session.createQuery("select student.sname,course.cname,grade from Studcourse where grade > 80").list();

计算各科大于80分的的学生数量

1. List<Object[]> list = session.createQuery("select course.cname,count(*) from Studcourse where grade>80 group by course.cid").list();

5.HQL分页技术

查询所有学生成绩进行高低排序并只分页显示。

1. //获取页数
2. int pageCount = Integer.parseInt(session.createQuery("select count(*) from Studcourse").uniqueResult().toString()) /3 +1;
3. System.out.println("一共有"+pageCount+"页");
4. //开始查询
5. for(int i = 0; i < pageCount; i++){
6. List<Object[]> list = session.createQuery("select student.sname,course.cname,grade from Studcourse order by grade DESC").
7. setFirstResult(i*3).setMaxResults(3).list();
8. for(int j = 0; j < list.size(); j ++) {
9. Object[] obj = list.get(j);
10. System.out.println(obj[0].toString() + " " + obj[1].toString() + " " + obj[2].toString());
11. }
12. System.out.println("*******第"+(i+1)+"页**********");
13. }

6.参数绑定

好处：
1.可读性高
2.效果好
3.防止sql注入漏洞

一般写法：

1. List<Student> list = session.createQuery("from Student where sage = 22 and sname = ‘张三‘").list();

参数绑定写法：
如果我们的参数是冒号形式给出的，则可以这样写：

1. List<Student> list = session.createQuery("from Student where sage=:sage andsname=:sname").setString("sage", "22").setString("sname", "张三").list();

如果我们的参数是问号形式给出的，则可以这样写：

1. List<Student> list = session.createQuery("from Student where sage=? and sname=?").setString(0, "22").setString(1, "张三").list();

将绑定分开写：

1. Query query = session.createQuery("from Student where sage=? and sname=?");
2. query.setInteger(0, 22);
3. query.setString(1, "张三");
4. List<Student> list = query.list();

映射文件中得到hql语句

hibernate提供了一种更加灵活的查询方法。
把hql语句配置到对象关系映射文件

1. <query name="myquerytest">
2. from Student
3. </query>

八、hibernate对象的三种关系

1. one-to-one： 身份证<---->人 丈夫<--->妻子
2. one-to-many: 部门<--->员工
3. many-to-one:员工<--->部门
4. many-to-many:学生<--->老师（尽量避免）
   （在实际开发过程中，如果出现了多对多的关系，我们应该尽量装换为两个一对多或者多对一的关系，这样程序好控制，同时不会有冗余）

九、 对象的三种状态

1. 瞬时状态（transient）

数据库中没有数据与之对应，超过作用域会被JVM垃圾回收器回收，一般是new出来且且与session没有关联的对象。

2.持久状态（persitent）

数据库中有数据与之对应，与当前session有关联，并且相关联的session没有关闭，事物没有提交；持久对象状态发生改变，在事务提交时会影响数据库（hibernate能检测得到）

3.托管状态/游离状态（datached）

数据库中有数据与之对应，但当前没有session与之关联；脱管状态发生改变时，hibernate不能检测到。

1. Student stu = new Student(); //stu就是瞬时状态
2. stu.setSname("王宝强");
3. stu.setSsex("M");
4. stu.setSdept("表演系");
5. stu.setSage(32);
6. stu.setSaddress("河南");
8. Session session = null;
9. Transaction ts = null;
10. try {
11. session = HibernateUtil.openSession();
12. ts = session.beginTransaction();
14. session.save(stu);
15. //stu既处于session管理下，
16. //同时stu被保存到数据库中，因此stu此时是持久态
17. stu.setSname("唐国强");//hibernate能检测到，并且会提交到数据库中去
18. ts.commit();
19. session.close();
20. //这是stu被保存到数据库中，没有处于session的管理之下
21. //此时stu就是脱管状态（游离态）
23. } catch (Exception e) {
24. if(ts != null){
25. ts.rollback();
26. }
27. throw new RuntimeException(e.getMessage());
28. }finally{
29. }

六、 其他

1. 什么是pojo类，他有什么要求？
* pojo类和一张表对应
* 一般放在com.XXX.domain下
* pojo需要一个主键属性（用于标示一个pojo对象）
* 除了主键属性，它还应当有其他属性，属性的访问权限为private
* 提供get/set方法
* 它应当有一个无参构造方法（hibernate反射）
* pojo类其实就是一个javaBean（有时也叫Data对象）

2. hibernate核心类和接口
1. configuration类
2. 读取配置文件
3. 管理关系映射文件
4. 加载hibernate的驱动，url，用户
5. 管理hibernate配置信息

3. hibernate.cfg.xml
4. 对象关系映射文件
5. SessionFactory接口（会话工厂）
1. 可以缓存sql语句和数据（称为session级缓存）
2. 是一个重量级的类，因此需要保证一个数据库有一个SessionFactory
6. 通过SessionFactory获取Session的两个方法
1. openSession()是获取一个新的Session
2. getCurrentSession()获取和当前绑定的session，换言之，在同一个线程中，我们获取的session是同一个session。（如果希望使用getCurrentSession需要配置hibernate.cfg.xml）

1. <property name="current_session_context_class">thread</property>

3.如何选择
如果在同一个线程中，保证使用同一个session，则使用getCurrentSession（），如果在同一个线程中需要使用不同的Session，则使用opentSession（）
4. openSession() 和 getCurrentSession（）的区别
* 通过getCurrentSession获取的session在事务提交以后会自动关闭，通过openSession获取的session则必须手动关闭，但是我们建议不管什么形式获取的session都进行判断后手动关闭。
* 如果是通过getCurrentSession()获取session进行查询时，也要进行事务提交。

7. 本地事务：针对一个数据库的事物
全局事务：跨数据库的事物（jta）

8. session接口：
主要功能和作用
1. session一个实例代表与数据库的一次操作。（当然一次操作可以使crud组合）
2. session实例是通过SessionFactory获取，用完需要关闭。
3. session实例是线程不同步的（不安全），因此要保证在同一线程中使用，可以用getCurrentSession（）
*4.*session可以看做是持久化管理器，它与持久化操作相关的接口。

get() 和load()区别
1. get()方法直接返回实体类，如果找不到数据则返回null。load()会返回一个实体代理对象（当前这个对象可以自动转化为实体对象）。但当代理对 象被调用时，如果数据不存在，就会抛出org.hibernate.ObjectNotFoundException异常。
2. load先到缓存(session缓存/二级缓存)中去查，如果没有则返回一个代理对象(不马上到DB中去找)，等后面使用这个代理对象操作的时候，才到 DB中去查询，这就是我们常说的load在默认情况下支持延迟加载(lazy--->我们可以在配置文件中关闭懒加载功能).

1. <!-- 禁用懒加载功能 -->
2. <class name="Student" lazy="false">

3. get先到缓存(session缓存/二级缓存)中去查，如果没有就到DB中去查（即马上发出sql）。总之，如果你确定DB中有这个对象就用load()，不确定就用get()（这样效率高）

Hibernate

一、hibernate是什么

1. 一种框架，一种orm框架
   （objext relation mapping）对象关系映射框架。
2. hibernate处于项目的持久层位置，又叫持久化框架。
3. hibernate实际上是对jdbc进行轻量级的封装。

二、需求

1. 切换数据库需要重写编写sql。
2. 使用jdbc操作数据库语句编写比较麻烦。
3. 让程序员只关注业务逻辑，不再关心数据库。

三、快速入门案例

使用手动配置hibernate方式开发一个hibernate项目，完成相关操作。

开发流程

1. 创建一个项目
2. 画出简单的项目框架图
3. 引入Hibernate包

4. 开发Hibernate三种方式

   • 由Domain object --> mapping --> db。 (官方推荐)
   • 由DB开始，用工具生成Mapping的Domain object。（使用较多）
   • 由映射文件开始。

我们使用第二种方式
首先在hibernate数据库下创建student表

1. create table student(
2. id int primary key,
3. name varchar(20)notnull,
4. age varchar(20)notnull,
5. );

5.开发domain对象 和对象关系映射
对象关系映射文件，用于指定domain对象和表的映射关系，该文件的取名有规范，domain对象hbm.xml,一般和domain对象同一包下。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
6. <hibernate-mappingpackage="com.sun.hibernate.model">
7. <classname="Student">
8. <idname="id"></id>
9. <propertyname="name"></property>
10. <propertyname="age"></property>
11. </class>
12. </hibernate-mapping>

6.手动配置hibernate.cfg.xml文件,该文件用于配置连接的数据库类型，diver，用户名，密码....同时管理对象关系映射文件和该文件的名称，这个文件一般放在src目录下。

1. <?xml version=‘1.0‘ encoding=‘utf-8‘?>
2. <!DOCTYPE hibernate-configuration PUBLIC
3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
4. "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
6. <hibernate-configuration>
7. <session-factory>
9. <!-- Database connection settings -->
10. <propertyname="connection.driver_class">com.mysql.jdbc.Driver</property>
11. <propertyname="connection.url">jdbc:mysql://localhost/hibernate</property>
12. <propertyname="connection.username">root</property>
13. <propertyname="connection.password"></property>
15. <!-- JDBC connection pool (use the built-in) -->
16. <!-- <property name="connection.pool_size">1</property> -->
18. <!-- SQL dialect -->
19. <propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
21. <!-- Echo all executed SQL to stdout -->
22. <propertyname="show_sql">true</property>
24. <!-- Enable Hibernate‘s automatic session context management -->
25. <!--<property name="current_session_context_class">thread</property>-->
27. <!-- Drop and re-create the database schema on startup -->
28. <!-- <property name="hbm2ddl.auto">create</property> -->
30. <!-- Disable the second-level cache -->
31. <propertyname="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
33. <mappingresource="com/sun/hibernate/model/Student.hbm.xml"/>
35. </session-factory>
36. </hibernate-configuration>

7. 创建对应的student模型

1. package com.sun.hibernate.model;
3. publicclassStudent{
4. privateint id;
5. privateString name;
6. privateint age;
7. publicint getId(){
8. return id;
9. }
10. publicvoid setId(int id){
11. this.id = id;
12. }
13. publicString getName(){
14. return name;
15. }
16. publicvoid setName(String name){
17. this.name = name;
18. }
19. publicint getAge(){
20. return age;
21. }
22. publicvoid setAge(int age){
23. this.age = age;
24. }
27. }

8.测试方法（向数据库中添加一条数据）

1. package com.sun.hibernate.model;
4. import org.hibernate.SessionFactory;
5. import org.hibernate.cfg.Configuration;
6. import org.hibernate.classic.Session;
8. publicclassStudentTest{
9. publicstaticvoid main(String[] args){
10. Student s =newStudent();
11. s.setId(1);
12. s.setName("s1");
13. s.setAge(2);
15. //1.创建Configuration ，该对象用于读取hibernate.cfg.xml，并完成初始化
16. Configuration cfg =newConfiguration();
17. //2.创建SessionFactory<这是一个会话工厂，是一个重量级对象>
18. SessionFactory sf = cfg.configure().buildSessionFactory();
19. //3.创建一个session，相当于jdbc Connection<不是jsp中的那个session>
20. Session session = sf.openSession();
21. //4.对hibernate而言，要求程序员在进行增加，删除，修改时必须使用事物提交
22. session.beginTransaction();
23. session.save(s);//insert into ... <sql语句被hibernate封装了>
24. session.getTransaction().commit();
25. session.close();
26. sf.close();
27. }
28. }

直接运行StudentTest就可以将数据插入到数据库中了。

四、 hibernate缓存原理

详细信息

1.session缓存（一级缓存）

Session内置不能被卸载，Session的缓存是事务范围的缓存（Session对象的生命周期通常对应一个数据库事务或者一个应用事务）。
一级缓存中，持久化类的每个实例都具有唯一的OID。

2.二级缓存

第二级缓存是可选的，是一个可配置的插件，默认下SessionFactory不会启用这个插件。
Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器。

什么样的数据适合存放到第二级缓存中？ 　　
1) 很少被修改的数据 　　
2) 不是很重要的数据，允许出现偶尔并发的数据 　　
3) 不会被并发访问的数据 　　
4) 常量数据 　　
不适合存放到第二级缓存的数据？ 　　
1) 经常被修改的数据 　　
2) 绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　
3) 与其他应用共享的数据。

Hibernate查找对象如何应用缓存？
当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；
查不到，如果配置了二级缓存，那么从二级缓存中查；
如果都查不到，再查询数据库，把结果按照ID放入到缓存删除、更新、增加数据的时候，同时更新缓存。

五、 Query接口

通过Query接口我们可以完成更加复杂的查询任务

###快速入门

1. /*获取query应用【这里student不是表，而是domain】
2. where后面的条件可以是一个类的属性名，也可以是表的字段,按照hibernate规定，我们还是应该使用类的属性名*/
3. Query query = session.createQuery("from Teacher where id = 2");
4. //通过list方法获取结果,这个list会自动将封装成对应的dommain
5. //所以我们jdbc进行二次封装的工作没有
6. List<Teacher> list = query.list();
7. for(Teacher tea: list){
8. System.out.println(tea.getName()+" "+ tea.getAge());
9. }

六、 criteria接口简单使用

快速入门

1. Criteria cri = session.createCriteria(Teacher.class).setMaxResults(4);
2. List<Teacher> list = cri.list();
3. for(Teacher tea:list){
4. System.out.println(tea.getId()+" "+ tea.getName());
5. }

六、HQL

(hibernate query language)

1.需求

在现有的只是基础上，对对象的批量删除，修改，查询还不能很方便的实现。

模拟创建表

2.list

查询所有对象

1. List<Student> list = session.createQuery("from Student").list();

3.uniqueResult

如果检索一个对象，明确知道最多只有一个，则建议使用该方法。
具体用法：

1. Student stu =(Student) session.createQuery(" from Student where sid = 20040001").uniqueResult();

4.HQL常见用法

distinct的用法：(用于过滤重复记录)

1. List<Object[]> list =(List<Object[]>)session.createQuery(" select distinct ssex,sage from Student").list();

between...and的用法

1. List<Object[]> list =(List<Object[]>)session.createQuery(" select distinct sname,ssex,sage from Student where sage between 22 and 24").list();

in 和 not in的用法

1. List<Student> list = session.createQuery("from Student where sdept in (‘数学系‘,‘计算机系‘)").list();

group 和 having 和 order by
group用法：(查询各个系的学生的平均年龄)

1. List<Object[]> list = session.createQuery("select avg(sage),sdept from Student group by sdept").list();

having的使用（显示人数大于等于2的系）

1. List<Object[]> list = session.createQuery("select count(*),sdept from Student group by sdept having count(*) >= 2").list();

(查询各个系女生的人数)

1. List<Object[]> list = session.createQuery("select count(*),sdept from Student where ssex=‘M‘ group by sdept").list();

order by用法(查询所有学生的成绩拼按照成绩高低排序)

1. List<Object[]> list = session.createQuery("select student.sname,course.cname,grade from Studcourse order by grade DESC").list();

查询计算机系共有多少学生
如果返回一列数据，取出数据是必须用Object，而不是Object[]

1. List<Object[]> list = session.createQuery("select count(*) from Student where sdept=‘计算机系‘").list();

查询总成绩是多少

1. List<Object[]> list = session.createQuery("select sum(grade) from Studcourse").list();

查询课程号为1001的课程名称，最高分和最低分

1. List<Object[]> list = session.createQuery("select course.cname,min(grade),max(grade) from Studcourse where course.cid=1011").list();

查询各科大于80分的学生的名字，科目，分数

1. List<Object[]> list =session.createQuery("select student.sname,course.cname,grade from Studcourse where grade > 80").list();

计算各科大于80分的的学生数量

1. List<Object[]> list = session.createQuery("select course.cname,count(*) from Studcourse where grade>80 group by course.cid").list();

5.HQL分页技术

查询所有学生成绩进行高低排序并只分页显示。

1. //获取页数
2. int pageCount =Integer.parseInt(session.createQuery("select count(*) from Studcourse").uniqueResult().toString())/3+1;
3. System.out.println("一共有"+pageCount+"页");
4. //开始查询
5. for(int i =0; i < pageCount; i++){
6. List<Object[]> list = session.createQuery("select student.sname,course.cname,grade from Studcourse order by grade DESC").
7. setFirstResult(i*3).setMaxResults(3).list();
8. for(int j =0; j < list.size(); j ++){
9. Object[] obj = list.get(j);
10. System.out.println(obj[0].toString()+" "+ obj[1].toString()+" "+ obj[2].toString());
11. }
12. System.out.println("*******第"+(i+1)+"页**********");
13. }

6.参数绑定

好处：
1.可读性高
2.效果好
3.防止sql注入漏洞

一般写法：

1. List<Student> list = session.createQuery("from Student where sage = 22 and sname = ‘张三‘").list();

参数绑定写法：
如果我们的参数是冒号形式给出的，则可以这样写：

1. List<Student> list = session.createQuery("from Student where sage=:sage andsname=:sname").setString("sage","22").setString("sname","张三").list();

如果我们的参数是问号形式给出的，则可以这样写：

1. List<Student> list = session.createQuery("from Student where sage=? and sname=?").setString(0,"22").setString(1,"张三").list();

将绑定分开写：

1. Query query = session.createQuery("from Student where sage=? and sname=?");
2. query.setInteger(0,22);
3. query.setString(1,"张三");
4. List<Student> list = query.list();

映射文件中得到hql语句

hibernate提供了一种更加灵活的查询方法。
把hql语句配置到对象关系映射文件

1. <queryname="myquerytest">
2. from Student
3. </query>

八、hibernate对象的三种关系

1. one-to-one： 身份证<---->人 丈夫<--->妻子
2. one-to-many: 部门<--->员工
3. many-to-one:员工<--->部门
4. many-to-many:学生<--->老师（尽量避免）
   （在实际开发过程中，如果出现了多对多的关系，我们应该尽量装换为两个一对多或者多对一的关系，这样程序好控制，同时不会有冗余）

九、 对象的三种状态

1. 瞬时状态（transient）

数据库中没有数据与之对应，超过作用域会被JVM垃圾回收器回收，一般是new出来且且与session没有关联的对象。

2.持久状态（persitent）

数据库中有数据与之对应，与当前session有关联，并且相关联的session没有关闭，事物没有提交；持久对象状态发生改变，在事务提交时会影响数据库（hibernate能检测得到）

3.托管状态/游离状态（datached）

数据库中有数据与之对应，但当前没有session与之关联；脱管状态发生改变时，hibernate不能检测到。

1. Student stu =newStudent();//stu就是瞬时状态
2. stu.setSname("王宝强");
3. stu.setSsex("M");
4. stu.setSdept("表演系");
5. stu.setSage(32);
6. stu.setSaddress("河南");
8. Session session =null;
9. Transaction ts =null;
10. try{
11. session =HibernateUtil.openSession();
12. ts = session.beginTransaction();
14. session.save(stu);
15. //stu既处于session管理下，
16. //同时stu被保存到数据库中，因此stu此时是持久态
17. stu.setSname("唐国强");//hibernate能检测到，并且会提交到数据库中去
18. ts.commit();
19. session.close();
20. //这是stu被保存到数据库中，没有处于session的管理之下
21. //此时stu就是脱管状态（游离态）
23. }catch(Exception e){
24. if(ts !=null){
25. ts.rollback();
26. }
27. thrownewRuntimeException(e.getMessage());
28. }finally{
29. }

六、 其他

1. 什么是pojo类，他有什么要求？
* pojo类和一张表对应
* 一般放在com.XXX.domain下
* pojo需要一个主键属性（用于标示一个pojo对象）
* 除了主键属性，它还应当有其他属性，属性的访问权限为private
* 提供get/set方法
* 它应当有一个无参构造方法（hibernate反射）
* pojo类其实就是一个javaBean（有时也叫Data对象）

2. hibernate核心类和接口
1. configuration类
2. 读取配置文件
3. 管理关系映射文件
4. 加载hibernate的驱动，url，用户
5. 管理hibernate配置信息

3. hibernate.cfg.xml
4. 对象关系映射文件
5. SessionFactory接口（会话工厂）
1. 可以缓存sql语句和数据（称为session级缓存）
2. 是一个重量级的类，因此需要保证一个数据库有一个SessionFactory
6. 通过SessionFactory获取Session的两个方法
1. openSession()是获取一个新的Session
2. getCurrentSession()获取和当前绑定的session，换言之，在同一个线程中，我们获取的session是同一个session。（如果希望使用getCurrentSession需要配置hibernate.cfg.xml）

1. <propertyname="current_session_context_class">thread</property>

3.如何选择
如果在同一个线程中，保证使用同一个session，则使用getCurrentSession（），如果在同一个线程中需要使用不同的Session，则使用opentSession（）
4. openSession() 和 getCurrentSession（）的区别
* 通过getCurrentSession获取的session在事务提交以后会自动关闭，通过openSession获取的session则必须手动关闭，但是我们建议不管什么形式获取的session都进行判断后手动关闭。
* 如果是通过getCurrentSession()获取session进行查询时，也要进行事务提交。

7. 本地事务：针对一个数据库的事物
全局事务：跨数据库的事物（jta）

8. session接口：
主要功能和作用
1. session一个实例代表与数据库的一次操作。（当然一次操作可以使crud组合）
2. session实例是通过SessionFactory获取，用完需要关闭。
3. session实例是线程不同步的（不安全），因此要保证在同一线程中使用，可以用getCurrentSession（）
*4.*session可以看做是持久化管理器，它与持久化操作相关的接口。

get() 和load()区别
1. get()方法直接返回实体类，如果找不到数据则返回null。load()会返回一个实体代理对象（当前这个对象可以自动转化为实体对象）。但当代理对 象被调用时，如果数据不存在，就会抛出org.hibernate.ObjectNotFoundException异常。
2. load先到缓存(session缓存/二级缓存)中去查，如果没有则返回一个代理对象(不马上到DB中去找)，等后面使用这个代理对象操作的时候，才到 DB中去查询，这就是我们常说的load在默认情况下支持延迟加载(lazy--->我们可以在配置文件中关闭懒加载功能).

1. <!-- 禁用懒加载功能 -->
2. <classname="Student"lazy="false">

3. get先到缓存(session缓存/二级缓存)中去查，如果没有就到DB中去查（即马上发出sql）。总之，如果你确定DB中有这个对象就用load()，不确定就用get()（这样效率高）

hibernate

标签：

原文地址：http://www.cnblogs.com/snail-lb/p/5669121.html