HQL是Hibernate提供的一种面向对象的查询语言;

具体就是HQL是一种面向对象的查询语言，类似于 SQL，但不是去对表和列进行操作，而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。

HQL的优点和SQL的区别:

面向对象,与数据库无关

语法与SQL类是,比较容易学习

HQL的用法:

获得HibernateSession对象

编写HQL语句

调用Session的createQuery方法创建Query对象执行HQL语句

如果HQL语句包含参数，则调用Query的setXxx方法为参数赋值

调用Query对象的list等方法返回查询结果。

HQL的一些常用示例

1.无参查询所有
String hql="select t from UserEntity t";
     //获得query对象,并执行hql语句
    Query query = session.createQuery(hql);
    //得到查询结果
     List<UserEntity> list =  query.list();

2,有参查询
String hql="from UserEntity where userName = ?";
     List<UserEntity > list =
       session.createQuery(hql)
               .setParameter(0,"小白")//设置参数替换占位符
               .list();

3,有参查询部分列1
 String hql="select userName,pwd from  UserEntity ";
       //查询结果,每一个Object数组代表一行
        List<Object[]> list =
         session.createQuery(hql).list();

4,有参查询部分列2
String hql="select new map(userName,pwd) from TeacherEntity";
		//查询结果,每个map集合代表结果的一行
        List<Map> list=
         session.createQuery(hql).list();

5,模糊查询
String hql="select new map(userName,pwd) " +
                "from UserEntity where userName like ?";
        List<Map> list = session.createQuery(hql)
        				//传参时,需要加上通配符
                        .setParameter(0,"小%")
                        .list();

6,连表查询
 String hql="select new map(s.studentName,t.teacherName,t.teacherClass) " +
                "from StudentEntity s " +
                " left join s.teacher t where t.teacherName=?";
         List<Map> list=
           session.createQuery(hql)
                   .setParameter(0,"陈老师")
                   .list();

8,分页查询
String hql="from UserEntity where teacherName like ?";
        List<TeacherEntity> list=
                session.createQuery(hql)
                .setParameter(0,"小%")
                .setFirstResult(0) //起始下标
                .setMaxResults(5) //每页显示的行数
                .list();

9,查询单个对象
 String hql="from UserEntity where userName like ?";
      TeacherEntity t=
              (TeacherEntity) session.createQuery(hql)
                      .setParameter(0,"小%")
                      //返回查询的第一条结果
                      .uniqueResult();

10,删除
  String hql="delete from UserEntity  where id = ?";
     int i =   session.createQuery(hql)
                .setParameter(0,3)
                .executeUpdate(); //执行修改、删除返回受影响的行数

11,修改
 String hql="update UserEntityset userName=? where id = ?";
     int i= session.createQuery(hql)
              .setParameter(0,"小青")
              .setParameter(1,5)
              //执行,并返回受影响行数
              .executeUpdate();

HQL
是Hibernate Query Language的缩写
hql 与  sql 的区别/异同




hql
sql




类名/属性
表名/列名


区分大小写,关键字不区分大小写
不区分大小写


别名 : ?，从下标0开始计算位置(hibernate5之后不支持)
别名：?，从顺序1开始计算位置


:命名参数
不支持:命名参数


面向对象的查询语言
面向结构查询语言


hql 语句介绍
package com.hyf.xFive.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.hyf.four.entity.Book;
import com.hyf.two.util.SessionFactoryUtils;

public class HqlTest {
	private Session session;
	private Transaction transaction;
	
	@Before
	public void before() {
		session = SessionFactoryUtils.openSession();
		transaction = session.beginTransaction();
	}
	
	@After
	public void after() {
		transaction.commit();
		session.close();
	}
	
