Hibernate之HQL

1、HQL的含义:

        HQL是Hibernate Query Language（专属于hibernate框架的一个查询语言）的缩写 

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

3、处理返回的结果集 
    ① 、单个对象—— select没有逗号 
    ② 、Object[]—— b.bookId, b.bookName 
    ③、 Map——new Map(b.bookId as bid, b.bookName as bname) 
    ④、 new  构造方法(attr1,attr2) String/long——new Book(b.bookId, b.price)            单个列段

4、展示

package lv.com.three.test;

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

imort 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 lv.com.two.entity.Book;
import lv.com.two.util.SessionFactoryUtil;

public class HqlTest {
    private Session session;
    private Transaction transaction;
    
    @Before
    public void before() {
        session = SessionFactoryUtil.getSession();
        transaction = session.beginTransaction();
    }
    
    @Aftern   public void after() {
        transaction.commit();
        session.close();
    }
    
    
    @Test
    public void testList1() {
        Query query = session.createQuery("from Book");
        List list = query.list();
        for (Book b : list) {
            System.out.println(b);
        }
    }
    
    
    @Test
    public void testList2() {
        Query query = session.createQuery("select b.bookName as ss frogm Book b");
        List list = query.list();
        for (String b : list) {
            System.out.println(b);
        }
    }
    
    
    @Test
    public void testList3() {
        Query query = session.createQuery("select b.bookId,b.bookName as ss from Book b");
        List list = query.list();
        for (Object[] b : list) {
            System.out.println(Arrays.toString(b));
        }
    }
    
    
    @Test
    public void testList4() {
        Query query = session.createQuery("select new mAp(b.bookId,b.bookName) from Book b");
        List

    }
    
    
    @Test
    public void testList9() {
        Query query = session.createQuery("from Book");
        query.setFirstResult(2);
        query.setMaxResults(3);
        List list = query.list();
        for (Book b : list) {
            System.out.println(b);
        }
    }
}

自定义mvc的baseDao思路：

①、完成一个基础版本的查询方法

②、分析共同之处（代码重复、思想重复）

③、解决方案，代码重复的抽取到父类，思想重复的用反射

        难点：通用分页的处理；思想重复的用反射

写Hibernate的baseDao使用一样的思路：

1、完成一个基础版本的查询方法

public void testList10() {
        String hql="from Book where 1=1";
        Book book=new Book();
        if(book.getBookId() !=0) {
            hql+=" and bookId = :bookId";
        }
        if(book.getBookName() !=null) {
            hql+=" and bookName =: bookName";
        }
        Query query = session.createQuery(hql);
        if(book.getBookId() !=0) {
            query.setParameter("bookId", 1);
        }
        if(book.getBookName() !=null) {
            query.setParameter("bookName", "%圣墟%");
        }
        Book b = (Book) query.getSingleResult();
        System.out.println(b);
        }

2、分析共同之处

        ①、都有非空判断

        ②、都有query对象

        ③、具体值从对象/map

        ④、都需要分页：

                query.setFirstResult(2);//起始下标
                query.setMaxResults(3);//偏移量

        注意：分页是与PageBean的total，是优先查询出符合条件的总记录数

3、解决方案

baseDao:

package lv.com.three.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;

import lv.com.three.hql.PageBean;

