Hibernate的各种查询

独立与自由

浏览: 11833 次

最近访客更多访客>>

zhangly2011

owen_liu

zhang0404

joe987

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Hibernate

命名查询：

将hql语句放在映射文件的<hibernate-mapping.../>中，而不是代码中，就像这样：

<!--定义命名查询-->
<query name="myNamedQuery">
		from Person as p where p.age > ?
</query>

执行命名查询：

//执行命名查询
List pl = sess.getNamedQuery("myNamedQuery")
//根据HQL语句里参数索引为参数赋值
		.setInteger(0 , 20)
		.list();

条件查询：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
//使用createCriteria开始条件查询
List l = session.createCriteria(Student.class)
		//根据Student的属性进行过滤数据
		.add( Restrictions.gt("name" , "a"))
		.list();

根据关联实体的属性过滤数据：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
//使用createCriteria开始条件查询
List l = session.createCriteria(Student.class)
		//此处增加限制条件必须是Student已经存在的属性
		.add( Restrictions.gt("studentNumber" , 20050231L))
		//如果要增加对Student的关联类的属性的限制
		//则必须重新createCriteria()
		//如果此关联属性是集合，则只要集合里任意一个对象的属性满足下面条件即可
		.createCriteria("enrolments")
		.add( Restrictions.gt("semester" , 2))
                //该方法并不是创建一个新的Criteria实例，它只是该关联实体起一个别名
//		.createAlias("enrolments", "en")
//		.add( Restrictions.gt("en.semester" , 2))
		.list();

命名查询时同时改变延迟加载策略：

通常在映射文件中指定延迟加载，如果想在查询中改变延迟加载策略可以这样：

//使用createCriteria开始条件查询
List l = session.createCriteria(Student.class)
		//此处增加限制条件必须是Student已经存在的属性
		.add( Restrictions.gt("studentNumber" , 20050231L))
                //同时初始化Student关联的enrolments对象
		.setFetchMode("enrolments", FetchMode.JOIN)
		.list();

投影、聚合、分组：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
//使用createCriteria开始条件查询
List l = session.createCriteria(Enrolment.class)
			.createAlias("student", "s")
			.setProjection(Projections.projectionList()
				//统计记录条数
				.add(Projections.rowCount())
				//统计选择该课程里最大的学生姓名
				.add(Projections.max("s.name"))
				//按course进行分组
				.add(Projections.groupProperty("course"))
			).list();

//------指定别名-----
List l = session.createCriteria(Enrolment.class)
                .setProjection(Projections.projectionList()
		//按course进行分组
		.add(Projections.groupProperty("course"))
		//统计记录条数，并为统计结果指定别名c
		.add(Projections.alias(Projections.rowCount(), "c")))
		.addOrder(Order.asc("c"))
		.list();

List l = session.createCriteria(Enrolment.class)
			.setProjection(Projections.projectionList()
			//按course进行分组
			.add(Projections.groupProperty("course").as("c"))
			//统计记录条数，并为统计结果指定别名c
			.add(Projections.rowCount()))
			.addOrder(Order.asc("c"))
			.list();

//使用Property只选出指定列
List l = session.createCriteria(Student.class)
			.setProjection(Property.forName("name"))
			.list();

//------指定别名-----
List l = session.createCriteria(Enrolment.class)
			.setProjection(Projections.projectionList()
			//按course进行分组,指定别名为c
			.add(Projections.groupProperty("course") , "c")
			//统计每组记录的条数,指定别名为rc
			.add(Projections.rowCount(), "rc"))
			.addOrder(Order.asc("rc"))
			.list();

根据指定列过滤数据：

//使用Property选出指定列，并根据指定列过滤数据
List l = session.createCriteria(Enrolment.class)
		.createAlias("student", "s")
		.setProjection(Projections.projectionList()
		.add(Property.forName("course"))
		.add(Property.forName("s.name")))
		.add(Property.forName("s.name").eq("孙悟空"))
		.list();

离线查询和子查询：

//定义一个离线查询
DetachedCriteria query = DetachedCriteria
			.forClass(Student.class)
			.setProjection(Property.forName("name"));
//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
//执行离线查询
List l = query.getExecutableCriteria(session)
		.list();

子查询：

//定义一个离线查询
DetachedCriteria subQuery = DetachedCriteria
			.forClass(Student.class)
			.setProjection(Property.forName("name"));
//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
//执行子查询
List l = session.createCriteria(Student.class)
		.add( Property.forName("name").in(subQuery))
		.list();

SQL查询：

