hibernate的查询

Hibernate进行数据库查询非常简单 
应用操作对象的方式来进行查询 
使用HQL来设置查询条件 
[size=large] 

使用get方法 

使用get方法通过持久类名和ID号查找一个对象 Stu instance = (Stu) getsession().get("com.lovo.po.Stu", id); 

使用createQuery方法 

使用createQuery指定查询条件 String queryString = "from Stu as model where model."  + propertyName + "= ?"; Query queryObject = getSession().createQuery(queryString); queryObject.setParameter(0, value); 

配置查询条件 

把查询条件放置在程序之外,避免硬编码; 
在*.hbm.xml中使用<query>标签, 在<![CDATE[ code]]> 中写HQL语句 

   
<query name="onlyfun.caterpillar.queryUser">  
<![CDATA[  
select user.name from User as user where user.age = :age and user.sex = :sex  
]]>  
</query>  



使用name属性查找配置的查询条件 

Query query = session.getNamedQuery("onlyfun.caterpillar.queryUser");  
query.setInteger("age", 25);  
query.setCharacter("sex", 'M');  
List names = query.list();  
}  



Hibernate语言查询 

Hibernate Query Language,HQL 
完全面向对象的查询语句 
查询功能非常强大 
具备继承、多态和关联等特性 
Hibernate官方推荐使用HQL进行查询。 

HQL 

HQL用面向对象的方式生成SQL 
以类和属性来代替表和数据列 
支持多态 
支持各种关联 
减少了SQL的冗余 
HQL支持所有的关系数据库操作 
连接(joins,包括Inner/outer/full joins),笛卡尔积(cartesian products) 
投影(projection) 
聚合(Aggregation,max, avg)和分组(group) 
排序(Ordering) 
子查询(Subqueries) 
SQL函数(SQL function calls) 
实体查询 

String hql=”from User user ”;  
List list=session.CreateQuery(hql).list();  


执行结果是,查询出User实体对象所对应的所有数据,而且将数据封装成User实体对象,并且放入List中返回 
Hibernate的实体查询存在着对继承关系的判定 ,查询超类会检索出所有超类和子类类型实体对象所对应的数据 
与标准SQL语句相似,可以在HQL语句中使用where字 

from User user where user.age=20;  
from User user where user.age between 20 and 30;  
from User user where user.age in(20,30);  
from User user where user.name is null;  
from User user where user.name like ‘%zx%’;  
from User user where (user.age%2)=1;  
from User user where user.age=20 and user.name like ‘%zx%’;  


实体的更新和删除 
Hibernate3中对更新和删除提供灵活和更具效率的解决办法 

Transaction trans=session.beginTransaction();  
String hql=”update User user set user.age=20 where user.age=18”;  
Query queryupdate=session.createQuery(hql);  
int ret=queryupdate.executeUpdate();  
trans.commit();  


类似的方式来完成delete操作 

Transaction trans=session.beginTransaction();  
String hql=”delete from User user where user.age=18”;  
Query queryupdate=session.createQuery(hql);  
int ret=queryupdate.executeUpdate();  
trans.commit();  


属性查询 
当只需要检索实体对象的部分属性所对应的数据时 

List list=session.createQuery(“select user.name from User user ”).list();  


也可以一次检索多个属性 

List list=session.createQuery(“select user.name,user.age from User user ”).list();  


实例化查询 (动态构造实例 ) 

List list=session.createQuery(“select new User(user.name,user.age) from User user ”).list();  

注意,这时所返回的User对象,仅仅只是一个普通的Java对象而以,除了查询结果值之外,其它的属性值都为null(包括主键值id),也就是说不能通过Session对象对此对象执行持久化的更新操作,只能save() 

分组与排序 
Order by子句 ,可以通过asc或者desc关键字指定排序方式 ,默认的排序方式为asc 

from User user order by user.name asc,user.age desc;  


Group by子句与统计查询 

String hql=”select count(user),user.age from User user group by user.age having count(user)>10 ”;  
List list=session.createQuery(hql).list();   


标准的SQL聚集函数都可以在HQL语句中使用,比如:count(),sum(),max(),min(),avg()等 
优化统计查询 

customer
ID varchar2(14)
age number(10)
namevarchar2(20)
order
IDvarchar2(14)
order_numbernumber(10)
customer_IDvarchar2(14)
from Customer c inner join c.orders o group by c.age;(1)  
select c.ID,c.name,c.age,o.ID,o.order_number,o.customer_ID  
from Customer c inner join c.orders o group by c.age;(2)  



语句(1)检索的结果会返回Customer与Order持久化对象,而且它们会被置于Hibernate的Session缓存之中 ,只有事务提交后它们才会从缓存中被清除 ; 
语句(2)返回的是关系数据而并非是持久化对象,因此它们不会占用Hibernate的Session缓存,只要在检索之后应用程序不在访问它们,它们所占用的内存就有可能被JVM的垃圾回收器回收,而且Hibernate不会同步对它们的修改 ; 
尽量使用通过select语句写出需要查询的属性的方式来返回关系数据,而避免使用第一种查询方式返回持久化对象(这种方式是在有修改需求时使用比较适合),这样可以提高运行效率并且减少内存消耗 . 
参数绑定 

传统JDBC的参数绑定 

PrepareStatement pre=connection.prepare(“select * from User where user.name=?”);  
pre.setString(1,”zhao”);  
ResultSet rs=pre.executeQuery();  



