hql 订阅
HQL是Hibernate Query Language(Hibernate 查询语言)的缩写,提供更加丰富灵活、更为强大的查询能力;HQL更接近SQL语句查询语法。Hibernate 查询语言(HQL)是一种面向对象的查询语言,类似于 SQL,但不是去对表和列进行操作,而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。 展开全文
HQL是Hibernate Query Language(Hibernate 查询语言)的缩写,提供更加丰富灵活、更为强大的查询能力;HQL更接近SQL语句查询语法。Hibernate 查询语言(HQL)是一种面向对象的查询语言,类似于 SQL,但不是去对表和列进行操作,而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。
信息
外文名
Hibernate Query Language
缩    写
hql
特    点
对查询条件进行了面向对象封装
中文名
Hibernate 查询语言
接    近
SQL语句查询语法
hqlHQL的优点
Hibernate查询语言(HQL)与SQL(结构化查询语言)相同,但不依赖于数据库表。 我们在HQL中使用类名,而不是表名,它是数据库独立的查询语言。HQL有很多优点:
收起全文
精华内容
下载资源
问答
  • HQL

    2020-03-20 19:18:51
    HQL是Hibernate提供的一种面向对象的查询语言; 具体就是HQL是一种面向对象的查询语言,类似于 SQL,但不是去对表和列进行操作,而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对...

    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

    千次阅读 2019-09-04 18:26:01
    HQL 是Hibernate Query Language的缩写 hql 与 sql 的区别/异同 hql sql 类名/属性 表名/列名 区分大小写,关键字不区分大小写 不区分大小写 别名 : ?,从下标0开始计算位置(hibernate5之后不支持) 别名...

    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

    2018-10-29 20:01:37
    什么是hql HQL是Hibernate Query Language的缩写 查全部 hql和sql区别/异同 HQL SQL 类名/属性 表名/列名 区分大小写,关键字不区分大小写 不区分大小写 别名 ...
    1. 什么是hql
      HQL是Hibernate Query Language的缩写

      查全部

    2. hql和sql区别/异同
      HQL SQL
      类名/属性 表名/列名
      区分大小写,关键字不区分大小写 不区分大小写
      别名 别名
      ?,从下标0开始计算位置(hibernate5之后不支持) ?,从顺序1开始计算位置
      :命名参数 不支持:命名参数
      面向对象的查询语言 面向结构查询语言

    3. 处理返回的结果集
      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)
      在这里插入图片描述

    在这里插入图片描述

    1. hql中使用占位符
      4.1 ?占位符
      从下标0开始计算位置
      hibernate5之后不再支持?占位符

    在这里插入图片描述

    1. 聚合函数
      sum
      avg
      max
      min
      count

    7分页

    在这里插入图片描述

    展开全文
  • hibernateHQL

    2019-09-06 10:44:59
    文章目录HQLhql与sql的区别hql的几种返回类型案例 HQL 定义 hql与sql的区别 hql sql 面向对象 面向结构 操作的是类 ,类属性 表,表列段 命名参数占位 占位符 hql的几种返回类型 返回对象 from 类名...

    HQL

    定义

    hql与sql的区别

    hql sql
    面向对象 面向结构
    操作的是类 ,类属性 表,表列段
    命名参数占位 占位符

    hql的几种返回类型

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

    案例

    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);
    		}
    	}
    

    效果一样,省了很多代码
    在这里插入图片描述

    展开全文
  • HQL查询

    2019-10-03 21:53:50
    什么是HQL HQL检索方式 HQL查询的from子句 HQL查询的select子句 HQL查询的聚集函数 HQL查询的where子句 绑定参数 排序 分组函数 分页查询 对象导航式 连接查询 本地 SQL 检索方式 1 Hibernate ...
  • HQL语句

    2020-09-09 10:10:27
    hql常用查询语句 // HQL: Hibernate Query Language. // 特点: // >> 1,与SQL相似,SQL中的语法基本上都可以直接使用。 // >> 2,SQL查询的是表和表中的列;HQL查询的是对象与对象中的属性。 // >&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,371
精华内容 8,948
关键字:

hql