关于HQL、QBC、Nnative sql的运用

此文章转载自该博主的文章。如若侵犯您的隐私,请见谅。请立即通知我,我会马上处理。

        首先有一点需要了解的是:hql(Hibernate Query Language)、qbc(Query By Criteria)、native sql都是hibernate的三种数据查询方式。

Hibernate Query Language(HQL

HQL具有与SQL语言类似的语法规范,只不过SQL针对表中字段进行查询,而HQL针对持久化对象,它用来取得对象,而不进行update、delete和insert等操作。而且HQL是完全面向对象的,具备继承、多态和关联等特性。

1.from子句

from字句是最简单的HQL语句,例如 from Student,也可以写成select s from Student s。它简单地返回Student类的所有实例。

除了Java类和属性的名称外,HQL语句对大小写并不敏感,所以在上一句HQL语句中,from与FROM是相同的,但是Student与student就不同了,所以上述语句写成from student就会报错。下列程序演示如何通过执行from语句取得所有的Student对象。

 Query query = session.createQuery(“from Student”); 

List list = query.list(); for (int i=0;i<list.size(); i++) { 

    Student stu = (Student)list.get(i); System.out.println(stu.getName()); }

如果执行HQL语句“from Student, Course”,并不简单地返回两个对象,而是返回这两个对象的的笛卡儿积,这类似于SQL语句中字段的全外连接。Student, Course是两个数据库名

2.select子句

有时并不需要得到对象的所有属性,这时可以使用select子句进行属性查询,例如,select s.name from Student s。下面程序演示如何执行这个语句:

 Query query = session.createQuery(“select s.name from Student s”); List list = query.list(); for (int i=0;i<list.size(); i++) { String name = (String)list.get(i); System.out.println(ame()); }

如果要查询两个以上的属性,查询结果会以数组的方式返回,如下所示:

 Query query = session.createQuery(“select s.name, s.sex from Student as s”); List list = query.list(); for (int i=0;i<list.size(); i++) { Object obj[] = (Object[])list.get(i); System.out.println(ame(obj[0] + “的性别是:” +obj[1])); }

在使用属性查询时,由于使用对象数组,操作和理解都不太方便,如果将一个object[]中所有成员封装成一个对象就方便多了。下面的程序将查询结果进行了实例化:

Query query = session.createQuery(“select new Student(s.name, s.sex) from Student s”); List list = query.list(); for (int i=0;i<list.size(); i++) { Student stu = (Student)list.get(i); System.out.println(stu.getName()); }

要正确运行以上程序,还需要在Student类中加入一个如下的构造函数:

public Student(String name, String sex) { this.name = name; this.sex = sex; }

3.统计函数查询

可以在HQL中使用函数,经常使用的函数有:

count():统计记录条数 min():求最小值 max():求最大值 sum():求和 age():求平均值

例如,要取得Student实例的数量,可以编写如下HQL语句:

 select count(*) from Student

取得Student的平均年龄的HQL语句如下:

select avg(s.age) from Student as s

可以使用distinct去除重复数据:

 select distinct s.age from Student as s

4.where子句

HQL也支持子查询,它通过where子句实现这一机制。where子句让用户缩小要返回的实例的列表范围,例如下面语句会返回所有名字为“Bill”的Student实例:

 Query query = session.createQuery("from Student as s where s.name='Bill' ");

where子句允许出现的表达式包括了SQL中可以使用的大多数情况: 数学操作:+,-,*,/ 真假比较操作:=,>=,<=,<>,!=,like 逻辑操作:and,or, not 字符串连接:|| SQL标量函数:例如upper()和lower()

如果子查询返回多条记录,可以用以下的关键字来量化:

all:表示所有的记录。 any:表示所有记录中的任意一条。 some:与any用法相同。 in:与any等价。 exists:表示子查询至少要返回一条记录。

例如,下面语句返回所有学生的年龄都大于22的班级对象:

from Group g where 22<all (select s.age from g.students s)

下述语句返回在所有学生中有一个学生的年龄等于22的班级:

from Group g where 22=any (select s.age from g.students s)

或者

from Group g where 22=some (select s.age from g.students s)

或者

from Group g where 22 in (select s.age from g.students s)

5.order by 子句

查询返回的列表可以按照任何返回的类或者组件的属性排序:

 from Student s order by s.name asc

asc和desc是可选的,分别代表升序或者降序。

6.连接查询

与SQL查询一样, HQL也支持连接查询,如内连接、外连接和交叉连接。

inner join: 内连接 left outer join:左外连接 right outer join:右外连接 full join: 全连接,但不常用

下面重点讲解内连接查询,左外连接和右外连接查询和内连接大同小异,而全连接几乎不怎么使用。

inner join可以简写为join,例如在查询得到Group对象时,内连接取得对应的Student对象,实现的程序如下。

……//打开Session,开启事务 

        Student  stu = null;  

//声明Student实例 

        Group  group = null; 

//声明Group实例 

        Query query = session.createQuery("from Group g join g.students"); 

        List list = query.list(); Object obj[] = null;  //声明对象数组

        for(int i=0;i<list.size();i++)  { 

        obj = (Object[])list.get(i); 

//取得集合中的第i个数组 

        group = (Group)obj[0];  

//group是数组中第一个对象 

        stu = (Student)obj[1];  

 //stu是数组中第二个对象

        System.out.println(stu.getName() + "属于:" +group.getName() ); } 

……//提交事务,关闭Session

Query By CriteriaQBC

当查询数据时,人们往往需要设置查询条件。在SQL或HQL语句中,查询条件常常放在where子句中。此外,Hibernate还支持Criteria查询(Criteria Query),这种查询方式把查询条件封装为一个Criteria对象。在实际应用中,使用Session的createCriteria()方法构建一个org.hibernate.Criteria实例,然后把具体的查询条件通过Criteria的add()方法加入到Criteria实例中。这样,程序员可以不使用SQL甚至HQL的情况下进行数据查询,如例程1-1所示。

例程1-1  Criteria应用实例

------------------------------------------------------------------------------------------ 

Criteria cr = session.createCriteria(Student.class); 

//生成一个Criteria对象

cr.add(Restrictions.eq("name", "Bill"));

//等价于where name=’Bill’ 

List list = cr.list(); 

Student stu = (Student)list.get(0); 

System.out.println(stu.getName());

1.常用的查询限制方法

在例程1-1中,Restrictions.eq()方法表示equal,即等于的情况。Restrictions类提供了查询限制机制。它提供了许多方法,以实现查询限制。这些方法及其他一些criteria常用查询限制方法列于表1-1中。

表1-1  Criteria Query常用的查询限制方法

方    法

说    明

Restrictions.eq()

equal,=

Restrictions.allEq()

参数为Map对象,使用key/value进行多个等于的对比,相当于多个Restrictions.eq()的效果

Restrictions.gt()

greater-than, >

Restrictions.lt()

less-than, <

Restrictions.le()

less-equal, <=

Restrictions.between()

对应SQL的between子句

Restrictions.like()

对应SQL的like子句

Restrictions.in()

对应SQL的in子句

Restrictions.and()

and关系

Restrictions.or()

or关系

Restrictions.isNull()

判断属性是否为空,为空返回true,否则返回false

Restrictions.isNotNull()

与Restrictions.isNull()相反

Order.asc()

根据传入的字段进行升序排序

Order.desc()

根据传入的字段进行降序排序

MatchMode.EXACT

字符串精确匹配,相当于“like 'value'”

MatchMode.ANYWHERE

字符串在中间位置,相当于“like '%value%'”

MatchMode.START

字符串在最前面的位置,相当于“like 'value%'”

MatchMode.END

字符串在最后面的位置,相当于“like '%value'”

例1:查询学生名字以t开头的所有Student对象。

 Criteria cr = session.createCriteria(Student.class);

 cr.add(Restrictions.like(“name”, “t%”)) ;

List list = cr.list(); 

Student stu = (Student)list.get(0);

或者使用另一种方式:

 Criteria cr = session.createCriteria(Student.class);

 cr.add(Restrictions.like(“name”, “t”, MatchMode.START)) ;

List list = cr.list(); 

Student stu = (Student)list.get(0);

例2:查询学生姓名在Bill, Jack和Tom之间的所有Student对象。

 String[] names = {“Bill”, “Jack”, “Tom”} ;

Criteria cr = session.createCriteria(Student.class); 

cr.add(Restrictions.in(“name”, names)) ;

List list = cr.list(); 

Student stu = (Student)list.get(0);

例3:查询学生的年龄age等于22或age为空(null)的所有Student对象。

Criteria cr = session.createCriteria(Student.class);

 cr.add(Restrictions.eq(“age”, new Integer(22)); 

cr.add(Restrictions.isNull(“age”));

 List list = cr.list(); 

Student stu = (Student)list.get(0);

例4:查询学生姓名以字母F开头的所有Student对象,并按姓名升序排序。

Criteria cr = session.createCriteria(Student.class);

 cr.add(Restrictions.like(“name”, “F%”); 

cr.addOrder(Order.asc(“name”)); 

List list = cr.list(); Student stu = (Student)list.get(0);

调用Order.asc的方法应是Criteria的addOrder()方法。

2.连接限制

在Criteria 查询中使用FetchMode来实现连接限制。在HQL语句中,可以通过fetch关键字来表示预先抓取(Eager fetching),如下所示:

 from Group g left join fetch g.students s where g.name like '%2005'

可以使用Criteria的API完成同样的功能,如下所示:

Criteria cr = session.createCriteria(Group.class); 

cr.setFetchMode(“students”, FetchMode.EAGER); 

cr.add(Restrictions.like(“name”, “2005”, MatchMode.END));

 List list = cr.list();

以上两种方式编写的代码,都使用相同的SQL语句完成它们的功能,如下所示:

select g.*, s.* from Group g left outer join Student s on g.id = s.group_id where g.name like '%2005'

Native SQL查询

本地SQL查询(Native SQL Query)指的是直接使用本地数据库(如Oracle)的SQL语言进行查询。它能够扫清你把原来直接使用SQL/JDBC 的程序迁移到基于 Hibernate应用的道路上的障碍。


这里有我的部分代码是关于qbc的部分方法测试:

package com.yibin.test;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import com.yibin.empty.User;
import com.yibin.session.HibernateSessionFactory;

/**
 * 测试类
 * @author 廖宜彬
 *时间:2018年6月20日08:59:32
 */
public class TestQBC {

	/**
	 * 在这里有一点需要注意,QBC只是查询语言不能进行增删改
	 */
	
	public void test() {
		Session session=HibernateSessionFactory.creSession();
		//完全面向对象查询
		//直接查询我们数据库的所有记录,使用QBC两句话就够了
		Criteria criteria=session.createCriteria(User.class);
		System.out.println(criteria.list());
	}
	
	
	public void likeqbc() {
		Session session=HibernateSessionFactory.creSession();
		Criteria criteria=session.createCriteria(User.class);
		//模糊查询
		criteria.add(Restrictions.like("uname", "%逗%"));
		//排序查询
		criteria.addOrder(Order.desc("uid"));
		System.out.println(criteria.list());
	}
	
	
	public void singercheck() {
		Session session=HibernateSessionFactory.creSession();
		Criteria criteria=session.createCriteria(User.class);
		//单个查询,可根据字段内容进行查询
		criteria.add(Restrictions.eq("uname", "小智"));
		System.out.println(criteria.list());
	}
	
	
	public void limitcheck() {
		Session session=HibernateSessionFactory.creSession();
		Criteria criteria=session.createCriteria(User.class);
		//分页查询
		criteria.setFirstResult(0);
		criteria.setMaxResults(2);
		System.out.println(criteria.list());
	}
	
	@Test
	public void scopecheck() {
		Session session=HibernateSessionFactory.creSession();
		Criteria criteria=session.createCriteria(User.class);
		//限定查询某个区间的内容
		criteria.add(Restrictions.between("uid", 3, 5));
		System.out.println(criteria.list());
	}
}


package com.yibin.test;

import org.hibernate.SQLQuery;
import org.hibernate.Session;

import com.yibin.empty.User;
import com.yibin.session.HibernateSessionFactory;

/**
 * native sql 测试
 * @author 廖宜彬
 *时间:2018-6-20 10:31:11
 */
public class Nativesql {

	public static void main(String[] args) {
		Session session=HibernateSessionFactory.creSession();
		//这里使用的是本地SQL查询,所以from后面跟的就是我们数据库的表名,即我们括号内是可以完整的写SQL语句
		SQLQuery createSQLQuery = session.createSQLQuery("select*from user");
		//如果直接将查询得到的结果转化为list所得的结果是个地址,
       //System.out.println(createSQLQuery.list());
     //因此我们需要将返回值封装到了一个数组
		createSQLQuery.addEntity(User.class);
		System.out.println(createSQLQuery.list()); 
	}

}

发布了15 篇原创文章 · 获赞 7 · 访问量 6917

猜你喜欢

转载自blog.csdn.net/qq_37165235/article/details/80741819