在Hibernate中共存在4种参数绑定的方式 

按参数名称绑定,在语句中定义命名参数要用”:”开头 

Query query=session.createQuery(“from User user where user.name=:customername and user.age=:customerage”);  
 query.setString(“customername”,name);  
 query.setInteger(“customerage”,age);  


按参数位置邦定 

Query query=session.createQuery(“from User user where user.name=? and user.age =? ”);  
 query.setString(0,name);  
 query.setInteger(1,age);  


HQL查询中可以通过setParameter()方法邦定任意类型的参数 

String hql=”from User user where user.name=:customername ”;  
 Query query=session.createQuery(hql);  
 query.setParameter(“customername”,name,Hibernate.STRING);  


可以用query.setParameter(“customername”,name); 

但是对于一些类型就必须写明映射类型,比如java.util.Date类型,因为它会对应Hibernate的多种映射类型 .比如Hibernate.DATA或者Hibernate.TIMESTAMP 

使用setProperties()方法,将命名参数与一个对象的属性值绑定在一起 

Customer customer=new Customer();  
customer.setName(“pansl”);  
customer.setAge(80);  
Query query=session.createQuery(“from Customer c where c.name=:name and c.age=:age ”);  
query.setProperties(customer);  


setProperties()方法会自动将customer对象实例的属性值匹配到命名参数上,但是要求命名参数名称必须要与实体对象相应的属性同名 
使用绑定参数的优势 
可以利用数据库实施性能优化,因为对Hibernate来说在底层使用的是PrepareStatement来完成查询,因此对于语法相同参数不同的SQL语句,可以充分利用预编译SQL语句缓存,从而提升查询效率 
可以防止SQL Injection安全漏洞的产生 
构建Criteria 查询 
Criteria这个接口代表对一个特定的持久化类的查询 

Session是用来制造Criteria实例的工厂 Criteria criteria = session.createCriteria(Mytest.class); 

Criteria对SQL进行封装, 让开发人员可以用对象的方式来对数据库进行操作 

Criteria criteria = session.createCriteria(User.class);  
// 查询user所有字段  
List users = criteria.list();  
Iterator iterator =  users.iterator();  
System.out.println("id \t name/age");  
while(iterator.hasNext()) {  
    User user = (User) iterator.next();   
    System.out.println(user.getId() +  
                               " \t " + user.getName() +  
                               "/" + user.getAge());              
}  


Criteria是个容器,如果想要设定查询条件,则要使用add()方法加入Restrictions的条件限制  
如下,查询age大于20且小于40的数据 

Criteria criteria = session.createCriteria(User.class);  
criteria.add(Restrictions.gt("age", new Integer(20)));  
criteria.add(Restrictions.lt("age", new Integer(40)));  
List users = criteria.list();  


使用逻辑组合来进行查询 
age等于(eq)20或(or)age为空(isNull)的条件 

Criteria criteria = session.createCriteria(User.class);  
criteria.add(Restrictions.or(   
                   Restrictions.eq("age", new Integer(20)),   
                   Restrictions.isNull("age")   
               ));   
List users = criteria.list();  


SQL语法作限定查询 
使用sqlRestriction()方法来提供SQL语法作限定查询例如:查询name以cater开头的数据 

Criteria criteria = session.createCriteria(User.class);  
criteria.add(Restrictions.sqlRestriction(“{类名}.name LIKE (?)", "cater%", Hibernate.STRING));  
List users = criteria.list();  


其中?将被替换为cater% 
有多个查询条件,如BETWEEN子句的查询,可以如下 

Criteria criteria = session.createCriteria(User.class);  
Integer[ ] ages = {new Integer(20), new Integer(40)};  
Type[ ] types = {Hibernate.INTEGER, Hibernate.INTEGER};  
criteria.add(Restrictions. between("age”,20,30));  
List users = criteria.list();  


Restrictions常用限定查询方法 
Restrictions.eq 等于 
Restrictions.allEq 使用Map,使用key/value进行多个等于的比对 
Restrictions.gt 大于 > 
Restrictions.ge 大于等于 >= 
Restrictions.lt 小于 < 
Restrictions.le 小于等于 <= 
Restrictions.between 对应SQL的BETWEEN子句 
Restrictions.like 对应SQL的LIKE子句 
Restrictions.in 对应SQL的in子句 
Restrictions.and and关系 
Restrictions.or or关系 
Restrictions.sqlRestriction SQL限定查询 

Criteria 高级特性 
对查询结果进行排序 

//查询所有groupId=2的记录   
 //并分别按照姓名(顺序)和groupId(逆序)排序   
 Criteria criteria = session.createCriteria(TUser.class);  
 criteria.add(Expression.eq("groupId",new Integer(2)));  
 criteria.addOrder(Order.asc("name"));  
 criteria.addOrder(Order.desc("groupId"));  


Criteria 和 DetachedCriteria 
Criteria 是在线的,所以它是由 Hibernate Session 进行创建的 
DetachedCriteria 是离线的,创建时无需 Session ---------------------------------------------------------------------- 
DetachedCriteria deCriteria = DetachedCriteria.forClass(QQUser.class); 

deCriteria.add ( Expression.eq("name","木棉花")); 

Criteria criteria = deCriteria.getExecutableCriteria(session); 

List results = criteria.list(); 

相关推荐