HQL select 总结

1. 查询整个映射对象所有字段 
Java代码   收藏代码
  1. //直接from查询出来的是一个映射对象,即:查询整个映射对象所有字段     
  2.         String hql = "from Users";     
  3.         Query query = session.createQuery(hql);     
  4.              
  5.         List<Users> users = query.list();     
  6.         for(Users user : users){     
  7.             System.out.println(user.getName() + " : " + user.getPasswd() + " : " + user.getId());     
  8.         }     
  9.     
  10.  输出结果为:     
  11. name1 : password1 : 1    
  12. name2 : password2 : 2    
  13. name3 : password3 : 3    


2.查询单个字段  
Java代码   收藏代码
  1. //查询单个字段     
  2.         String hql = " select name from Users";     
  3.         Query query = session.createQuery(hql);     
  4.              
  5.         List<String> list = query.list();     
  6.         for(String str : list){     
  7.             System.out.println(str);     
  8.         }     
  9. 输出结果为:     
  10. name1     
  11. name2     
  12. name3    


3.查询其中几个字段 
Java代码   收藏代码
  1. //查询其中几个字段     
  2.         String hql = " select name,passwd from Users";     
  3.         Query query = session.createQuery(hql);     
  4.         //默认查询出来的list里存放的是一个Object数组     
  5.         List<Object[]> list = query.list();     
  6.         for(Object[] object : list){     
  7.             String name = (String)object[0];     
  8.             String passwd = (String)object[1];     
  9.                  
  10.             System.out.println(name + " : " + passwd);     
  11.         }     
  12. 输出结果为:     
  13. name1 : password1     
  14. name2 : password2     
  15. name3 : password3    


4.修改默认查询结果(query.list())不以Object[]数组形式返回,以List形式返回 
Java代码   收藏代码
  1. //查询其中几个字段,添加new list(),注意list里的l是小写的。也不需要导入包,这样通过query.list()出来的list里存放的不再是默认的Object数组了,而是List集合了     
  2.         String hql = " select new list(name,passwd) from Users";     
  3.         Query query = session.createQuery(hql);     
  4.         //默认查询出来的list里存放的是一个Object数组,但是在这里list里存放的不再是默认的Object数组了,而是List集合了     
  5.         List<List> list = query.list();     
  6.         for(List user : list){     
  7.             String name = (String)user.get(0);     
  8.             String passwd = (String)user.get(1);     
  9.                  
  10.             System.out.println(name + " : " + passwd);     
  11.         }     
  12.         /**   
  13.         输出结果为:   
  14.          name1 : password1   
  15.         name2 : password2   
  16.         name3 : password3   
  17.          */    


5.修改默认查询结果(query.list())不以Object[]数组形式返回,以Map形式返回 
Java代码   收藏代码
  1. //查询其中几个字段,添加new map(),注意map里的m是小写的。也不需要导入包,这样通过query.list()出来的list里存放的不再是默认的Object数组了,而是map集合了     
  2.         String hql = " select new map(name,passwd) from Users";     
  3.         Query query = session.createQuery(hql);     
  4.         //默认查询出来的list里存放的是一个Object数组,但是在这里list里存放的不再是默认的Object数组了,而是Map集合了     
  5.         List<Map> list = query.list();     
  6.         for(Map user : list){     
  7.             //一条记录里所有的字段值都是map里的一个元素,key是字符串0,1,2,3....,value是字段值     
  8.             //如果将hql改为:String hql = " select new map(name as username,passwd as password) from Users";,那么key将不是字符串0,1,2...了,而是"username","password"了     
  9.             String name = (String)user.get("0");//get("0");是get(key),注意:0,1,2...是字符串,而不是整形     
  10.             String passwd = (String)user.get("1");     
  11.                  
  12.             System.out.println(name + " : " + passwd);     
  13.         }     
  14.         /**   
  15.         输出结果为:   
  16.          name1 : password1   
  17.         name2 : password2   
  18.         name3 : password3   
  19.          */    


6.修改默认查询结果(query.list())不以Object[]数组形式返回,以Set形式返回,但是因为Set里是不允许有重复的元素,所以:username和password的值不能相同。只需将hql改为:String hql = " select new set(name,passwd) from Users"; 

7.修改默认查询结果(query.list())不以Object[]数组形式返回,以自定义类型返回 
自定义类 
Java代码   收藏代码
  1. package com.domain;     
  2.     
  3. public class MyUser {     
  4.     
  5.     private String username;     
  6.     private String password;     
  7. //因为:String hql = " select new  com.domain.MyUser(name,passwd) from Users";所以必须要有接受2个参数的构造函数     
  8.     public MyUser(String username,String password){     
  9.         this.username = username;     
  10.         this.password = password;     
  11.     }     
  12.          
  13.     public String getUsername() {     
  14.         return username;     
  15.     }     
  16.     public void setUsername(String username) {     
  17.         this.username = username;     
  18.     }     
  19.     public String getPassword() {     
  20.         return password;     
  21.     }     
  22.     public void setPassword(String password) {     
  23.         this.password = password;     
  24.     }     
  25.          
  26.          
  27. }    