标量查询：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
String sqlString = "select stu.* from student_inf as stu";
List l = session.createSQLQuery(sqlString)
		//指定查询name和student_id两个数据列，指定返回值类型
		.addScalar("name" , StandardBasicTypes.STRING)
		.addScalar("student_id" , StandardBasicTypes.INTEGER)
		//返回标量值列表
		.list();

实体查询：

将查询结果转换为实体：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
String sqlString = "select * from enrolment_inf where year=:year";
List l = session.createSQLQuery(sqlString)
			//指定将查询的记录行转换成Enrolment实体
			.addEntity(Enrolment.class)
			//为SQL字符串的参数设置值
			.setInteger("year" , 2005)
			.list();

将查询结果转换为多个实体：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
String sqlString = "select s.*,e.*,c.* "
		+ "from student_inf s,enrolment_inf e,course_inf c "
		+ "where s.student_id = e.student_id "
		+ "and e.course_code = c.course_code";
List l = session.createSQLQuery(sqlString)
		//指定将查询的记录行转换成Student实体
		.addEntity("s", Student.class)
		.addEntity("e", Enrolment.class)
		.addEntity("c", Course.class)
		.list();

将结果转换为JavaBean：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
String sqlString = "select s.name stuName, c.name courseName "
		+ "from student_inf s,enrolment_inf e,course_inf c "
		+ "where s.student_id = e.student_id "
		+ "and e.course_code = c.course_code ";
List l = session.createSQLQuery(sqlString)
		//指定将查询的记录行转换成StudentCourse对象
		.setResultTransformer(Transformers
		.aliasToBean(StudentCourse.class))
		.list();

public class StudentCourse
{
	private String stuName;
	private String courseName;

	//stuName属性的setter和getter方法
	public void setStuName(String stuName)
	{
		this.stuName = stuName;
	}
	public String getStuName()
	{
		return this.stuName;
	}

	//courseName属性的setter和getter方法
	public void setCourseName(String courseName)
	{
		this.courseName = courseName;
	}
	public String getCourseName()
	{
		return this.courseName;
	}
}

关联查询：

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
String sqlString = "select s.* , e.* from student_inf s , "
		+ "enrolment_inf e where s.student_id=e.student_id";
List l = session.createSQLQuery(sqlString)
		.addEntity("s", Student.class)
                //将s.enrolments属性转换为别名为e的实体
		.addJoin("e" , "s.enrolments")
		.list();

SQL命名查询：

与上边命名查询相似（在映射文件的<hibernate-mapping../>中）：

<!-- 指定SQL查询的名称为queryTest -->
<sql-query name="queryTest">
	<!-- 将s别名转换成Student实体 -->
	<return alias="s" class="Student"/>
	<!-- 将e别名转换成Enrolment实体 -->
	<return alias="e" class="Enrolment"/>
	<!-- 预初始化e的course属性（关联实体） -->
	<return-join alias="c" property="e.course"/>
	<!-- 指定将student表的name列作为标量值返回 -->
	<return-scalar column="s.name" type="string"/>
		select s.*,e.*,c.* 
		from student_inf s,enrolment_inf e,course_inf c 
		where s.student_id = e.student_id 
		and e.course_code = c.course_code
		and e.year=:targetYear
</sql-query>

//打开Session和事务
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
//调用命名查询，直接返回结果
List l = session.getNamedQuery("queryTest")
		.setInteger("targetYear" , 2005)
		.list();

调用存储过程：

先在mysql创建一个存储过程：

create procedure select_all_student()
select *
from student_inf;

在映射文件<hibernate-mapping.../>：

<!-- 定义一个调用存储过程的命名SQL查询 -->
<sql-query name="callProcedure" callable="true">
	<!-- 将查询结果转换成Student实体 -->
	<return class="Student">
		<!-- 将查询的数据列转换成实体的属性 -->
		<return-property name="studentNumber"
			column="student_id"/>
		<return-property name="name" column="name"/>
	</return>
	{call select_all_student()}
</sql-query>

//调用存储过程
private void callProcedure()
{
	//打开Session和事务
	Session session = HibernateUtil.currentSession();
	Transaction tx = session.beginTransaction();
	//调用命名查询，直接返回结果
	List l = session.getNamedQuery("callProcedure")
		.list();
	tx.commit();
        ....
}

定制SQL：

默认通过一套固定的sql语句来完成一些功能

<loader query-ref="new_loader"/>
<sql-insert>insert into news_inf
	(title, content) values(upper(?), ?)</sql-insert>
<sql-update>update news_inf 
	set title=upper(?),content=? where id=?</sql-update>
<sql-delete>delete from news_table where id=?</sql-delete>

分享到：