本文详细介绍了Hibernate框架中的Session对象、HQL查询、对象查询及离线查询。讨论了Session的事务控制、持久化机制、对象状态转换，以及HQL与SQL的区别。通过示例代码展示了实体类操作、查询方法和DetachedCriteria离线查询的使用。
第一:概念
深入查询：
1.当我们要保存两张表的时候，就需要两个session来开启事务，两个session开启的两个事务互不影响，当第一个事务完成后关闭session之后再打开第二个session。因此session不能再dao层产生和关闭。这样不对。
因此我们应该把事务控制放到业务层。业务层的一个方法调用数据访问层的多个方法，而且保证用同一个session的这个事务来控制这几个dao中的方法，。
2.hql：是hibernate query languange：hibernate查询语言。hql语句不用考虑数据库之间的差异，因为我们在hibernate主配置文件中设置了数据库的方言。hql查询要用query对象
3.本地查询：session.careteSQLQuery是本地查询，只能针对此项目的数据库，因为没有方言。
4.单条查询：
--1.hql=from Emp where name=? ;query=session.createQuery(),query.set(1,"张三")
--2.hql=from Emp where name=:name ;query=session.createQuery(),query.set("name","张三")
5.在hibernate中hql查询，后面跟的字符串可以是from语句也可以是select语句。from语句查询结果是个实体类对象的集合(list)。select查询语句查询出来的结果是一个object[](数组)类型的集合（list）,此list集合中的每个object数组就是一个实体类对象，数组中的每个下标就是对象的各个属性。
6.对象查询criteria，也叫在线查询。这个criteria是关联的意思，因为把where条件都封装到对象的方法里了，因此叫对象查询
7.where 1=1的意思是说先保证where语句随时能用
8.离线查询，是脱离session对象的查询（其他查询都需要由session对象创建）。他封装的是查询条件（where），然后在用criteria把条件封装成对象
----------------------------------------------------------------------
笔记二：
持久化：就是把实体类对象放在session的map结构中
hibernate框架：封装了jdbc的查询过程。
1.主键生成策略：
（1）identity：主键自动增长，适用于mysql（auto_increment）、SQLServer(identity)
(2)uuid.hex:是个算法。产生一个十六进制32位的字符串，这样保证了在互联网上可以唯一的标识数据库中的每一个记录，避免了主键的重复
（3)native（内迪）：自动增长，但更具有兼容性。（oracle使用于sequence，mysql（auto_increment）、SQLServer(identity)）
（4）increnment：只适用于单线程，在多线程情况下线程不安全。所以不建议使用
（5）assigned（饿散的）:由程序员来设置主键字段。（程序员来设置可能造成主键的重复）。是分配的意思
2.session接口API：
hibernate提供了session接口的实现类，并提供了session对象。利用session对象来操作javabean（增删改查），
第一：javabean的持久化：由一个实体类对象（瞬时态）通过session的save方法变成持久化对象（持久化就是永久保存了，例如保存到了数据库）。
注意：当我们执行session.save的时候实体类对象就会进入session对象的map结构中了，然后session对象把实体类对象通过sql语句插入到oracle数据库中
3.session对象的方法：
--1.flush（福辣湿）方法：session对象和数据库同步的机制。（session对象的同步机制，session对象在客户端，数据库在服务器端，因此需要同步）
第一种情况： 持久化对象的属性变更：第一步创建对象并给属性赋值，第二步是执行session的save方法，第三步是修改当中的一个属性值。
最后的结果是修改了这个属性值（也就表明hibernate框架不但执行了一个insert语句，还执行了一个update语句）。
为什么会改变？答：由于session的map结构中的属性发送变更，为了session对象和数据库保持同步，session对象向数据库发送了一个update语句。
什么时候发送的update语句？答：默认情况下，在执行commit的时候，也就是在提交事务的时候发送update语句。有一定的延时
第二种情况：第一步创建对象并给属性赋值，第二步是执行session的save方法，第三步是修改当中的一个属性值，第四步是执行flush方法，第五步在修改一个属性值。
产生的结果就是：产生了两条update语句。
为什么会产生两条update语句？答：flush方法会使session主动跟数据库同步，此时产生一个update语句。同步之后又修改了一个属性值之后在提交时候，提交事务的时候又产生一个update语句
--2.get方法：如何查询唯一的持久化对象？用get方法，session.get(Class,id)。注意查询的时候可以不用事务
get方法是hibernate框架向数据库发送一个select语句。
get方法的执行流程：首先查询session对象的map结构，如果没有在查数据库，查数据库中的会发送select语句。如果session中有（也就是缓存中有这个数据），就不会再发送select语句去数据库查了。
--3.delete方法：如何删除一个持久化对象？
session.delete方法：先删掉sesion对象的map结构中的该数据，在删掉数据库中的该对象。
传入的参数是个对象，其实hibernate框架只需要id，因此只要这个对象有id属性就能够成功删除。
4.创建一个实体类对象，并赋属性值的过程是个瞬时态，因为当我们关闭电脑这个值就没了，没能永久的保存。
save方法的返回值是个serializable序列化类型的(其实就是返回的是主键，这个主键就是序列化类型的)，也就是返回the generated identifier，也就是执行save方法后服务器会返回一个序列化的标识
5.关于游离态的操作
---1.对象离开了session对象的map结构
---2.session对象断开了数据库的连接：此时session对象中map结构中的对象都是游离状态。例如：session.ecict(bean)将某个对象断开,session.clear()清除sesion对象,session.close()关闭session
---3,如何把游离态对象重新变成持久态？
答：实体类对象只有放入session对象中才能跟数据库进行交互。
session的update方法的作用就是把游离态对象变成持久化对象（在dao层中的修改的方法不用session.update进行修改表数据,因为当我们执行对象.set方法的时候session对象就会向数据库发送update方法），而不是修改数据。
update方法的参数是个游离态的对象。session的update方法将会数据库发送一个update语句。此时由游离态变成了持久态（因为执行update语句后会重新同步数据库与session对象）。这个update语句的作用不一定非得是改变数据库的内容，但是肯定会把游离态对象重新变成持久化对象。
---4.为什么参数必须是游离态的，不能是瞬时态的吗？
答：不能，因为瞬时态的对象还没有id属性的值呢，也就是说这个瞬时对象还不完整呢，此时不能进行修改。因此只有游离态对象才会用到update方法
---5,游离态对象的属性变更。
6.javabean对象的三种状态：
--瞬时态：刚刚创建的javabean对象，id属性为null
---持久态：在session对象的map里，并且此时的id属性有值
--游离态：session对象中没有，数据库中有
7.如何区分瞬时对象和游离对象？
答：通过id属性来区分，瞬时态为null。这就需要我们的实体类中的id属性设置成为Integer，因为integer的默认值是null，int类型的默认值是0；
8.merge(墨这)方法：融合：利用游离态对象修改持久化对象，session.merge(游离对象)
做法1：在通过get方法获得对象之后就关闭session（保证此时已经是游离态了），然后修改这个对象u1的属性值，然后在重新开启一个事务并创建相同id的u2对象进行查询，此时发现查询结果是修改之前的结果。(因为第一次关闭session之后变成游离态，就没有session的map结构跟数据库之间的同步机制了)
做法2：在通过get方法获得对象之后就关闭session（保证此时已经是游离态了），然后修改这个对象u1的属性值，然后在重新开启一个事务并创建相同id的u2对象进行查询，并把游离态对象变成持久化对象（使用update方法），执行结果是报错了。
做法3：在通过get方法获得对象之后就关闭session（保证此时已经是游离态了），然后修改这个对象u1的属性值，然后在重新开启一个事务并创建相同id的u2对象进行查询，并用merge方法将游离态对象变成持久化对象u3=session.merge(u1)，
此方法的返回值不是u1对象，而是u2对象，u2与u3对象是同一个对象。u1对象还是瞬时态的对象，u1一直没进入数据库，因为数据库中有这个主键对应着对象了。
综合三种：我想用游离对象修改数据表中的记录，使用update方法就报错，因此要使用merge方法。
9.hql查询：基于hibernate框架的查询，Query q=session.createQuery("from User u where u.id=44")：这是hql的查询语句
把hql语句封装成了query类型的对象，如果结果唯一的话，就User user=q.uniqueRequest()，得到这个对象。
问题：为什么不要get查询呢？
答：因为uniqueRequest()是绕过session对象的查询。如果使用Hql查询，将会立刻实施同步。hql语句也会向数据库发送hql语句
10.查询全部：使用Query对象的list方法：Query q=session.createQuery;q.list()
11.saveorupdate方法：当程序员不知道该对象是瞬时态的还是持久态的时候，就用这个方法。如果这个对象是瞬时态的就调用save方法，如果这个对象是持久态的就调用update方法。
这个判断的依据是我传入的对象的id在数据库中能不能找到。其他字段不管，只管id字段
12.hql查询和sql查询的区别：hql语句会立即执行
总结：hibernate生命周期（状态）：
1.瞬态：存在于内存中，数据库中没有，一级缓存中没有。（所谓的内存就是指数据进入堆内存或者栈内存）
2.持久态：一级缓存也有，同步一级缓存和数据库的数据。（所谓的一级缓存就是指session对象的map结构）
3.游离态：数据库当中有，一级缓存中没有（所谓的游离态对象就是指该对象跟session的map结构断开了）
4.瞬时态变成持久态：是通过save方法，游离态变成持久态是通过update方法
5.当缓存中有的时候就不会去数据库中去查，而是直接访问缓存。
添加的时候会产生缓存。查询的时候会先看有没有缓存，有缓存的话就不进入数据库了。删除的时候是先删掉缓存在删数据库
注意：Query接口是用来封装hql的查询语句的，是把hql的查询语句转化成sql的查询语句.并不执行hql语句，执行是调用query里面的方法的时候才会执行。
笔记三：最原始的比较
（一）Session接口
通过配置文件，Hibernate框架会为我们建立一个Sesssion对象，
通过Session对象，可以调用Session接口中所提供的方法。
（二）Session对象的持久化机制
（1）持久化JavaBean对象
Session对象内部包含一个Map结构，
当调用Session对象save方法时，向数据库发送insert语句，将
JavaBean对象存入表中并返回id属性；Hibernate框架以id属性作键，
将JavaBean对象存入Session对象的map中！
（2）持久化对象的属性变更
持久化对象的属性变更时，如何实施数据库的同步？
同步是通过向数据库发送update语句实现的，目的是使JavaBean对象的变更数据体现
在数据库表中。
①执行session.flush()方法时；//程序员控制
②实施HQL查询时(案例：TestSession#testQuery()方法)；//自动同步
③事务提交时；//自动同步
（3）Session对象通过get方法，获取指定id属性的持久化对象:
①方式：
session.get(Student.class, "1001");
立刻产生和发送SelectSQL语句
②get方法的执行过程：
(a)session对象首先从map中查找，如果没有，再去数据库查询(会产生select语句)，
(b)查询后的数据结果封装成实体bean对象，并存入map中。
---------------------------------------------------
（三）在Hibernate框架下，JavaBean对象有三种状态：
瞬时状态、持久化状态、游离状态
（1）刚诞生时，是瞬时状态；
特点：id属性为null;
（2）进入session后，是持久化状态：
①对持久化对象的属性变更，会产生update语句
②持久化对象的删除:
(a)首先获得持久化对象；
(b)然后删除该对象：
session.delete(bean);
（3）游离状态
①持久化对象转变为游离对象：
(a)session.evict(bean);
(b)session.clear();
(c)session.close();
②游离对象重新持久化：
(a)方式：
session.update(bean);
(b)条件：
Session对象的map结构中，不能含有和游离对象id属性相同的持久化对象，
否则会报异常；
(c)注意：
ⅠSession对象的update方法总是产生update语句，无论游离对象的属性是否变更；
Ⅱupdate方法只能操作游离对象，如果操作瞬时对象将产生异常；
③Hibernate框架如何区分瞬时状态的对象和游离状态的对象？
通过考察对象的id属性是否为null。
瞬时对象的id属性是空(null)，游离对象的id属性不为空(null);
【建议】：
(a)id属性的类型最好使用引用类型，此时id属性的默认值是null;
（如果id属性的类型使用了基本数据类型，比如int，id属性的默认值是0，此时要求在映射配置
文件中的id标签使用unsaved属性，并设置为0。即<id name="id" unsaved=0 type="int">）
(b)如果程序员不能断定当前对象是瞬时状态还是游离状态，可以采用：
session.saveOrUpdate(bean)，此时由Hibernate框架决定使用save方法还是update方法；
④使用游离对象修改持久化对象：
(a)方式:
session.merge(bean);
(b)适用的场合：
在Session对象的map结构中，含有和游离对象id属性相同的持久化对象
(c)merge之后，游离对象还是游离对象；merge方法返回的持久化对象与游离对象不是同一个对象；
（四）HQL查询：
（1）HQL语句（Hibernate Query Language)：
①举例:from User u; //User u=new User();
特点:从面相对象的角度解释HQL语句，比SQL简单。
②对比SQL语句:select * from t_user(表名) tu;
(Structured Query Language)
（2）封装Query对象
Session对象通过createQuery方法，将HQL语句封装为Query对象
（3）Query对象的唯一性查询:
Query#uniqueResult();
（4）Query对象的多值查询:
Query#list()；
（5）HQL查询与get方法的区别:
①get方法首先查询Session对象的map结构；
②HQL查询绕过Session对象，直接查询数据库；
第二：代码实现
1.实体类
package com.model.pojo;
public class chu_hibernate01 {
//模拟员工表
private String empId;//员工编号
private String empName;//员工姓名
private int empAge;//员工年龄
private String empWh;//员工工资
public chu_hibernate01() {
super();
// TODO Auto-generated constructor stub
}
public String getEmpId() {
return empId;
}
public void setEmpId(String empId) {
this.empId = empId;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public int getEmpAge() {
return empAge;
}
public void setEmpAge(int empAge) {
this.empAge = empAge;
}
public String getEmpWh() {
return empWh;
}
public void setEmpWh(String empWh) {
this.empWh = empWh;
}
public chu_hibernate01(String empId, String empName, int empAge,
String empWh) {
super();
this.empId = empId;
this.empName = empName;
this.empAge = empAge;
this.empWh = empWh;
}
}
2.对象关系映射
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.model.pojo">
<class name="chu_hibernate01" table="chu_table01">
<id name="empId" column="empId" type="java.lang.String">
<generator class="native"></generator>
</id>
<property name="empName" column="empName" type="java.lang.String"></property>
<property name="empAge" column="empAge" type="int"></property>
<property name="empWh" column="empWh" type="java.lang.String"></property>
</class>
</hibernate-mapping>
3.hibernate主配置文件
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:ORCL</property>
<property name="connection.username">chu1</property>
<property name="connection.password">1234</property>
<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
<property name="myeclipse.connection.profile">chu</property>
<!-- <property name="hbm2ddl.auto">create</property> -->
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<mapping resource="com/model/pojo/Chu_hibernate01.hbm.xml"/>
</session-factory>
</hibernate-configuration>
4.公共的session工厂类
package com.comm;
import java.io.Serializable;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class BaseDao {
static SessionFactory sf;
//1.静态方法，随着类的加载而加载，因为dao中的每个方法都会用到加载配置文件这几行代码，因此写成静态的这样只用加载一次。
//其实看看hibernate主配置文件我们也能发现，就一个主配置文件，加载一边就把所有内容都加载了，没必要每次访问数据库都加载一遍。
static
{
Configuration c=new Configuration();
Configuration cfg = c.configure("/hibernate.cfg.xml");//加载配置文件
sf=cfg.buildSessionFactory();//创建sessionFactory，因此配置文件的跟标签就是这个session工厂。
}
//2.通过session工厂获得session，对应着配置文件，因为session工厂里面的内容首先是连接数据库的内容，因此要获得session，这里的session相当于jdbc中的connection，用于与数据库进行连接
public Session getSession(){
return sf.openSession();
}
//3.封装增加的方法
public Serializable save(Object obj){
Session session=null;
Transaction tr=null;
Serializable ser=null;
try {
session = this.getSession();//获得session
tr=session.beginTransaction();//开启事务
ser=session.save(obj);//增加的方法，返回值是一个序列化后的id
tr.commit();//事务提交
} catch (Exception e) {
e.printStackTrace();//楚翔异常，异常处理相当于事务回滚
}finally{
session.close();//关闭session
}
return ser;
}
}
5.dao层实现
package com.model.dao.impl;
import java.io.Serializable;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import com.comm.BaseDao;
import com.model.dao.TestDao;
import com.model.pojo.chu_hibernate01;
public class TestDaoImpl extends BaseDao implements TestDao{
//1.添加的方法，返回值是serialiazble
@Override
public int addEmp(chu_hibernate01 emp) {
Serializable ser = super.save(emp);
return Integer.parseInt(ser.toString());
}
//2.Query查询全部，测试from语句（用类名）。单条查询是get
@Override
public List<chu_hibernate01> searchEmp() {
String hql="from chu_hibernate01 where empWh like ?";
Session session = super.getSession();
Query query=session.createQuery(hql);//query查询，因为是查询没有对数据库造成影响，因此可以不创建事务
query.setString(0, "%本科%");
return query.list();
}
//3.Query查询全部:测试select语句查询,用类名，因为有对象关系映射，所以都是类名
public List<Object[]> searchEmp2(){
String hql="select empName,empWh from chu_hibernate01 where empWh like ?";
Session session=super.getSession();
Query query=session.createQuery(hql);
query.setString(0, "%本科%");
return query.list();
}
//4.测试集合函数和uniqueResult方法。
public List searchEmp3() {
Session session=super.getSession();
String hql="select max(empAge),min(empAge) from chu_hibernate01";
Query query=session.createQuery(hql);
Object obj=query.uniqueResult();//找出唯一结果，当这个集合中就一行的时候就能用这个方法
return query.list();
}
//5.Criteria对象查询，也叫在线查询。对象查询是把查询的where条件都封装到对象里了。
public List<chu_hibernate01> searchEmp4() {
Session session=super.getSession();
Criteria c = session.createCriteria(chu_hibernate01.class);//创建对象查询语句，并指明要查的是哪个类。此时表明查询当前这个类，相当于hql=from chu_hibernate01
c.add(Restrictions.disjunction());//相当于1=1
c.add(Restrictions.eq("empAge", 23));//下面是设置查询条件,也就是限制结果集。Restrictions是限制的意思
c.add(Restrictions.like("empWh", "本"));
c.addOrder(Order.desc("empName"));
//c.add(Criterion)//注意：Criterion是查询条件
//上面的几行代码相当于像数据库发送hql="from chu_hibernate01 where 1=1 and empAge=23 and empWh like "%本% order by empWh desc";
return c.list();//产生查询结果，是个集合
}
//注意：Restrictions是限制结果集，里面直接把查询条件写死，Property是也是限制结果集，但是具体怎么现在不少写死的，而是由dc对象给传过来的。
//6.离线查询,查询条件封装到形参DetachedCriteria中了。离线查询的意思是脱离了session对象。可以从session之外的地方传入一个DetachedCriteria对象来当查询条件。
//get单条查询，query查询全部，Criteria对象查询语句都必须由session创建，例如session.get,session.createquery等。离线查询与session无关。
//因此，离线查询需要一个形参DetachedCriteria，他用来封装查询条件。
/*public List<chu_hibernate01> searchEmp5(DetachedCriteria dc){
Session session=super.getSession();
Criteria c = session.createCriteria(chu_hibernate01.class);
c.add(Property.forName("empAge").gt(dc));//这里的意思是找年龄empAge大于dc对象的，dc对象是在当前session之外获取的，dc对象里设置empAge属性的值为平均年龄
c.add(Property.forName("empName").like(dc));
return c.list();
}*/
//7.离线查询，dc封装的是整个sql语句。整个查询语句都由形参dc给定。并通过dc.getExecutableCriteria(session)把dc这个查询语句给当前这个session。
public List<chu_hibernate01> searchEmp5(DetachedCriteria dc){
Session session=super.getSession();
Criteria c = dc.getExecutableCriteria(session);
return c.list();
}
public static void main(String[] args) {
TestDao tdao=new TestDaoImpl();
//1.
/* chu_hibernate01 emp=new chu_hibernate01();
emp.setEmpId("110");
emp.setEmpName("小强");
emp.setEmpAge(23);
emp.setEmpWh("本科");
tdao.addEmp(emp);*/
//2.
/* List<chu_hibernate01> elist = tdao.searchEmp();
for(chu_hibernate01 emp:elist){
System.out.println("输出："+emp.getEmpName()+"\t"+emp.getEmpWh());
}*/
// 3.注意：使用select语句查询的时候，返回的list集合是个Objet[]类型的，由于list集合中的每一个元素都代表数据库中的一行（或者实体类的一个对象），
// 所以集合中的每个元素都是一个object类型的数组，该数组表示该行，数组中的每个元素表示该行中的每一列。
//因此，该集合的泛型必定是Object[]
/* List<Object[]> list=tdao.searchEmp2();
for(Object[] obj:list){//list集合中的每个对象都是一耳光object[]类型的数组，该数组表示一个对象，数组中的元素是该对象的元素。
System.out.println(obj[0]+"\t"+obj[1]);
}*/
//4.
/*List list=tdao.searchEmp3();
Object[] obj=(Object[]) list.get(0);
System.out.println(obj[0]+" "+obj[1]);*/
//5对象查询
/* List<chu_hibernate01> elist=tdao.searchEmp4();
for(chu_hibernate01 emp:elist){
System.out.println(emp.getEmpName()+" "+emp.getEmpAge()+" "+emp.getEmpWh());
}*/
//6.创建DetachedCriteria对象封装查询员工的条件。Property是对某个字段进行查询条件的设置。forName里面是属性名
//DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来 执行它。
/* DetachedCriteria dc = DetachedCriteria.forClass(chu_hibernate01.class)
.setProjection(Property.forName("empAge").avg());
// .add(Restrictions.like("empName", "%本科%"));
List<chu_hibernate01> elist=tdao.searchEmp5(dc);
for(chu_hibernate01 emp:elist){
System.out.println(emp.getEmpName()+" "+emp.getEmpWh()+" "+emp.getEmpAge());
}*/
//7.这里写好一个完整sql语句
DetachedCriteria dc = DetachedCriteria.forClass(chu_hibernate01.class)
.add(Restrictions.like("empWh", "%本科%"));
//遍历的过程
List<chu_hibernate01> elist=tdao.searchEmp5(dc);
System.out.println(elist.size());
for(chu_hibernate01 emp:elist){
System.out.println(emp.getEmpName()+" "+emp.getEmpWh()+" "+emp.getEmpAge());
}
}
}
扫一扫
1646
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