Java代码   收藏代码
  1. //通过query.list()出来的list里存放的不再是默认的Object数组了,而是自定义的类MyUser,必须加包名,String hql = "from Users";中的Users类也是必须加包名的,但是因为再Users.hbm.xml里<hibernate-mapping auto-import="true"> auto-import默认值为true(所以auto-import属性也可以不写),自动导入了     
  2.         String hql = " select new  com.domain.MyUser(name,passwd) from Users";     
  3.         Query query = session.createQuery(hql);     
  4.         //默认查询出来的list里存放的是一个Object数组,但是在这里list里存放的不再是默认的Object数组了,而是MyUser对象了     
  5.         List<MyUser> myUsers = query.list();     
  6.         for(MyUser myUser : myUsers){     
  7.             String name = myUser.getUsername();     
  8.             String passwd = myUser.getPassword();     
  9.             System.out.println(name + " : " + passwd);     
  10.         }     
  11.         /**   
  12.         输出结果为:   
  13.         name1 : password1   
  14.         name2 : password2   
  15.         name3 : password3   
  16.          */    


8:条件查询 
Java代码   收藏代码
  1. //条件查询,参数索引值从0开始,索引位置。通过setString,setParameter设置参数     
  2.         String hql = "from Users where name=? and passwd=?";     
  3.         Query query = session.createQuery(hql);     
  4.         //第1种方式     
  5. //      query.setString(0, "name1");     
  6. //      query.setString(1, "password1");     
  7.         //第2种方式     
  8.         query.setParameter(0"name1",Hibernate.STRING);     
  9.         query.setParameter(1"password1",Hibernate.STRING);     
  10.         List<Users> list = query.list();     
  11.         for(Users users : list){     
  12.             System.out.println(users.getId());     
  13.         }     

Java代码   收藏代码
  1. //条件查询,自定义索引名(参数名):username,:password.通过setString,setParameter设置参数     
  2.         String hql = "from Users where name=:username and passwd=:password";     
  3.         Query query = session.createQuery(hql);     
  4.         //第1种方式     
  5. //      query.setString("username", "name1");     
  6. //      query.setString("password", "password1");     
  7.         //第2种方式,第3个参数确定类型     
  8.         query.setParameter("username""name1",Hibernate.STRING);     
  9.         query.setParameter("password""password1",Hibernate.STRING);     
  10.         List<Users> list = query.list();     
  11.         for(Users users : list){     
  12.             System.out.println(users.getId());     
  13.         }    

