学步园

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