`

hibernate02:session对象、hql查询、在线查询也叫对象查询、离线查询

 
阅读更多

第一:概念

深入查询:
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());
   }
  
  }
 
}

  • 大小: 20.9 KB
分享到:
评论

相关推荐

    Hibernate学习资料(离线查询)

    根据提供的文件信息,我们可以深入探讨Hibernate中的离线查询方法及相关知识点。下面将详细介绍这些知识点。 ### Hibernate中的离线查询 Hibernate是一种广泛使用的Java持久层框架,它极大地简化了数据库操作,...

    Hibernate开发所需的jar包

    - HQL(Hibernate Query Language):面向对象的查询语言,类似于SQL,但操作的是对象而非表格。 - Criteria API:提供一种无SQL字符串的查询方式,更安全,避免SQL注入问题。 - Criteria API的子集——...

    hibernate-release-5.2.3.Final

    - Query/Criteria API:提供SQL查询的抽象,支持HQL(Hibernate Query Language)和Criteria API,使得代码更加面向对象。 4. Hibernate的实体管理: 实体类通常与数据库表对应,通过注解或XML文件定义映射关系。...

    hibernate3API

    - 查询对象:Session.get(),Session.load(),Criteria API或HQL查询。 - 开启事务:Session.beginTransaction(),提交事务:transaction.commit()。 6. Criteria API - Criteria API 提供了一种基于Java的方法...

    hibernate(ppt)

    2. Criteria Query和Detached Criteria:允许离线构建查询,避免了内存中的对象状态影响查询。 3. Criteria Join:支持多种类型的连接查询,包括内连接、外连接等。 4. Criteria Projections:用于聚合操作,如...

    Hibernate QBC高级查询.rar

    2. **DetachedCriteria**:这是一个离线查询对象,可以在不与Session交互的情况下构建查询条件,然后在需要的时候再与Session结合执行,这对于延迟加载和构建复杂的查询非常有用。 3. **Criteria查询的构建**:包括...

    hibernate3.3.zip

    get()和load()根据ID加载对象,find()执行HQL(Hibernate查询语言)查找。 5. Transaction管理: Transaction接口用于管理事务,begin()开始事务,commit()提交,rollback()回滚。事务的ACID特性在Hibernate中得到...

    Hibernate全部笔记

    1. **HQL(Hibernate Query Language)**:面向对象的查询语言,类似SQL但操作对象。 2. **Criteria API**:提供动态构建查询的方式,更易读且灵活。 3. **QBC(Query By Criteria)**:基于对象的查询,提供更强大...

    Hibernate实践

    - **HQL(Hibernate Query Language)**:面向对象的查询语言,类似于SQL,但操作的是对象和属性。 - **Criteria查询**:提供了一种更动态的查询方式,可以在运行时构建查询,无需预先知道查询的精确结构。 7. **...

    Hibernate3.2官方中文参考手册

    2. 使用示例:DetachedCriteria用于离线构建查询条件,Criteria用于在线执行查询,Projection用于结果集的投影。 七、Criteria与HQL的比较 1. Criteria更适合动态构建查询,灵活性高,而HQL适用于复杂的静态查询。 ...

    Hibernate3.2_帮助文档

    HQL可以方便地进行复杂的对象查询,避免了直接编写SQL的麻烦。 7. **Criteria查询**:另一种查询方式,提供了更加面向对象的API,通过构建Criteria对象来执行查询,灵活且易于代码的动态构造。 8. ** Criteria API...

    HibernateAPI

    Hibernate 提供了类似于 SQL 的 HQL(Hibernate Query Language),用于查询对象。HQL支持复杂的查询条件、关联查询和聚合函数,使得开发者可以以面向对象的方式编写查询语句。 7. **Criteria查询** Criteria API...

    hibernate3 chm 格式 中文

    7. **HQL(Hibernate Query Language)**:讲解类似于SQL的Hibernate专用查询语言,包括基本查询、聚合函数、子查询等。 8. **Criteria与HQL的比较**:对比两者在查询性能和灵活性上的优缺点。 9. **关联映射**:...

    hibernate-api

    Query API基于HQL(Hibernate Query Language),类似于SQL但面向对象。Criteria API则提供了一个更高级且类型安全的方式来构建查询,无需直接书写字符串查询。 4. **Entity和Mapping**:在Hibernate中,业务对象被...

    Hibernate.3.6.10帮助文档

    5. **查询语言HQL**:Hibernate Query Language,是Hibernate提供的一种面向对象的查询语言,类似于SQL,但更贴近于Java对象。 6. ** Criteria查询**:一种动态构建查询的方法,允许在运行时构建查询,提供了更灵活...

    Hibernate

    6. **查询语言(HQL)**:Hibernate提供的面向对象的查询语言,类似于SQL,但更贴近Java对象,包括简单的查询、复杂查询、条件查询和分页查询。 7. **Criteria API**:另一种进行数据库查询的方式,提供动态构建...

    hibernate-distribution中文帮助手册

    7. **Criteria API**:另一种进行对象查询的方法,提供了更动态、更灵活的查询构造方式。 8. **Criteria与DetachedCriteria**:Criteria用于在线程内的查询,而DetachedCriteria则允许在不直接与数据库交互的情况下...

    Hibernate学习笔记(2)

    2. HQL(Hibernate Query Language):是Hibernate的面向对象查询语言,类似于SQL。HQL支持命名参数和位置参数,例如上面的例子展示了如何通过`createQuery()`创建HQL查询,并使用`setParameter()`或`...

Global site tag (gtag.js) - Google Analytics