14、Hibernate的HQL与QBC检索
Hibernate检索对象的方式
- HQL检索方式
- QBC检索方式
1、Hibernate提供的检索对象的方式
- 导航图对象检索方式
根据已经加载的对象，导航到其他对象。例如，对于已经加载的Customer对象，调用它的getOrders（）.iterator（）方法就可以导航到所有关联的Order对象，假如在关联级别使用了延迟家在检索策略，那么首次执行此方法时，hibernate会从数据库中加载关联的Order对象，否则就从缓存中取得Order对象。
- OID检索方式
按照对象的OID来检索对象。Session的get（）和load（）方法提供了这种功能。如果在应用程序中事先知道了OID，就可以使用这种检索对象的方式。
- HQL检索方式
HIbernate提供了Query接口，它是Hibernate提供的专门的HQL查询接口，能够执行各种复杂的HQL查询语句。
- QBC检索方式
使用QBC（Query By Criteria）API来检索对象。这种API封装了基于字符串形式的查询语句，提供了更加面向对象的接口。
2、HQL检索方式
HQL（Hibernate Query Language）是面向对象的查询语言，他和SQL查询语言有些相似。在Hibernate提供的各种检索方式中，HQL是使用最广的一种检索方式。它具有以下功能：
- 在查询语句中设定各种查询条件
- 支持投影查询，即仅检索出对象的部分属性
- 支持分页查询
- 支持连接查询
- 支持分组查询，允许使用having和group by关键字
- 提供内置聚集函数，如sum()、min()、和max()
- 支持子查询，即嵌入式查询
- 支持动态绑定参数
HQL检索步骤：
//创建一个Query
Query query = session.createQuery("from Customer as c where " + "c.name =: customerName" + "and c.age =: customerAge");
//这里c.name =: customerName，c.name是指出Customer的属性name，=：是一个动态赋值的符号，后面的customerName是任意起名的，是我们要动态付值得一个临时变量。c.age =: customerAge同理
//动态绑定参数
query.setString("customerName","tom");
query.setInteger("customerAge",20);
//执行查询语句，返回查询结果
List result = query.list();
Query提供了大量的setXXX方法，来为其提供设定参数。
（1）通过Session的createQuery（）方法创建一个Query对象，它包含一个HQL查询语句。HQL查询语句可以包含命名参数，如”customerName“和”customerAge“都是命名参数。
（2）动态绑定参数。Query接口提供了各种类型的命名参数赋值的方法，例如setString（）方法用于为字符串类型的customerName命名参数赋值。
（3）调用Query的list（）方法执行查询语句。该方法返回List类型的查询结果，在List集合中存放了符合查询条件的持久化对象。
对于Query支持方法链编程风格
List result = session.greateQuery("...").setString("customerName","Tom").setInteger("customerAge",21).list();
方法链编程风格能使程序代码更加简洁
3、QBC检索方式
采用HQL检索方式时，在应用程序中需要定义基于字符串形式的HQL查询语句。
QBC API提供了检索对象的另一种方式，它主要由Criteria接口、Criterion接口和Expression类组成，它支持在运行时动态生成查询语句。
Criteria是由Session创建的，Session的createCriteria（）创建一个Criteria对象。Criterion是增加约束条件的，具体实现类Restrictions
//创建一个Criteria对象
Criteria criteria = session.createCriteria（Customer.clss）；
//设定查询条件，然后把查询条件加入到Criteria中
Criterion criterion1 = Expression.like(”name“，”T%“)； //相当于where name like ‘T%’
Criterion criterion2 = Expression.eq("age",new Integer(21));
criteria = criteria.add(criterion1);
criteria = criteria.add(criterion2);
//执行查询语句，返回查询结果
List result = criteria.list();
使用QBC检索的步骤
-（1）调用Session的createCriteria（）方法创建一个Criteria对象。
-（2）设定查询条件。Expression类提供了一系列用于设定查询条件的静态方法，这些静态方法都返回Criterion实例，每个Criterion实例代表一个查询条件。Criteria的add（）方法用于加入查询条件。
-（3）调用Criteria的list（）方法执行查询语句。该方法返回List类型的查询结果，在List集合中存放了符合查询条件的持久化对象。对于以上程序代码，当运行Criteria的list（）方法时，Hibernate执行的SQL查询语句为：
select * from customers where name like 'T%' and age = 21;
方法链编程风格
List result = session.createCriteria（Customer.class）.add(Expression.like("name","T%")).add(Expression.eq("age",new Integer(21))).list();
4、分页查询
Query和Criteria接口都提供了用于分页显示查询结果的方法：
- setFirstResult（int firstResult）：设定从哪一个对象开始检索，参数firstResult表示这个对象在查询结果中的索引位置，索引位置的起始值为0.默认情况下，Query和Criteria接口从查询结果中的第一个对象，也就是索引位置为0的对象开始检索。
- seMaxResult(int maxResults)：设定一次最多检索出的对象数目。默认情况下，Query和Criteria接口检索出查询结果中所有的对象。
分页查询：
| //采用HQL检索方式 Query query = session.createQuery("from Customer c order by c.name asc"); query.setFirstResults(0); query.setMaxResults(10); List result = query.list(); |
//采用QBC检索方式 Criteria criteria=session.createCritia(Customer.class); criteria.addOrder(Order.asc("name")); criteria.setFirstResults(0); criteria.setMaxResults(10); List result = criteria.list(); |
5、查询检索方式举例：
使用Team、Student和Course三个类：
import java.util.HashSet;
import java.util.Set;
public class Team
{
private String id;
private String teamName;
private Set students = new HashSet();
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getTeamName()
{
return teamName;
}
public void setTeamName(String teamName)
{
this.teamName = teamName;
}
public Set getStudents()
{
return students;
}
public void setStudents(Set students)
{
this.students = students;
}
}
import java.util.Set;
public class Student
{
private String id;
private String cardId;
private String name;
private int age;
public String getCardId()
{
return cardId;
}
public void setCardId(String cardId)
{
this.cardId = cardId;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
private Set<Course> courses;
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Set<Course> getCourses()
{
return courses;
}
public void setCourses(Set<Course> courses)
{
this.courses = courses;
}
}
import java.util.Set;
public class Course
{
private String id;
private String name;
private Set<Student> students;
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Set<Student> getStudents()
{
return students;
}
public void setStudents(Set<Student> students)
{
this.students = students;
}
}
对应的映射文件：
<?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> <class name="com.cdtax.hibernate.Team" table="team"> <id name="id" column="id" type="string"> <generator class="uuid"> </generator> </id> <property name="teamName" column="teamname" type="string"></property> <set name="students" lazy="false" cascade="all" inverse="true" fetch="select"> <key column="team_id"></key> <one-to-many class="com.cdtax.hibernate.Student"/> </set> </class> </hibernate-mapping>
<?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> <class name="com.cdtax.hibernate.Student" table="student"> <id name="id" column="id" type="string"> <generator class="uuid"></generator> </id> <property name="name" column="name" type="string"></property> <property name="cardId" column="cardid" type="string"></property> <property name="age" column="age" type="int"></property> <set name="courses" table="student_course" cascade="save-update"> <!-- cascade不能使用all --> <key column="student_id"></key> <many-to-many class="com.cdtax.hibernate.Course" column="course_id"></many-to-many> </set> </class> </hibernate-mapping>
<?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> <class name="com.cdtax.hibernate.Course" table="course"> <id name="id" column="id" type="string"> <generator class="uuid"></generator> </id> <property name="name" column="name" type="string"></property> <set name="students" table="student_course" cascade="save-update" inverse="true"> <!-- cascade不能使用all --> <key column="course_id"></key> <many-to-many class="com.cdtax.hibernate.Student" column="student_id"></many-to-many> </set> </class> </hibernate-mapping>
产生数据库表：
create table course (id varchar(255) not null, name varchar(255), primary key (id))
create table student (id varchar(255) not null, name varchar(255), cardid varchar(255), age integer, team_id varchar(255), primary key (id))
create table student_course (student_id varchar(255) not null, course_id varchar(255) not null, primary key (student_id, course_id))
create table team (id varchar(255) not null, teamname varchar(255), primary key (id))
alter table student add index FK8FFE823BB04F9E7 (team_id), add constraint FK8FFE823BB04F9E7 foreign key (team_id) references team (id)
alter table student_course add index FKB0A3729F45A3E36D (student_id), add constraint FKB0A3729F45A3E36D foreign key (student_id) references student (id)
alter table student_course add index FKB0A3729FA31F19E7 (course_id), add constraint FKB0A3729FA31F19E7 foreign key (course_id) references course (id)
插入一些测试数据：
USE hibernate;
insert into `course`(`id`,`name`) values ('402881c04223208801422320897a0031','yy');
insert into `course`(`id`,`name`) values ('402881c04223208801422320897a0032','sx');
insert into `course`(`id`,`name`) values ('402881c04223208801422320897a0033','yw');
insert into `student`(`id`,`name`,`cardid`,`age`,`team_id`) values ('402881c04223208801422320897a0011','zhangsan','402881c04223208801422320897a0021',20,'402881c04223208801422320897a0001');
insert into `student`(`id`,`name`,`cardid`,`age`,`team_id`) values ('402881c04223208801422320897a0012','lisi','402881c04223208801422320897a0022',7,'402881c04223208801422320897a0001');
insert into `student`(`id`,`name`,`cardid`,`age`,`team_id`) values ('402881c04223208801422320897a0013','wangwu','402881c04223208801422320897a0023',45,'402881c04223208801422320897a0002');
insert into `student`(`id`,`name`,`cardid`,`age`,`team_id`) values ('402881c04223208801422320897a0014','zhaoliu','402881c04223208801422320897a0024',34,'402881c04223208801422320897a0002');
insert into `student`(`id`,`name`,`cardid`,`age`,`team_id`) values ('402881c04223208801422320897a0015','kklk','402881c04223208801422320897a0025',23,'402881c04223208801422320897a0003');
insert into `team`(`id`,`teamname`) values ('402881c04223208801422320897a0001','team1');
insert into `team`(`id`,`teamname`) values ('402881c04223208801422320897a0002','team2');
insert into `team`(`id`,`teamname`) values ('402881c04223208801422320897a0003','team3');
insert into `student_course`(`student_id`,`course_id`) values ('402881c04223208801422320897a0011','402881c04223208801422320897a0031');
insert into `student_course`(`student_id`,`course_id`) values ('402881c04223208801422320897a0011','402881c04223208801422320897a0032');
insert into `student_course`(`student_id`,`course_id`) values ('402881c04223208801422320897a0012','402881c04223208801422320897a0033');
insert into `student_course`(`student_id`,`course_id`) values ('402881c04223208801422320897a0013','402881c04223208801422320897a0032');
使用HQL查询学生的信息，如果是查询学生的所有信息，就用from Student这种写法，但是这里我们只是查询学生的name和age，写法要注意如下：
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateTest
{
private static SessionFactory sessionFactory;
static
{
try
{
sessionFactory = new Configuration().configure().buildSessionFactory();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
public static void main(String[] args)
{
Session session = sessionFactory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
Query query = session.createQuery("select s.name,s.age from Student s");
//对于以前查询学生的所有信息，就用from Student这种写法，现在是查询学生的name和age，写法就如上
//对于查询出来的结果，如果是from Student，那么查询出来的就是Student对象，现在只是name和age，是游离的，跟Student看不出有任何关系
List list = query.list();
//对于list中的元素，如果是from Student方式，那么就是Student实例
//但是现在就不是了，查看Query的list（）方法说明：Return the query results as a List.If the query contains multiple results pre row
//the results are returned in an instance of Object[].如果query每一行包含多个结果，那么结果就作为一个Objec[]数组返回。
//对于我们这个程序list中的元素就是一个Object[]数组，其中Object[0]就是name，Object[1]就是age
//所以我们要进行类型转换
for(int i = 0; i < list.size(); i++)
{
Object[] obj = (Object[])list.get(i);
System.out.println(obj[0] + ", " + obj[1]);
}
tx.commit();
}
catch(Exception ex)
{
if(null != tx)
{
tx.rollback();
}
ex.printStackTrace();
}
finally
{
session.close();
}
}
}看下面的对应关系图：
执行的结果：
Hibernate: select student0_.name as col_0_0_, student0_.age as col_1_0_ from student student0_
zhangsan, 20
lisi, 7
wangwu, 45
zhaoliu, 34
kklk, 23
Hibernate也提供了直接查询部分属性，而且返回也是相应类的查询方式，如下：
try
{
tx = session.beginTransaction();
Query query = session.createQuery("select new Student(s.name,s.age) from Studnet s");
List list = query.list();
for(int i = 0; i < list.size(); i++)
{
Student student = (Student)list.get(i);
System.out.println(student.getName() + ", " + student.getAge());
}
tx.commit();
}这时list（）返回的List元素就是Student。执行：结果出现异常了：
org.hibernate.hql.ast.QuerySyntaxException: Unable to locate appropriate constructor on class [com.cdtax.hibernate.Student] [select new Student(s.name,s.age) from com.cdtax.hibernate.Student s]
at org.hibernate.hql.ast.QuerySyntaxException.convert(QuerySyntaxException.java:54)
at org.hibernate.hql.ast.QuerySyntaxException.convert(QuerySyntaxException.java:47)
at org.hibernate.hql.ast.ErrorCounter.throwQueryException(ErrorCounter.java:82)
at org.hibernate.hql.ast.QueryTranslatorImpl.analyze(QueryTranslatorImpl.java:261)
at org.hibernate.hql.ast.QueryTranslatorImpl.doCompile(QueryTranslatorImpl.java:185)
at org.hibernate.hql.ast.QueryTranslatorImpl.compile(QueryTranslatorImpl.java:136)
at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:101)
at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:80)
at org.hibernate.engine.query.QueryPlanCache.getHQLQueryPlan(QueryPlanCache.java:94)
at org.hibernate.impl.AbstractSessionImpl.getHQLQueryPlan(AbstractSessionImpl.java:156)
at org.hibernate.impl.AbstractSessionImpl.createQuery(AbstractSessionImpl.java:135)
at org.hibernate.impl.SessionImpl.createQuery(SessionImpl.java:1651)
at com.cdtax.hibernate.HibernateTest.main(HibernateTest.java:54)
什么原因呢？？？？原来Hibernate使用构造函数来生成list的元素，就是Student，而Student没有具有两个参数（String name，int age）的构造函数，所以修改一下Student类，增加相应的构造函数，一定要注意参数的顺序。
import java.util.Set;
public class Student
{
private String id;
private String cardId;
private String name;
private int age;
public Student()
{
}
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
public String getCardId()
{
return cardId;
}
public void setCardId(String cardId)
{
this.cardId = cardId;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
private Set<Course> courses;
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Set<Course> getCourses()
{
return courses;
}
public void setCourses(Set<Course> courses)
{
this.courses = courses;
}
}
在执行结果正确显示：
Hibernate: select student0_.name as col_0_0_, student0_.age as col_1_0_ from student student0_
zhangsan, 20
lisi, 7
wangwu, 45
zhaoliu, 34
kklk, 23
我们在打印的时候增加一行：System.out.println(student.getCardId());结果：
Hibernate: select student0_.name as col_0_0_, student0_.age as col_1_0_ from student student0_
zhangsan, 20
null
lisi, 7
null
wangwu, 45
null
zhaoliu, 34
null
kklk, 23
null
cardid为null，因为我们没有查此字段。
6、连接操作
如下的查询：
Query query = session.createQuery("from Team t join t.students");
List list = query.list();产生的sql语句如下：
Hibernate:
select
team0_.id as id3_0_,
students1_.id as id0_1_,
team0_.teamname as teamname3_0_,
students1_.name as name0_1_,
students1_.cardid as cardid0_1_,
students1_.age as age0_1_
from
team team0_
inner join
student students1_
on team0_.id=students1_.team_id
Hibernate:
select
students0_.team_id as team5_1_,
students0_.id as id1_,
students0_.id as id0_0_,
students0_.name as name0_0_,
students0_.cardid as cardid0_0_,
students0_.age as age0_0_
from
student students0_
where
students0_.team_id=?
Hibernate:
select
students0_.team_id as team5_1_,
students0_.id as id1_,
students0_.id as id0_0_,
students0_.name as name0_0_,
students0_.cardid as cardid0_0_,
students0_.age as age0_0_
from
student students0_
where
students0_.team_id=?
Hibernate:
select
students0_.team_id as team5_1_,
students0_.id as id1_,
students0_.id as id0_0_,
students0_.name as name0_0_,
students0_.cardid as cardid0_0_,
students0_.age as age0_0_
from
student students0_
where
students0_.team_id=?
简单地写join就是内连接：inner join
inner join student students1_ on team0_.id=students1_.team_id
等价于：select * from team team0_ ,student students1_ where team0_.id=students1_.team_id
左外连接，以连接左面的表为准（为参照表），查询结果一定包含左边表的全部和右边表匹配的记录。left outer join
同理，右外连接以右面的表为参照。
对于上面的查询，查询的是team和student中的所有字段，所以list结果是其元素是一个Object的数组，数组中是Team和Student对象。
Query query = session.createQuery("from Team t join t.students");
List list = query.list();
for(int i = 0; i < list.size(); i++)
{
Object[] obj = (Object[])list.get(i);
Team team = (Team)obj[0];
Student student = (Student)obj[1];
System.out.println(team.getTeamName());
System.out.println(student.getName() + ", " + student.getAge());
System.out.println("====================");
}执行结果：
team1
zhangsan, 20
====================
team1
lisi, 7
====================
team2
wangwu, 45
====================
team2
zhaoliu, 34
====================
team3
kklk, 23
====================
7、将Team.hbm.xml中的set设为延迟加载，即lazy=”true“
修改测试程序：
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateTest
{
private static SessionFactory sessionFactory;
static
{
try
{
sessionFactory = new Configuration().configure().buildSessionFactory();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
public static void main(String[] args)
{
Session session = sessionFactory.openSession();
Transaction tx = null;
Query query = null;
List list = null;
try
{
tx = session.beginTransaction();
query = session.createQuery("from Team t join t.students");
list = query.list();
tx.commit();
}
catch(Exception ex)
{
if(null != tx)
{
tx.rollback();
}
ex.printStackTrace();
}
finally
{
session.close();
}
for(int i = 0; i < list.size(); i++)
{
Object[] obj = (Object[])list.get(i);
Team team = (Team)obj[0];
Student student = (Student)obj[1];
System.out.println(team.getTeamName());
System.out.println(student.getName() + ", " + student.getAge());
System.out.println("====================");
}
}
}
使用了join后，连同Student的信息就一并查询出来了，lazy延时加载就被覆盖了，变成了立即加载，所以在session关闭后，打印student也能出来结果，如果只查询team，而且又使用了延迟加载，那么在关系session后在打印student是打印不出来的。
8、使用实体命名参数查询
修改Student，增加一个Team成员变量：
import java.util.Set;
public class Student
{
private String id;
private String cardId;
private String name;
private int age;
private Team team;
public Team getTeam()
{
return team;
}
public void setTeam(Team team)
{
this.team = team;
}
public Student()
{
}
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
public String getCardId()
{
return cardId;
}
public void setCardId(String cardId)
{
this.cardId = cardId;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
private Set<Course> courses;
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Set<Course> getCourses()
{
return courses;
}
public void setCourses(Set<Course> courses)
{
this.courses = courses;
}
}
修改HBM文件：
<?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>
<class name="com.cdtax.hibernate.Student" table="student">
<id name="id" column="id" type="string">
<generator class="uuid"></generator>
</id>
<property name="name" column="name" type="string"></property>
<property name="cardId" column="cardid" type="string"></property>
<property name="age" column="age" type="int"></property>
<set name="courses" table="student_course" cascade="save-update">
<!-- cascade不能使用all -->
<key column="student_id"></key>
<many-to-many class="com.cdtax.hibernate.Course" column="course_id"></many-to-many>
</set>
<many-to-one name="team" class="com.cdtax.hibernate.Team" fetch="select" column="team_id"></many-to-one>
</class>
</hibernate-mapping>增加了many-to-one
查询测试：
try
{
tx = session.beginTransaction();
Team team = (Team)session.get(Team.class, "402881c04223208801422320897a0002");
Query query = session.createQuery("from Student s where s.team = :team and s.age > 20");
query.setParameter("team", team,Hibernate.entity(Team.class));
List<Student> list = query.list();
System.out.println(list.size());
tx.commit();
}
这里要注意，使用命名参数=：与命名参数之间不能有空格=和：之间可以有空格，query的setParameter方法，第一个参数是命名参数，第二个是参数的值，第三个是type，是Hibernate要求的type值，这个值的获取是使用org.hibrenate.Hibernate类提供的静态方法entity()来获得的。
第二种设定实体查询的命名参数的方法
try
{
tx = session.beginTransaction();
Team team = (Team)session.get(Team.class, "402881c04223208801422320897a0002");
Query query = session.createQuery("from Student s where s.team = :team and s.age > 20");
// query.setParameter("team", team,Hibernate.entity(Team.class));
query.setEntity("team", team);
List<Student> list = query.list();
System.out.println(list.size());
tx.commit();
}query的setEntity（）方法更简单。
session提供的过滤功能，createFilter（Object collection，String queryString）
try
{
tx = session.beginTransaction();
Team team = (Team)session.get(Team.class, "402881c04223208801422320897a0002");
// Query query = session.createQuery("from Student s where s.team = :team and s.age > 20");
// query.setParameter("team", team,Hibernate.entity(Team.class));
// query.setEntity("team", team);
Query query = session.createFilter(team.getStudents(), "where age > 20");
List<Student> list = query.list();
System.out.println(list.size());
tx.commit();
}
9、QBC查询
between：
try
{
tx = session.beginTransaction();
Criteria criteria = session.createCriteria(Student.class)
.add(Restrictions.between("age", new Integer(10), new Integer(30)));
List<Student> list = criteria.list();
for(Student student : list)
{
System.out.println(student.getName());
}
tx.commit();
}
like：
try
{
tx = session.beginTransaction();
// Criteria criteria = session.createCriteria(Student.class)
// .add(Restrictions.between("age", new Integer(10), new Integer(30)));
Criteria criteria = session.createCriteria(Student.class)
.add(Restrictions.like("name", "k%"));
List<Student> list = criteria.list();
for(Student student : list)
{
System.out.println(student.getName());
}
tx.commit();
}in：
try
{
tx = session.beginTransaction();
// Criteria criteria = session.createCriteria(Student.class)
// .add(Restrictions.between("age", new Integer(10), new Integer(30)));
// Criteria criteria = session.createCriteria(Student.class)
// .add(Restrictions.like("name", "k%"));
String[] names = {"zhangsan","lisi","wangwu"};
Criteria criteria = session.createCriteria(Student.class)
.add(Restrictions.in("name",names));
List<Student> list = criteria.list();
for(Student student : list)
{
System.out.println(student.getName());
}
tx.commit();
}
排序：addOrder
try
{
tx = session.beginTransaction();
// Criteria criteria = session.createCriteria(Student.class)
// .add(Restrictions.between("age", new Integer(10), new Integer(30)));
// Criteria criteria = session.createCriteria(Student.class)
// .add(Restrictions.like("name", "k%"));
// String[] names = {"zhangsan","lisi","wangwu"};
//
// Criteria criteria = session.createCriteria(Student.class)
// .add(Restrictions.in("name",names));
Criteria criteria = session.createCriteria(Student.class)
.addOrder(Order.asc("age")).addOrder(Order.desc("cardId"));
List<Student> list = criteria.list();
for(Student student : list)
{
System.out.println(student.getName()+","+ student.getAge() + ","+ student.getCardId());
System.out.println("-----------------");
}
tx.commit();
}
执行结果：
Hibernate:
select
this_.id as id0_0_,
this_.name as name0_0_,
this_.cardid as cardid0_0_,
this_.age as age0_0_,
this_.team_id as team5_0_0_
from
student this_
order by
this_.age asc,
this_.cardid desc
lisi,7,402881c04223208801422320897a0022
-----------------
zhangsan,20,402881c04223208801422320897a0021
-----------------
kklk,23,402881c04223208801422320897a0025
-----------------
zhaoliu,34,402881c04223208801422320897a0024
-----------------
wangwu,45,402881c04223208801422320897a0023
-----------------
推荐使用HQL