	/**
	 * 返回对象（多个）
	 */
	@Test
	public void testList1() {
		Query query = session.createQuery("from Book");
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * 返回单个列段，用字符串就可以接受
	 */
	@Test
	public void testList2() {
		Query query = session.createQuery("select b.bookName as ss from Book b");
		List<String> list = query.list();
		for (String b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * 查两个列段及以上，默认返回的是Object【】
	 */
	@Test
	public void testList3() {
		Query query = session.createQuery("select b.bookId,b.bookName as ss from Book b");
		List<Object[]> list = query.list();
		for (Object[] b : list) {
			System.out.println(Arrays.toString(b));
		}
	}
	
	/**
	 * 注意map是函数，所以不区分大小写，返回的是map集合
	 */
	@Test
	public void testList4() {
		Query query = session.createQuery("select new mAp(b.bookId,b.bookName) from Book b");
		List<Map> list = query.list();
		for (Map b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * 查两个列段及以上，也可返回对象，前提是有对应的构造函数
	 */
	@Test
	public void testList5() {
		Query query = session.createQuery("select new Book(b.bookId,b.bookName) from Book b");
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * HQL语句支持占位符
	 */
	@Test
	public void testList6() {
//		Query query = session.createQuery("from Book where bookId = :bookId");
//		query.setParameter("bookId", 1);
//		Book b = (Book) query.getSingleResult();
//		System.out.println(b);
		
		Query query = session.createQuery("from Book where bookId in (:bookIds)");
		// 查询id 为 1 ， 2，4
		// 传数组
//		query.setParameterList("bookIds", new Integer[] {1,2,4});
		// 传集合
		List<Integer> params = new ArrayList<Integer>();
		params.add(1);
		params.add(2);
		params.add(4);
		query.setParameterList("bookIds", params);
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * HQL支持连接查询
	 */
	@Test
	public void testList7() {
		Query query = session.createQuery("select o.orderNo,oi.quantity from Order o,OrderItem oi where o = oi.order");
		List<Object[]> list = query.list();
		for (Object[] b : list) {
			System.out.println(Arrays.toString(b));
		}
	}
	
	/**
	 * HQL支持聚合函数
	 */
	@Test
	public void testList8() {
		Query query = session.createQuery("select count(*) from Book");
		Long singleResult = (Long) query.getSingleResult();
		System.out.println(singleResult);
	}
	
	/**
	 * HQL分页
	 */
	@Test
	public void testList9() {
		Query query = session.createQuery("from Book");
		query.setFirstResult(2);
		query.setMaxResults(3);
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
}


query.list(); 查询多条数据

query.getSingleResult() 查询多条数据单条

通用查询hql baseDao
版本一
public  List<Book> list(Book book,PageBean pageBean){
		Session session = SessionFactoryUtils.openSession();
		String hql = "from Book where 1=1";
		String bname = book.getBookName();
		if(StringUtils.isNotBlank(bname)) {
			hql +=" and bookName like :bookName";
		}
        		
		Query query = session.createQuery(hql );
		
		// 当 bname 不等于空的时候赋值
		if(StringUtils.isNotBlank(bname)) {
			query.setParameter("bookName", bname);
		}
		
		// 分页
		if(pageBean !=null && pageBean.isPagination()) {
			// 设置pageBean 起始下标
			query.setFirstResult(pageBean.getStartIndex());
			query.setMaxResults(pageBean.getRows());
		}
		List list = query.list();
		
		return list;
	}
	

问题：每增加一个查询就需要写一个这种语句，如果数量过多的话，导致重复代码过多。


版本二

通用 beasDao
package com.hyf.xFive.util;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.query.Query;

/**
 * 基于hql语句的通用查询通用工具类 
 *      1、需要给拼接的hql语句的命名参数赋值（可以简化的） 
 *      2、分页（可以简化）
 *       
 *      基于sql的分页的查询的做法
 *         1、首先要查询出符合条件的总记录数
 *         2、返回符合条件的记录
 *      参数：sql ,pageBean,Class clz
 *       1、 countSql = select count(*) from (sql) t;
 *       2、 pageSql = sql + " limit " +start +" , " +rows
 *       
 *      基于hql的分页的查询的做法
 *        hql =          from Book where bookName like "%xxx%"
 *        hql = select * from Book where bookName like "%圣墟%"
 *        1、countHql = select count(*) hql  
 *        
 *          
 * @author 17628
 *
 */
public class BeasDao {

	/**
	 * @param query  里面包含了带有参数的hql 语句，需要等待赋值
	 *       "from Book where 1=1  and bookName like :bookName
	 * @param map  
	 *        =request.getParameterMap();
	 */      
	public void setParam(Query query, Map<String, Object> paramMap) {
         if(paramMap !=null && paramMap.size()!=0) {
        	  // 遍历 paramMap 集合 得到前台传来的数据
        	 Set<Entry<String, Object>> entrySet = paramMap.entrySet();
        	 for (Entry<String, Object> entry : entrySet) {
			  // 遍历之后，给 query 赋值
        		 String key = entry.getKey();
        		 Object value = entry.getValue();
        		 // 我们这里要考虑以下 传过来的是数组 还是集合
        		 if(value instanceof Object[]) {
        			 // 当 value 为数组时
        			 query.setParameter(key, (Object [])value);
        		 }else if(value instanceof Collection){
        			// 当 value 为集合时
        			 query.setParameter(key, (Collection)value);
        		 }else {
        			 // 普通字符串
        			 query.setParameter(key, value);
        		 }
			}
         }
	}
	
	
	/**
	 *  拼装符合条件的总记录数
	 * 2、countHql = select count(*) hql  
	 *   hql 可以能为以下两种情况
	 *       hql =          from Book where bookName like "%xxx%"
 *           hql = select * from Book where bookName like "%圣墟%"
	 *       所以通过截取得到  from和后面的条件
	 * 
	 * @param hql
	 * @return
	 */
	public String getCountSql(String hql) {
		// toUpperCase()  转大写  。因为hql 区分大小写 ，我们干脆把hql语句转成 大写
		// indexOf()      取 FROM 的下标
		int fromIndex = hql.toUpperCase().indexOf("FROM");
		return "select count(*)"+hql.substring(fromIndex);
	}
	
	
	/**
	 * 基于hql通用查询方法
	 * 
	 * @param hql       最终传来的 hql 语句
	 * @param pageBean  分页
	 * @param paramMap  =request.getParameterMap(); 前台传来的 值
	 * @param session   创建 Query 对象
	 * @return
	 */
	public List  executeQuery(String hql,PageBean pageBean,Map<String,Object> paramMap,Session session) {
		List list = null;
		Query query = null;
		if(pageBean != null && pageBean.isPagination()) {
			// 获取查询的总数量
			String countHql =getCountSql(hql);
			Query createQuery = session.createQuery(countHql);
			this.setParam(createQuery, paramMap);
			//将总行数放入PageBean对象
			pageBean.setTotal(createQuery.getSingleResult().toString());
			
			// 返回符合条件的记录
			query = session.createQuery(hql);
			//给预定于的hql语句的命名参数赋值。有多少赋多少
			this.setParam(query, paramMap);
			//设置开始位置（下标从0开始）
			query.setFirstResult(pageBean.getStartIndex());
			//这是偏移量，就是一页展示几条数据
			query.setMaxResults(pageBean.getRows());
			list=query.list();
		}else {
			// 不分页
			query=session.createQuery(hql);
			this.setParam(query, paramMap);
			list=query.list();
		}
		return list;
		
	}
}


BookDao

它需要继承 BaseDao
public  List<Book> listPlus(Book book,PageBean pageBean){
		Session session = SessionFactoryUtils.openSession();
		String hql = "from Book where 1=1";
		String bname = book.getBookName();
		
//		这个是jsp 自动传递过来的，不与要手写，模拟一下
		Map<String, Object> map = new HashMap<String, Object>();
		
		if(StringUtils.isNotBlank(bname)) {
			hql +=" and bookName like :bookName";
			map.put("bookName", bname);
		}
		
		List list = super.executeQuery(hql, pageBean, map, session);
		session.close();
		return list;
	}

JUnit 测试
	@Test
	public void testList11() {
        Book b = new Book();
        PageBean pageBena = new PageBean();
        pageBena.setPage(3);
     //   b.setBookName("%圣墟%");
        List<Book> list = this.bookDao.listPlus(b, pageBena);
        for (Book book : list) {
			System.out.println(book);
		}
	}

测试结果：

什么是hql

HQL是Hibernate Query Language的缩写
查全部


hql和sql区别/异同

HQL                                           SQL

类名/属性                                     表名/列名

区分大小写,关键字不区分大小写                 不区分大小写

别名                                          别名

?，从下标0开始计算位置(hibernate5之后不支持)  ?，从顺序1开始计算位置

:命名参数                                     不支持:命名参数

面向对象的查询语言                            面向结构查询语言


处理返回的结果集

3.1 单个对象

select没有逗号

3.2 Object[]

b.bookId, b.bookName

3.3 Map

new Map(b.bookId as bid, b.bookName as bname)

3.4 new 构造方法(attr1,attr2)

new Book(b.bookId, b.price)






hql中使用占位符

4.1 ?占位符

从下标0开始计算位置

hibernate5之后不再支持?占位符



聚合函数

sum

avg

max

min

count

7分页

文章目录
HQL
hql与sql的区别
hql的几种返回类型
案例

HQL
定义
hql与sql的区别




hql
sql




面向对象
面向结构


操作的是类 ，类属性
表，表列段


命名参数占位
占位符


hql的几种返回类型


返回对象   from 类名
返回String  查询单个属性
object []      查询两个及两个以上的属性
Map    利用了Map函数，查询两个及两个以上的类属性
返回对象 利用了构造函数的形式


案例
Book
package com.wxm.four.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Book implements Serializable{
	private Integer bookId;
	private String bookName;
	private Float price;
	
	private Set<Category> categories = new HashSet<Category>();
	private Integer initCategories = 0;

	public Integer getInitCategories() {
		return initCategories;
	}

	public void setInitCategories(Integer initCategories) {
		this.initCategories = initCategories;
	}

	public Integer getBookId() {
		return bookId;
	}

	public void setBookId(Integer bookId) {
		this.bookId = bookId;
	}

	public String getBookName() {
		return bookName;
	}

	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public Float getPrice() {
		return price;
	}

	public void setPrice(Float price) {
		this.price = price;
	}

	public Set<Category> getCategories() {
		return categories;
	}

	public void setCategories(Set<Category> categories) {
		this.categories = categories;
	}

	@Override
	public String toString() {
		return "Book [bookId=" + bookId + ", bookName=" + bookName + ", price=" + price + "]";
	}

	public Book(Integer bookId, String bookName) {
		super();
		this.bookId = bookId;
		this.bookName = bookName;
	}

	public Book() {
		super();
	}
	
	
}


BookDao
package com.wxm.four.dao;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;

import com.wxm.five.dao.BaseDao;
import com.wxm.five.dao.PageBean;
import com.wxm.five.dao.StringUtils;
import com.wxm.four.entity.Book;
import com.wxm.four.entity.Category;
import com.wxm.two.util.SessionFactoryUtils;

public class BookDao extends BaseDao {
	public Integer addBook(Book book) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer bid = (Integer) session.save(book);
		transaction.commit();
		session.close();
		return bid;
	}

	public Integer addCategory(Category category) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer cid = (Integer) session.save(category);
		transaction.commit();
		session.close();
		return cid;
	}

	public Category getCategory(Category category) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Category c = session.get(Category.class, category.getCategoryId());
		transaction.commit();
		session.close();
		return c;
	}

	public Book getBook(Book book) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Book b = session.get(Book.class, book.getBookId());
		if (b != null && new Integer(1).equals(book.getInitCategories())) {
			Hibernate.initialize(b.getCategories());
		}
		transaction.commit();
		session.close();
		return b;
	}

	public void delBook(Book book) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		session.delete(book);
		transaction.commit();
		session.close();
	}

	public void delCategory(Category category) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Category c = session.get(Category.class, category.getCategoryId());
		if (c != null) {
			for (Book b : c.getBooks()) {
				// 通过在被控方通过主控方来解除关联关系，最后被控方再做删除
				b.getCategories().remove(c);
			}
		}
		session.delete(c);
		transaction.commit();
		session.close();
	}

	/**
	 * 书籍的分页查询
	 * 
	 * 1.动态的拼接hql语句 2.需要给拼接的hql语句的命名参数赋值(可以简化) 3.分页
	 * 
	 * @param book
	 * @param pageBean
	 * @return
	 */

	public List<Book> list(Book book, PageBean pageBean) {
		Session session = SessionFactoryUtils.openSession();
		// Transaction beginTransaction = session.beginTransaction();

		String hql = "from Book where 1=1 ";
		String bname = book.getBookName();
		if (StringUtils.isNotBlank(bname)) {
			hql += " and bookName like :bookName";

		}
		Query query = session.createQuery(hql);
		if (StringUtils.isNotBlank(bname)) {
			query.setParameter("bookName", bname);

		}

		if (pageBean != null && pageBean.isPagination()) {
			query.setFirstResult(pageBean.getStartIndex());
			query.setMaxResults(pageBean.getRows());
		}
		List list = query.list();

		session.close();
		return list;

	}



HqlTest
package com.wxm.five.test;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.wxm.five.dao.PageBean;
import com.wxm.four.dao.BookDao;
import com.wxm.four.entity.Book;
import com.wxm.two.util.SessionFactoryUtils;

public class HqlTest {
	private Session session;
	private Transaction transaction;
	BookDao bookDao=new BookDao();
	 
	@Before
	public void before() {
		session = SessionFactoryUtils.openSession();
		transaction = session.beginTransaction();
	}
	
	@After
	public void after() {
		transaction.commit();
		session.close();
	}
	
	/**
	 * 返回对象（多个）
	 */
	@Test
	public void testList1() {
		Query query = session.createQuery("from Book");
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * 返回单个列段，用字符串就可以接受
	 */
	@Test
	public void testList2() {
		Query query = session.createQuery("select b.bookName as ss from Book b");
		List<String> list = query.list();
		for (String b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * 查两个列段及以上，默认返回的是Object【】
	 */
	@Test
	public void testList3() {
		Query query = session.createQuery("select b.bookId,b.bookName as ss from Book b");
		List<Object[]> list = query.list();
		for (Object[] b : list) {
			System.out.println(Arrays.toString(b));
		}
	}
	
	/**
	 * 注意map是函数，所以不区分大小写，返回的是map集合
	 */
	@Test
	public void testList4() {
		Query query = session.createQuery("select new mAp(b.bookId,b.bookName) from Book b");
		List<Map> list = query.list();
		for (Map b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * 查两个列段及以上，也可返回对象，前提是有对应的构造函数
	 */
	@Test
	public void testList5() {
		Query query = session.createQuery("select new Book(b.bookId,b.bookName) from Book b");
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * HQL语句支持占位符
	 */
	@Test
	public void testList6() {
//		Query query = session.createQuery("from Book where bookId = :bookId");
//		query.setParameter("bookId", 1);
//		Book b = (Book) query.getSingleResult();
//		System.out.println(b);
		
		Query query = session.createQuery("from Book where bookId in (:bookIds)");
		query.setParameterList("bookIds", new Integer[] {1,2,4});
//		List<Integer> params = new ArrayList<Integer>();
//		params.add(1);
//		params.add(2);
//		params.add(4);
//		query.setParameterList("bookIds", params);
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
	
	/**
	 * HQL支持连接查询
	 */
	@Test
	public void testList7() {
		Query query = session.createQuery("select o.orderNo,oi.quantity from Order o,OrderItem oi where o = oi.order");
		List<Object[]> list = query.list();
		for (Object[] b : list) {
			System.out.println(Arrays.toString(b));
		}
	}
	
	/**
	 * HQL支持聚合函数
	 */
	@Test
	public void testList8() {
		Query query = session.createQuery("select count(*) from Book");
		Long singleResult = (Long) query.getSingleResult();
		System.out.println(singleResult);
	}
	
	/**
	 * HQL分页
	 */
	@Test
	public void testList9() {
		Query query = session.createQuery("from Book");
		query.setFirstResult(2);
		query.setMaxResults(3);
		List<Book> list = query.list();
		for (Book b : list) {
			System.out.println(b);
		}
	}
	@Test
	public void testList10() {
		  Book book=new Book();
		  PageBean pageBean =new PageBean();
//		  pageBean.setPagination(true);
		  book.setBookName("%圣墟%");
		  
		  List<Book> list=this.bookDao.list(book, pageBean);
		  for (Book b : list) {
			System.out.println(b);
		}
	}
	/**
	 *继承了basedao后
	 */
	@Test
	public void testList11() {
		  Book book=new Book();
		  PageBean pageBean =new PageBean();
//		  pageBean.setPagination(false);
		  book.setBookName("%圣墟%");
		  
		  List<Book> list=this.bookDao.listPlus(book, pageBean);
		  for (Book b : list) {
			System.out.println(b);
		}
	}
}




问题：每增加一个查询就需要写一个这种语句，如果数量过多的话，导致重复代码过多。因此我们封装了baseDao类

BaseDao
package com.wxm.five.dao;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.query.Query;

/**
 * 基于hql语句的查询工具类
 * 
 * 1.动态的拼接hql语句 2.需要给拼接的hql语句的命名参数赋值(可以简化) 3.分页
 * 
 * 基于sql的分页的查询的做法 1.首先要查询出符合条件的总记录数 2.返回符合条件的记录
 * 
 * 
 * 参数:sql,pagebean,Class clz sql=select * from t_hibernate_book where bookName
 * like "%圣墟%"
 * 
 * 
 * 1.countSql=select count(*)form (sql)t 2.pageSql=sql+" limit "+start+","+rows
 * 
 * 基于hql的分页的查询的做法 hql=from Book where bookName like "%圣墟%" hql=select * from
 * Book where bookName like "%圣墟%"
 * 
 * 1.countHql=select count(*) hql;
 * 
 */
public class BaseDao {

	/**
	 *
	 * 
	 * @param query
	 *            里面的包含了带有命名参数hql语句,需要等待赋值 from Book where 1=1 ";
	 * @param parameMap
	 *            =request.getParameterMap();
	 */
	public void setParam(Query query, Map<String, Object> paramMap) {
		if (paramMap != null && paramMap.size() > 0) {
			Set<Entry<String, Object>> entrySet = paramMap.entrySet();
			for (Entry<String, Object> entry : entrySet) {
				// 给query赋值
				String key = entry.getKey();
				Object value = entry.getValue();
				if (value instanceof Object[]) {
					// value可能是集合
					query.setParameterList("bookIds", (Object[]) value);
				} else if (value instanceof Collection) {
					// value可能是集合
					query.setParameterList("bookIds", (Collection) value);
				} else {//普通字符串
					query.setParameter(key, value);
				}
			}

		}

	}

	/**
	 * 拼装符合条件总记录数
	 * 
	 * @param hql
	 * @return
	 */
	public String getCountHql(String hql) {
		//indexOf()      取 FROM 的下标
		int fromIndex = hql.toUpperCase().indexOf("FROM");
		return "select count(*) " + hql.substring(fromIndex);

	}

	/**
	 * 基于hql的通用查询方法
	 * 
	 * @param hql
	 * @param pageBean
	 * @param paMap
	 * @param session
	 * @return
	 */
	public List excuteQuery(String hql, PageBean pageBean, Map<String, Object> paMap, Session session) {
		List list = null;
		Query query = null;
		if (pageBean != null && pageBean.isPagination()) {
			// 1.首先要查询出符合条件的总记录数
			String countHql = getCountHql(hql);
			Query countQuery = session.createQuery(countHql);
			this.setParam(countQuery, paMap);
			//将总行数放入pageBean对象
			pageBean.setTotal(countQuery.getSingleResult().toString());

			// 2.返回符合条件的记录
			query = session.createQuery(hql);
			//给预定于的hql语句的命名参数赋值。有多少赋多少
			this.setParam(query, paMap);
			//设置开始位置
			query.setFirstResult(pageBean.getStartIndex());
			//这是偏移量，就是一页展示几条数据
			query.setMaxResults(pageBean.getRows());
			list = query.list();
		} else {
			query = session.createQuery(hql);
			this.setParam(query, paMap);
			list = query.list();
		}

		return list;

	}
}


BookDao
/**
 * 基于hql 继承了basedao的BookDao
 * @param book
 * @param pageBean
 * @return
 */
	public List<Book> listPlus(Book book, PageBean pageBean) {
		Session session = SessionFactoryUtils.openSession();

		String hql = "from Book where 1=1 ";
		String bname = book.getBookName();
		// 这是jsp自动传递过来的,不需要手写,这里模拟一下
		Map<String, Object> map = new HashMap<String, Object>();
		if (StringUtils.isNotBlank(bname)) {
			hql += " and bookName like :bookName";
			map.put("bookName", bname);
		}
		Query query = session.createQuery(hql);
		List list = super.excuteQuery(hql, pageBean, map, session);
		session.close();
		return list;

	}

HqlTest
	/**
	 *继承了basedao后
	 */
	@Test
	public void testList11() {
		  Book book=new Book();
		  PageBean pageBean =new PageBean();
//		  pageBean.setPagination(false);
		  book.setBookName("%圣墟%");
		  
		  List<Book> list=this.bookDao.listPlus(book, pageBean);
		  for (Book b : list) {
			System.out.println(b);
		}
	}

效果一样，省了很多代码