public class baseDao {

    
    public void setParam(Map map, Query query) {
        if (map != null && map.size() > 0) {
            Object value = null;
            Set> entrySet = map.entrySet();
            for (Entry entry : entrySet) {
                // 例子的圣墟，但是有的时候它并不是单纯的字符串，可能是数组比如爱好，也可能是集合
                value = entry.getValue();
                if (value instanceof Object[]) {
                    query.setParameterList(entry.getKey(), (Object[]) value);
                } else if (value instanceof Collection) {
                    query.setParameterList(entry.getKey(), (Collection) value);
                } else {
                    query.setParameter(entry.getKey(), value);
                }
            }
        }
    }
    
    
    public String getCountHql(String hql) {
        // hql = "from Book where bookName like :bookName"
        // * hql = "select * from new Book(bid,bookName) where bookName like :bookName"
        int index = hql.toUpperCase().indexOf("FROM");
        return "select count(*) " + hql.substring(index);
    }
    
    
    public List executeQuery(Session session,Map map,String hql,PageBean pageBean) {
        List list = null;
        if(pageBean != null && pageBean.isPagination()) {
            String countHql = getCountHql(hql);
            Query countQuery = session.createQuery(countHql);
            this.setParam(map, countQuery);
            pageBean.setTotal(countQuery.getSingleResult().toString());
            
            Query query = session.createQuery(hql);
//            给预定义hql语句执行对象中的参数赋值，有多少赋值多少
            this.setParam(map, query);
            query.setFirstResult(pageBean.getStartIndex());
            query.setMaxResults(pageBean.getRows());
            list = query.list();
        }else {
            Query query = session.createQuery(hql);
//            给预定义hql语句执行对象中的参数赋值，有多少赋值多少
            this.setParam(map, query);
            list = query.list();
        }
        return list;
    }

}

BookDao:

package lv.com.two.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 lv.com.three.dao.baseDao;
import lv.com.three.hql.PageBean;
import lv.com.three.hql.StringUtils;
import lv.com.two.entity.Book;
import lv.com.two.entity.Category;
import lv.com.two.util.SessionFactoryUtil;

public class BookDao extends baseDao{
    public Integer addBook(Book book) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        Integer bid = (Integer) session.save(book);
        transaction.commit();
        session.close();
        return bid;
    }
    
    public Integer addCategory(Category category) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        Integer cid = (Integer) session.save(category);
        transaction.commit();
        session.close();
        return cid;
    }
    
    public Category getCategory(Category category) {
        Session session = SessionFactoryUtil.getSession();
        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 = SessionFactoryUtil.getSession();
        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 = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        session.delete(book);
        transaction.commit();
        session.close();
    }
    
    public void delCategory(Category category) {
        Session session = SessionFactoryUtil.getSession();
        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();
    }
    
    
    
    
    public List list(Book book, PageBean pageBean) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        String hql = "from Book where 1 = 1";

        if (StringUtils.isNotBlank(book.getBookName())) {
            hql += " and bookName like :bookName";
        }

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

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

    }
    
    
    public List list2(Book book, PageBean pageBean) {
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        String hql = "from Book where 1 = 1";
        Map map = new HashMap();

        if (StringUtils.isNotBlank(book.getBookName())) {
            hql += " and bookName like :bookName";
            map.put("bookName", book.getBookName());
        }
        List list = super.executeQuery(session, map, hql, pageBean);
        transaction.commit();
        session.close();
        return list;
    }
    
    
    public List list3(Book book, PageBean pageBean) {
//        String sql = "select b.*,o.* from t_hibernate_book b,t_hibernate_Order o";
        String sql = "select * from t_hibernate_book";
        Session session = SessionFactoryUtil.getSession();
        Transaction transaction = session.beginTransaction();
        List list = session.createSQLQuery(sql).list();
        transaction.commit();
        session.close();
        return list;
    }
}
 

进行测试：

    @Test

//    原生sql
    public void testList1() {
        PageBean pageBean=new PageBean();
        pageBean.setRows(3);
        Book book = new Book();
//        book.setBookName("%圣墟%");
        List list=this.bookDao.list3(book, pageBean);
        for (Book b : list) {
            System.out.println(b);
        }
    }

     @Test
//    使用baseDao
    public void testList2() {
        PageBean pageBean=new PageBean();
        pageBean.setRows(3);
        Book book = new Book();
//        book.setBookName("%圣墟%");
        List list=this.bookDao.list2(book, pageBean);
        for (Book b : list) {
            System.out.println(b);
        }
    }

     @Test
//    在hibernate中使用原生sql
    public void testList3() {
        PageBean pageBean=new PageBean();
        pageBean.setRows(3);
        Book book = new Book();
        List list=this.bookDao.list3(book, pageBean);
        for (Object[] object : list) {
            System.out.println(Arrays.toString(object));
        }
    }

本期内容结束~