Java代码   收藏代码
  1. //条件查询,通过setProperties设置参数     
  2.         String hql = "from Users where name=:username and passwd=:password";     
  3.         Query query = session.createQuery(hql);     
  4.         //MyUser类的2个属性必须和:username和:password对应     
  5.         MyUser myUser = new MyUser("name1","password1");     
  6.         query.setProperties(myUser);     
  7.         List<Users> list = query.list();     
  8.         for(Users users : list){     
  9.             System.out.println(users.getId());     
  10.         }    
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate的检索方式:(查询/加载) 1. 通过OID加载 session.get(Users.class, 1); * 2. 通过HQL/SQL 检索 hibernate query language (面向对象的查询语言) * a) 不再操纵表,它操纵的是持久化类的对象 b) 面向对象的 3. QBC ( query by criteria ) 更加面向对象 4. QBE ( query by Example ) 5. SQL Hibernate的检索策略: 1. 延迟检索(加载)映射文件中改变lazy a) Lazy的取值: i. Many-to-one 1. false 2. proxy 3. no-proxy ii. set 一对多 1. true   2. false   3. extra 根据对set容器的不同,可以产生高效的sql访问数据库 2. 批量检索:batch-size=3 a) 可以使用批量检索: b) 在内存中,如果有多个set(代理)容器需要初始化, 则当访问任何一个代理set容器时,一次初始化n个set容器,减少sql语句; c) 产生的语句是:select * from ….. where FK in (?,?,?... …n); 3. 迫切(fetch)左外连接检索: a) 在映射文件中设置:fetch(抓取) i. Select 什么都不做 ii. Subselect 当访问内存中的一个代理容器时,一次将所有的set容器用一个子查询,全部初始化 iii. Join 1. 对OID检索方式有用 2. 对hql检索方式没有用 b) 在hql中要使用迫切左外连接时,必须加 left join fetch 对象.关系属性 i. 如果不加fetch关键字,则hibernate不会抓取关系属性,但会遍历关系属性所对应的表 ii. 不加fetch关键字时,select 要指定返回的对象,否则它要返回数组 iii. 条件:持久化类之间有关系属性映射 Hibernate级联操作对象的关系属性: 映射文件中设置: 1. Cascade a) none b) Save-update 当使用session的api对当前对象进行save,update操作时,对它的关系属性也进行save或者update c) Delete d) All = delete + save-update e) Delete-orphan 只是删除父子关系的子对象 f) All-delete-orphan 父子关系的表设为此值,表示,当删除一个父对象时,将这个set容器中的子对象全部删除 2. Inverse 只能在set映射时使用;它的作用是:是否根据set容器中存放的对象,产生update语句,维护关系(子)表的外键属性;取值为true时,将不产生update语句。当inverse设为true时,通过父亲增儿子时,必须建立双向关系. Session的一级缓存:(相当于一系列的map容器,它是需要维护的) 1. 提高效率 2. 维护缓存中的对象和数据库中对应表的记录之间进行同步 3. 当一级缓存中的对象状态(属性)发展生改变时,session在特定的时刻清理缓存: a) 清理缓存的时间点: i. Transaction.commit(); 事务提交时 ii. Session.flush(); 4. 管理session一级缓存的方法 a) Session.evict(obj)从session的一级缓存中移出一个对象 b) Session.clear() 将一级缓存中的所有对象全部清空 c) Session.close() 关闭一个session 对象的状态和对象的生命周期: 持久化类的对象,在hibernate应用中可以处于三种状态(根据对象和session之间的关系进行划分): 1. 临时态,瞬态:特点: a) 在数据库中没有记录和它对应 b) 和session没有任何关系 c) New 出来的对象,都处于临时态 2. 持久态:特点: a) 处于session的一级缓存中 b) 数据库中有一条记录和它对应 c) Session会在特定的时刻(清理缓存时)维护这个对象和数据库中的记录进行同步 d) 在同一个session的缓存中,具有相同OID的持久态对象,只有一个(同一个session的一缓存中,不可能同时有两个OID相同的同一个持久化类的对象存在) 3. 游离态,脱管 a) 不在一级缓存之中 b) 数据库可能有记录和它对应,也可能没有记录和它对应 c) 从一个持久态对象转化过来的,从session的一级缓存中出来的,因为调用了session的一些方法,产生了这种对象(session.close()) SessionFctory: Hibernate映射一对多关系: public class Dept implements java.io.Serializable { // Fields private Integer deptid; private String deptname; private Integer deptnum; private Integer actNum; private Date cdate; private Set emps = new HashSet(0) ; //getter/setter方法 略… } 映射文件: <hibernate-mapping> <class name="org.wllt.www.po.Dept " table="dept " catalog="hibernate"> <id name="deptid" type="java.lang.Integer" > <column name="deptid" /> <generator class="native" /> </id> <property name="deptname" type="java.lang.String"> <column name="deptname" length="20" /> </property> <property name="deptnum" type="java.lang.Integer"> <column name="deptnum" /> </property> <property name="actNum" type="java.lang.Integer"> <column name="actNum" /> </property> <property name="cdate" type="java.util.Date"> <column name="cdate" length="19" /> </property> <set name="emps" inverse ="true" lazy="true" cascade="none" batch-size="2" fetch="join" > <key> <column name="deptid" /> </key> <one-to-many class="org.wllt.www.po.Emp" /> </set> </class> </hibernate-mapping> Hibernate映射多对一: public class Emp implements java.io.Serializable { private Integer empid; private Dept dept; private String empname; //getter/setter方法略 } <hibernate-mapping> <class name="org.wllt.www.po.Emp" table="emp" catalog="hibernate"> <id name="empid" type="integer"> <column name="empid" /> <generator class="native" /> </id> <many-to-one name="dept" class="org.wllt.www.po.Dept" fetch="select" cascade ="none" lazy ="proxy"> <column name="deptid" /> </many-to-one> <property name="empname" type="string"> <column name="empname" length="30" /> </property> </class> </hibernate-mapping> Hibernate映射一对一(通过主键实现一对一的关系) //主PO对象(一个员工对个应一个身份证) public class Employees implements Serializable{ private Integer empid; private String name; private String sex; private Date birthday; private Double salary; //关系属性: private Idcard idcard; } <hibernate-mapping package ="org.wllt.www.po"> <class name="Employees" table="emp"> <id name="empid" type="java.lang.Integer"> <generator class="increment"/> </id> … 属性映射略 <one-to-one name="idcard" class="Idcard" fetch="select" lazy="proxy" cascade ="save-update"> </one-to-one> </class> </hibernate-mapping> //子PO对象 public class Idcard { private Integer empid; private String cardno; private String addr; private String fzjg; private Date enddate; //关系属性 private Employees emp; } <hibernate-mapping package="org.wllt.www.po3"> <class name="Idcard"> <id name="empid" type="java.lang.Integer"> <generator class="foreign "> <param name="property ">emp</param> </generator> </id> <one-to-one name="emp" class="Employees" fetch="join" constrained="true" cascade="save-update" > </one-to-one> <property name="cardno" type="java.lang.String" /> <property name="addr" type="java.lang.String" /> <property name="fzjg" type="java.lang.String" /> <property name="enddate" type="java.util.Date"/> </class> </hibernate-mapping> Hibernate映射一对一(通过外键实现一对一的关系) 子表引用主表的主键做外键,这个外键建立了unique约束、not-null约束 //主对象: public class Dept implements java.io.Serializable { private Integer deptid; private String deptname; private Integer deptnum; private Integer actNum; private Date cdate; //关系属性 private Phonenote phonenote; } <hibernate-mapping> <class name="org.wllt.www.po.Dept" table="dept" catalog="hibernate"> <id name="deptid" type="java.lang.Integer"> <column name="deptid" /> <generator class="native" /> </id> <-- …property 映射略 --> <one-to-one name="phonenote" class="org.wllt.www.po.Phonenote" property-ref="dept" cascade ="all" fetch="join" > </one-to-one> </class> </hibernate-mapping> 子对象 public class Phonenote implements java.io.Serializable { // Fields private Integer phonid; private Dept dept; private String phonecode; } <hibernate-mapping> <class name="org.wllt.www.po.Phonenote" table="phonenote" catalog="hibernate"> <id name="phonid" type="java.lang.Integer"> <column name="phonid" /> <generator class="native" /> </id> <many-to-one name="dept" class="org.wllt.www.po.Dept" fetch="select" cascade ="all"> <column name="deptid" unique="true" /> </many-to-one> <property name="phonecode" type="java.lang.String"> <column name="phonecode" length="20" not-null="true" /> </property> </class> </hibernate-mapping> Hibernate映射多对多(两个一对多实现多对多) 表:材料表和产品表多对多,在数据库中有中间表即产品材料表用来存放两个表之间的关系 Java类:材料PO,产品PO,中间PO,中间PO的复合主键类(由于是两个一对多形成的多对多,所以,这里只讲一个一对多,另一个是相同的映射方法) //产品类: public class Product { private Integer cpbh; private String cpmc; private String gg; private String sh; private String nbxh; private String txm; private String bzfs; private Set proMals = new HashSet(0); } <hibernate-mapping package="org.wllt.www.po"> <class name="Product" table="prod"> <id name="cpbh" type="java.lang.Integer"> <column name="pro_id"></column> <generator class="increment"/> </id> <-- property 映射略 --> <set name="proMals" inverse="true" cascade="all-delete-orphan"> <key> <column name="pro_id"></column> </key> <one-to-many class="ProMal"/> </set> </class> </hibernate-mapping> 中间PO public class ProMal { private ProMalId id; } 复合主键类: public class ProMalId implements Serializable{ private Product product; private Clzb clzb; } <hibernate-mapping package="org.wllt.www.po"> <class name="ProMal" table="pro_mat"> <composite-id name="id" class ="ProMalId"> <key-many-to-one name ="product" class ="Product" lazy="proxy" column="pro_id" > </key-many-to-one> <key-many-to-one name="clzb" class="Clzb"column="mat_id"> </key-many-to-one> </composite-id> </class> </hibernate-mapping> Hibernate映射多对多(两个PO类直接实现多对多) 表:材料表和产品表多对多,在数据库中有中间表即产品材料表用来存放两个表之间的关系 Java类:材料PO,产品PO,这两个PO分别包含一个set容器, 相互放对方的对象,没有中间PO, 程序员因为得不到中间PO对象,所以不能直接操作数据库的中间表。中间表中的记录的维护工作,只能交给hibernate来处理,这时,set容器的inverse属性必须设为false 主PO: public class Users implements java.io.Serializable { private Integer uerid; private String name; private String passwd; private Set roles = new HashSet(0); } <hibernate-mapping> <class name="org.wllt.www.po2.Users" table="users" atalog="hibernate"> <id name="uerid" type="java.lang.Integer"> <column name="UERID" /> <generator class="increment" /> </id> <-- property的映射略 --> <set name="roles" inverse ="false" table ="USERANDROLE"> <key> <column name="UERID" not-null="true" /> </key> <many-to-many class="org.wllt.www.po2.Roles " column ="ROLESID"/> </set> </class> </hibernate-mapping>

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值