hibernate createSQLQuery查询 hibernate hql连接查询

一 hql连接查询

和SQL查询一样，HQL也支持各种各样的连接查询，如内连接、外连接。我们知道在SQL中可通过join子句实现多表之间的连接查询。HQL同样提供了连接查询机制，还允许显式指定迫切内连接和迫切左外连接。HQL提供的连接方式如表1所示。

连接类型	HQL语法	适用范围
内连接	inner join或 join	适用于有关联关系
迫切内连接	inner join fetch或 join fetch	的持久化类，并且在
左外连接	left outer join或 left join	映射文件中对这种关
迫切左外连接	left outer join fetch或 left join fetch	联关系做了映射
右外连接	right outer join或 right join

迫切连接是指在指定连接方式时不仅指定了连接查询方式，而且显式地指定了关联级别的查询策略。Hibernate使用fetch关键字实现，fetch关键字表明“左边”对象用于与“右边”对象关联的属性会立即被初始化。

案例一，多对一关联，无迫切连接

package com.obtk.test2;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;

import com.obtk.entitys.DeptEntity;
import com.obtk.entitys.EmployeeEntity;
import com.obtk.utils.HibernateUtil;

public class TestJoin01 {
	public static void main(String[] args) {
		Session session=null;
		String hql="from EmployeeEntity e inner join e.dept d " +
				" where e.gender=? and d.deptName=? ";
		try {
			session=HibernateUtil.getSession();
			Query qy=session.createQuery(hql);
			qy.setParameter(0, "男");
			qy.setParameter(1, "人事部");
			List<Object[]> objList=qy.list();
			EmployeeEntity theEmp=null;
			DeptEntity dept=null;
			for(Object[] theArr :objList){
				theEmp=(EmployeeEntity)theArr[0];
				dept=(DeptEntity)theArr[1];
				System.out.println(theEmp.getEmpName()+","+theEmp.getGender()
						+","+dept.getDeptName());
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}

案例二   多对一关联，有迫切连接(注意fetch关键字)

package com.obtk.test2;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;

import com.obtk.entitys.DeptEntity;
import com.obtk.entitys.EmployeeEntity;
import com.obtk.utils.HibernateUtil;

public class TestFetchJoin01 {
	public static void main(String[] args) {
		Session session=null;
		String hql="from EmployeeEntity e inner join fetch e.dept d " +
				" where e.gender=? and d.deptName=? ";
		try {
			session=HibernateUtil.getSession();
			Query qy=session.createQuery(hql);
			qy.setParameter(0, "男");
			qy.setParameter(1, "人事部");
			List<EmployeeEntity> empList=qy.list();
			for(EmployeeEntity theEmp:empList){
				System.out.println(theEmp.getEmpName()+","+theEmp.getGender()
						+","+theEmp.getDept().getDeptName());
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}

案例三  一对多关联，有迫切连接

package com.obtk.test2;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;

import com.obtk.entitys.DeptEntity;
import com.obtk.entitys.EmployeeEntity;
import com.obtk.utils.HibernateUtil;

public class TestFetchJoin02 {
	public static void main(String[] args) {
		Session session=null;
		String hql="select distinct d from DeptEntity d inner join fetch d.empList e  " +
				" where e.gender=? ";
		try {
			session=HibernateUtil.getSession();
			Query qy=session.createQuery(hql);
			qy.setParameter(0, "男");
			List<DeptEntity> deptList=qy.list();
			List<EmployeeEntity> empList=null;
			for(DeptEntity theDept:deptList){
				empList=theDept.getEmpList();
				for(EmployeeEntity theEmp: empList){
					System.out.println(theEmp.getEmpName()+","+theEmp.getGender()
							+","+theDept.getDeptName());
				}
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}

建议用多对一，也就是从外键表发出关联，这样性能会好些，输出的sql会少些。

案例四  隐式内连接

package com.obtk.test2;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;

import com.obtk.entitys.EmployeeEntity;
import com.obtk.utils.HibernateUtil;

public class TestYinJoin {
	public static void main(String[] args) {
		Session session=null;
		//隐式内连接
		String hql="from EmployeeEntity e where e.gender=? and e.dept.deptName=?";
		try {
			session=HibernateUtil.getSession();
			Query qy=session.createQuery(hql);
			qy.setParameter(0, "男");
			qy.setParameter(1, "人事部");
			List<EmployeeEntity> empList=qy.list();
			for(EmployeeEntity theEmp:empList){
				System.out.println(theEmp.getEmpName()+","+theEmp.getGender()
						+","+theEmp.getDept().getDeptName());
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}

案例五，迫切左外连接

package com.obtk.test2;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;

import com.obtk.entitys.DeptEntity;
import com.obtk.entitys.EmployeeEntity;
import com.obtk.utils.HibernateUtil;

public class TestLeftJoin01 {
	public static void main(String[] args) {
		Session session=null;
		String hql="from EmployeeEntity e left join fetch e.dept d ";
		try {
			session=HibernateUtil.getSession();
			Query qy=session.createQuery(hql);
			List<EmployeeEntity> empList=qy.list();
			for(EmployeeEntity theEmp:empList){
				if(theEmp.getDept()!=null){
					System.out.println(theEmp.getEmpName()+","+theEmp.getGender()
							+","+theEmp.getDept().getDeptName());
				}else{
					System.out.println(theEmp.getEmpName()+","+theEmp.getGender()
							+",null");
				}
				
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}

fetch关键字只对inner join和left join有效。对于right join而言，由于作为关联对象容器的“左边”对象可能为null，所以也就无法通过fetch关键字强制Hibernate进行集合填充操作。

二  查询性能优化

 1．Hibernate主要从以下几方面来优化查询性能

    (1)使用迫切左外连接或迫切内连接查询策略、查询缓存等方式，减少select语句的数目，降低访问数据库的频率。

    (2)使用延迟查询策略等方式避免加载多余的不需要访问的数据。

    (3)使用Query接口的iterate()方法减少select语句中的字段，从而降低访问数据库的数据量。

    Query接口的iterate()方法和list()方法都用来执行SQL查询语句。在某些情况下，iterate()方法能提高查询性能。如示例1和示例2所示，先查询所有学生信息，再查询符合条件的学生信息，这种情况下，对比list()方法和iterate()方法的查询性能。

示例l

   List<StudentEntity>stuList=session.createQuery("from StudentEntity").list();

   for(StudentEntity student: stuList){

        System.out.println(student.getStuName());

   }

   stuList=session.createQuery("fromStudentEntity where stuId<2020").list();

   for(StudentEntity student: stuList){

       System.out.println(student.getStuName());

   }

运行示例l，Hibernate执行的select语句：

   select * from StudentEntity

   select * from StudentEntity wherestuId<2020

 

    第一次使用list()方法查询时，Hibernate从数据库中查询StudentEntity对象，把所有的StudentEntity对象放入Session缓存中；第二次使用list()查询时，Hibernate仍然从数据库中查询StudentEntity对象，而不是从Session缓存中获取StudentEntity对象。使用iterate()方法，能提高查询性能，如示例2所示。

示例2

List<StudentEntity>stuList=session.createQuery("from StudentEntity").list();

for(StudentEntitystudent: stuList){

       System.out.println(student.getStuName());

}

Iterator<StudentEntity>studentIt= session.createQuery("from StudentEntity wherestuId<2020").iterate();

StudentEntitystudent=null;

while(studentIt.hasNext()){

   student= studentIt.next();

   System.out.println(student.getStuName());

}

 

运行示例2，Hibernate执行的select语句：

   select * from StudentEntity

   select * from StudentEntity wherestuId<2020

 

    第一次使用list()方法查询时，Hibernate从数据库中查询StudentEntity对象，把所有的StudentEntity对象放入Session缓存中；第二次使用iterate()方法查询时，首先查询ID字段，然后根据ID字段到Hibernate的Session缓存中查找匹配的StudentEntity对象。如果存在，就直接把它加入到查询结果集中，否则就执行额外的select语句，根据ID字段到数据库中查询对象。

    iterate()方法适用于查询对象开启二级缓存的情况。

 2．HQL优化

    HQL优化是Hibernate程序性能优化的一个方面，HQL的语法与SQL非常类似。HQL是基于SQL的，只是增加了面向对象的封装。如果抛开HOL同Hibernate本身一些缓存机制的关联，HQL的优化技巧同SQL的优化技巧一样。在编写HQL时，需注意以下几个原则。

    (1)避免or操作的使用不当。如果where子句中有多个条件，并且其中某个条件没有索引，使用or，将导致全表扫描。假定在HOUSE表中TITLE有索引，PRICE没有索引，执行以下HQL语句：

    from House   where title= ‘出租-居室’  or price<1500

    当PRICE比较时，会引起全表扫描。

    (2)避免使用not。如果where子句的条件包含not关键字，那么执行时该字段的索引失效。这些语句需要分成不同情况区别对待，如查询租金不多于1800元的店铺出租转让信息的HQL语句：

    from House as h where not (h.price>1800)

    对于这种不大于（不多于）、不小于（不少于）的条件，建议使用比较运算符来替代not，如不大于就是小于等于。例如：

    from House as h where h.price<=1800

    如果知道某一字段所允许的设置值，那么就有其他的解决方法。例如，在用户表中增加性别字段，规定性别字段仅能包含M和F，当要查询非男用户时，为避免使用not关键字，将条件设定为查询女用户即可。

    (3)避免like的特殊形式。某些情况下，会在where子句条件中使用like。如果like以一个“%” 或“_”开始即前模糊，则该字段的索引不起作用。但是非常遗憾的是，对于这种问题并没有额外的解决方法，只能通过改变索引字段的形式变相地解决。

    (4)避免having予句。在分组的查询语句中，可在两个位置指定条件，一是where子旬中，二是在having子句中。尽可能地在where子句而不是having子句中指定条件。Having是在检索出所有记录后才对结果集进行过滤，这个处理需要一定的开销，而where子句限制记录数目，能减少这方面的开销。

    (5)避免使用distinct。指定distinct会导致在结果中删除重复的行。这会对处理时间造成一定的影响，因此在不要求或允许冗余时，应避免使用distinct。

    (6)索引在以下情况下失效，应注意使用。

Ø 只要对字段使用函数，该字段的索引将不起作用，如substring(aa，1，2)='xx'。

Ø 只要对字段进行计算，该字段的索引将不起作用，如price+10。

三  hql批量增删改

批量处理数据是指在一个事务场景中处理大量数据。

HQL可以查询数据，也可以批量插入、更新和删除数据。HQL批量操作实际上直接在数据库中完成，处理的数据不需要加载至Session缓存中。使用Query接口的executeUpdate()方法执行用于插入、更新和删除的HQL语句。

案例一  批量添加

package com.obtk.test03;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.obtk.utils.HibernateUtil;

public class TestAdd {
	public static void main(String[] args) {
		Session session=null;
		Transaction tx=null;
		String hql="insert into UserEntity(userName,passWord,email) " +
				" select userName,passWord,email from UserEntity";
		try {
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			Query qy=session.createQuery(hql);
			int result=qy.executeUpdate();
			System.out.println("fdsa:"+result);
			tx.commit();
		} catch (HibernateException e) {
			tx.rollback();
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}

案例二   批量删除

package com.obtk.test03;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.obtk.utils.HibernateUtil;

public class TestDelete {
	public static void main(String[] args) {
		Session session=null;
		Transaction tx=null;
		String hql="delete from UserEntity where userId>?";
		try {
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			Query qy=session.createQuery(hql);
			qy.setParameter(0, 7);
			int result=qy.executeUpdate();
			System.out.println("fdsa:"+result);
			tx.commit();
		} catch (HibernateException e) {
			tx.rollback();
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}

案例三  批量修改

package com.obtk.test03;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.obtk.utils.HibernateUtil;

public class TestUpdate {
	public static void main(String[] args) {
		Session session=null;
		Transaction tx=null;
		String hql="update UserEntity set passWord=? ";
		try {
			session=HibernateUtil.getSession();
			tx=session.beginTransaction();
			Query qy=session.createQuery(hql);
			qy.setParameter(0, "321");
			int result=qy.executeUpdate();
			System.out.println("fdsa:"+result);
			tx.commit();
		} catch (HibernateException e) {
			tx.rollback();
			e.printStackTrace();
		}finally{
			HibernateUtil.closeSession();
		}
	}
}