Hibernate——HQL语句

深碍√TFBOYSˉ_ 2022-05-30 07:49 225阅读 0赞

# **HQL(Hibernate Query Language) – 官方推荐** #

前面的入门示例中，我们通过`session.load(Employee.class, 1)`，也就是通过`load()`方法或者`get()`方法，可以通过主键属性来查询一条记录。当然这种方法很有局限性，为了更多的查询需求，我们需要使用HQL语句。

HQL即Hibernate查询语言，它是面向对象的查询语言，与SQL不同，HQL中的对象名是区分大小写的（除了JAVA类和属性的其他部分不区分大小写）；HQL中查的是对象而不是表，并且支持多态；HQL主要通过Query来操作，Query的创建方式：

Query q = session.createQuery(hql);

hql = from Person
     hql = from User user where user.name = :name
     hql = from User user where user.name = :name and user.birthday < :birthday

下面我们通过示例来学习HQL的相关语法。

## **建立三张表** ##

这里我们建立三张表，通过示例来学习HQL语法。

CREATE TABLE student (
        sid INT PRIMARY KEY,
        sname VARCHAR (45) NOT NULL,
        ssex CHAR (2) NOT NULL,
        sdept VARCHAR (10) NOT NULL,
        sage INT,
        saddress VARCHAR (45)
    );
    
    -- 学生表中的数据
    INSERT INTO student
    VALUES
        (
            20040001,
            '林青霞',
            'F',
            '计算机系',
            22,
            '上海'
        );
    
    INSERT INTO student
    VALUES
        (
            20040002,
            '刘德华',
            'M',
            '外语系',
            23,
            '南京'
        );
    
    INSERT INTO student
    VALUES
        (
            20050003,
            '成龙',
            'M',
            '化学系',
            21,
            '山东'
        );
    
    INSERT INTO student
    VALUES
        (
            20050004,
            '林可欣',
            'F',
            '计算机系',
            22,
            '北京'
        );
    
    INSERT INTO student
    VALUES
        (
            20050005,
            '周华健',
            'M',
            '生物系',
            24,
            '山东'
        );
    
    INSERT INTO student
    VALUES
        (
            20050006,
            '周润发',
            'M',
            '数学系',
            20,
            '湖北'
        );
    
    -- 建立课程表
    CREATE TABLE course (
        cid INT PRIMARY KEY,
        -- 这是课程号
        cname VARCHAR (50) NOT NULL,
        -- 课程名
        ccredit INT -- 课程学分
    );
    
    INSERT INTO course
    VALUES
        (11, 'java编程', 6);
    
    INSERT INTO course
    VALUES
        (21, 'c++课程', 4);
    
    INSERT INTO course
    VALUES
        (31, 'oracle', 3);
    
    INSERT INTO course
    VALUES
        (41, 'javaEE', 100);
    
    INSERT INTO course
    VALUES
        (51, 'linux', 1);
    
    -- 建立选课表
    CREATE TABLE studCourse (
        stuCourseId INT AUTO_INCREMENT PRIMARY KEY,
        -- 这是一个自增的,表示一次选课
        sid INT REFERENCES student (sid),
        -- 学生号
        cid INT REFERENCES course (cid),
        -- 课程号
        grade INT NOT NULL -- 成绩
    );
    
    -- 初始化数据
    INSERT INTO studCourse (sid, cid, grade)
    VALUES
        (20040001, 11, 90);
    
    INSERT INTO studCourse (sid, cid, grade)
    VALUES
        (20040001, 21, 19);
    
    INSERT INTO studCourse (sid, cid, grade)
    VALUES
        (20050003, 21, 45);
    
    INSERT INTO studCourse (sid, cid, grade)
    VALUES
        (20050004, 41, 99);
    
    INSERT INTO studCourse (sid, cid, grade)
    VALUES
        (20050006, 11, 39);

此时数据库中的数据如下：

![这里写图片描述][70]

## **建立项目HibernateHQL** ##

我们使用Hibernate自动生成domain对象和映射文件，如果我们的表有主外键的关系，应该先映射主表，再映射从表。

另外，在IntelliJ IDEA中，需要手动配置一对多，或者多对一、多对多的关系。

当然，首先我们需要先配置好数据源，建好domain对象存放的包。建数据源的步骤可以参考[Hibernate——入门][Hibernate]

**(1) 使用Hibernate Persistence 工具，选中我们要映射的表及其字段**

![这里写图片描述][70 1]

这里最重要的一点是，我们不能勾选`studCourse`表中的`sid`字段和`cid`字段，因为在生成的`StudCourse`domain对象中，这两个字段会对应生成`Student`对象和`Course`对象。这在接下来配置一对多关系的时候就会看到。

**(2) 配置一对多和多对一的关系，也就是我们的表所对应的外键关系**

首先，`student`和`studCourse`是一对多的关系，一个`student`可以对应多个`studCourse`；反过来，`studCourse`和`student`是多对一的关系,即多个`studCourse`可以对应一个`student`。

在Hibernate中，这样的关系在domain对象中表现为，`StudCourse`对象有一个`Student`属性，即一个`StudCourse`对象对应一个`Student`对象，这个`Student`对象根据`studCourse`表的外键字段`sid`生成。`Student`对象【可以】有一个`Set<StudCourse>`集合，表示一个`Student`对象对应多个`StudCourse`对象。这里用了【可以】一词，其实是为了说，不一定是`Set<StudCourse>`，也可以是`List<StudCourse>`。

还是在刚才的界面，我们选中`studCourse`表，然后点击表格上方的加号。

![这里写图片描述][70 2]

在弹出来的界面中配置`Student`与`StudCourse`的关系。

![这里写图片描述][70 3]

同样的，与`Student`和`StudCourse`类似，我们配置`Course`与`StudCourse`的关系。

![这里写图片描述][70 4]

最后，在我们的配置界面，我们可以看到刚才配置的关系，这里可以检查一下是否有错误。

![这里写图片描述][70 5]

确认无误后，我们点击确定就可以了。此时，IDEA会帮我们自动在`com.gavin.domain`包下生成3个domain对象和3个映射文件。

如下图：

![这里写图片描述][70 6]

此时我们的3个domain对象分别如下：

public class Student {
        
        private int sid;
        private String sname;
        private String ssex;
        private String sdept;
        private Integer sage;
        private String saddress;
        private Set<StudCourse> studcourse;
    
        // ... 省略其他方法
    }
    
    public class Course {
        
        private int cid;
        private String cname;
        private Integer ccredit;
        private Set<StudCourse> studcourse;
    
        // ... 省略其他方法
    }
    
    public class StudCourse {
        
        private int stuCourseId;
        private int grade;
        private Student student;
        private Course course;
    
        // ... 省略其他方法
    }

可以看到，`Student`类和`Course`类都包含一个`Set`集合，集合里保存着`StudCourse`对象。而`StudCourse`对象中包含一个`Student`对象和一个`Course`对象。这正好对应我们上面所讲述的一对多和多对一的关系。

此时hibernate.cfg.xml文件如下，记得要配置数据库的用户名和密码，以及数据库方言。

<?xml version='1.0' encoding='utf-8'?>
    <!DOCTYPE hibernate-configuration PUBLIC
            "-//Hibernate/Hibernate Configuration DTD//EN"
            "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
        <session-factory>
            <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
            <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="connection.username">root</property>
            <property name="connection.password">gavin</property>
            <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
            <mapping resource="com/gavin/domain/Course.hbm.xml"/>
            <mapping resource="com/gavin/domain/StudCourse.hbm.xml"/>
            <mapping resource="com/gavin/domain/Student.hbm.xml"/>
    
            
            
        </session-factory>
    </hibernate-configuration>

## **HQL语法** ##

### **一个工具类:`HibernateSessionFactory`类** ###

`HibernateSessionFactory`类设计成单例的，并且将`Session`与线程绑定。

package com.gavin.util;
    
    import org.hibernate.HibernateException;
    import org.hibernate.Session;
    import org.hibernate.cfg.Configuration;
    
    public class HibernateSessionFactory {
        
        private static final ThreadLocal<Session> threadLocal = new ThreadLocal<>();
        private static org.hibernate.SessionFactory sessionFactory;
    
        static {
            sessionFactory = new Configuration().configure().buildSessionFactory();
        }
    
        /**
         * 单例
         */
        private HibernateSessionFactory() {
        }
    
        public static Session getSession() throws HibernateException {
            Session session = threadLocal.get();
    
            if (session == null || !session.isOpen()) {
                if (sessionFactory == null) {
                    rebuildSessionFactory();
                }
                session = (sessionFactory != null) ? sessionFactory.openSession()
                        : null;
                threadLocal.set(session);
            }
    
            return session;
        }
    
        public static void rebuildSessionFactory() {
            try {
                sessionFactory = new Configuration().configure().buildSessionFactory();
            } catch (Exception e) {
                System.err.println("%%%% Error Creating SessionFactory %%%%");
                e.printStackTrace();
            }
        }
    
        public static void closeSession() throws HibernateException {
            Session session = threadLocal.get();
            threadLocal.set(null);
    
            if (session != null) {
                session.close();
            }
        }
    
        public static org.hibernate.SessionFactory getSessionFactory() {
            return sessionFactory;
        }
    }

### **测试** ###

*  **1. 查询所有学生信息，并输出其选课信息。**

package com.gavin.view;
    
    import com.gavin.domain.Course;
    import com.gavin.domain.StudCourse;
    import com.gavin.domain.Student;
    import com.gavin.util.HibernateSessionFactory;
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    
    import java.util.List;
    
    public class TestMain {
        
    
        public static void main(String[] args) {
            queryAll();
        }
    
        public static void queryAll() {
            Session session = null;
            Transaction transaction = null;
            try {
                session = HibernateSessionFactory.getSession();
                transaction = session.beginTransaction();
                // 1.检索所有学生
                List<Student> list = session.createQuery("from Student").list();
                transaction.commit();
    
                for (Student student : list) {
                    int size = student.getStudcourse().size();
                    if (size == 0) {
                        System.out.println(student.getSname() + "没有选课");
                    }else{
                        System.out.println(student.getSname() + "选了" + size + "门课");
                        for (StudCourse studCourse : student.getStudcourse()) {
                            Course course = studCourse.getCourse();
                            System.out.println(course.getCname()+ " ");
                        }
                        System.out.println();
                    }
                }
            } catch (Exception e) {
                if (transaction != null) {
                    transaction.rollback();
                }
                throw new RuntimeException(e);
            }finally {
                HibernateSessionFactory.closeSession();
            }
        }
    }

如上述代码所示，我们使用HQL语句`from Student`就可以查询所有的学生信息，并不需要`select *`。并且将查询结果直接封装成对象，通过`list()`方法返回查询结果列表。不过要注意的是，这里的`Student`指的是`Student对象`，而不是数据库中的表名，数据库中的表名是小写。

我们查询出来的不止学生基本信息，还包括其选课信息，因为`Student`对象中有`Set<StudCourse>`对象，所以我们连带着将选课信息也可以查出来。下面是运行结果：

林青霞选了2门课
    c++课程 
    java编程 
    
    刘德华没有选课
    成龙选了1门课
    c++课程 
    
    林可欣选了1门课
    javaEE 
    
    周华健没有选课
    周润发选了1门课
    java编程

从这个示例中我们可以看到Hibernate极大地简化了我们的查询过程，在配置好Hibernate之后，我们可以直接对对象进行查询，并直接返回查询出来的对象。

*  **2. 查询部分属性**

public static void querySome(){
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            // 1.检索学生的名字和所在系
            // JDBC是要查询什么字段就查询什么字段，而不要select * from 表
            // 但Hibernate建议我们把对象的所有属性都查询出来，这样才能封装成一个完整的对象
            // 这里进行演示查询部分属性
            List<Object[]> list = session.createQuery("select sname, sdept from Student").list();
            for (Object[] objects: list) {
                System.out.println(objects[0] + " " + objects[1]);
            }
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw new RuntimeException(e);
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

Hibernate不建议我们查询部分属性，而是建议我们把对象的所有属性都查询出来，这样才能封装成一个完整的对象。

要注意的是，`select sname, sdept from Student`这句话中的`sname`和`sdept`都是`Student`对象的属性名，而不是数据库表的字段。

林青霞 计算机系
    刘德华 外语系
    成龙 化学系
    林可欣 计算机系
    周华健 生物系
    周润发 数学系

*  **3. 根据条件查询一个单独的对象**

public static void queryOne() {
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
    
            Student student = (Student) session.createQuery("from Student where sid = " + 20050003).uniqueResult();
            System.out.println("student = " + student);
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

HQL也支持where条件查询，上述示例，我们查询sid为20050003的学生，并通过`uniqueResult()`方法直接返回一个单独的结果。输出如下：

student = Student{sid=20050003, sname='成龙', ssex='M', sdept='化学系', sage=21, saddress='山东'}

*  **4. 结果去重**

public static void queryDistinct() {
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
    
            List<String> list = session.createQuery("select distinct ssex from Student").list();
            for (String str : list) {
                System.out.println(str);
            }
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

HQL也可以通过`distinct`关键字对结果去重。

F
    M

*  **5. `between`关键字**

public static void queryBetween() {
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            List<Student> list = session.createQuery("from Student where sage between 20 and 22").list();
            for (Student student : list) {
                System.out.println(student);
            }
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

HQL语句也可以在`where`条件中使用`between`关键字。上例查出所有年龄在20和22之间的学生。

Student{sid=20040001, sname='林青霞', ssex='F', sdept='计算机系', sage=22, saddress='上海'}
    Student{sid=20050003, sname='成龙', ssex='M', sdept='化学系', sage=21, saddress='山东'}
    Student{sid=20050004, sname='林可欣', ssex='F', sdept='计算机系', sage=22, saddress='北京'}
    Student{sid=20050006, sname='周润发', ssex='M', sdept='数学系', sage=20, saddress='湖北'}

*  **6. `in`关键字**

public static void queryIn(){
        Session session;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            List<Student> list = session.createQuery("from Student where sage not in (22, 23)").list();
            list.forEach(student -> System.out.println("student = " + student));
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw new RuntimeException(e);
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

HQL语句的`where`条件中也可以使用`in`关键字，上例查出年龄不是22和23岁的学生。

student = Student{sid=20050003, sname='成龙', ssex='M', sdept='化学系', sage=21, saddress='山东'}
    student = Student{sid=20050005, sname='周华健', ssex='M', sdept='生物系', sage=24, saddress='山东'}
    student = Student{sid=20050006, sname='周润发', ssex='M', sdept='数学系', sage=20, saddress='湖北'}

*  **6. `group by`分组查询**

public static void queryGroupBy(){
        Session session;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            List<Object[]> list = session.createQuery("select avg(sage), sdept from Student group by sdept").list();
            list.forEach(objects -> System.out.println("Arrays.toString(objects) = " + Arrays.toString(objects)));
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw new RuntimeException(e);
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

HQL也可以进行`group by`分组，上例通过分组查出了每个系的平均年龄。

Arrays.toString(objects) = [21.0, 化学系]
    Arrays.toString(objects) = [23.0, 外语系]
    Arrays.toString(objects) = [20.0, 数学系]
    Arrays.toString(objects) = [24.0, 生物系]
    Arrays.toString(objects) = [22.0, 计算机系]

*  **7. group by having 分组查询并过滤**

public static void queryGroupByHaving(){
        Session session;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            // 查询平均年龄不小于22岁的系
            List<Object[]> list = session.createQuery("select avg(sage), sdept" +
                    " from Student group by sdept having avg(sage) >= 22 ").list();
            list.forEach(objects -> System.out.println("Arrays.toString(objects) = " + Arrays.toString(objects)));
    
            // 查询各个系的女生人数，并过滤出女生人数大于1个的系
            list = session.createQuery("select count(ssex), sdept" +
                    " from Student where ssex='F' group by sdept having count(ssex) >1").list();
            list.forEach(objects -> System.out.println("Arrays.toString(objects) = " + Arrays.toString(objects)));
    
            // 查询计算机系的人数
            List<Long> list1 = session.createQuery("select count(*)" +
                    " from Student where sdept='计算机系'").list();
            list1.forEach(objects -> System.out.println("Arrays.toString(objects) = " + (objects)));
    
            // 查询11号课程的最高分和最低分
            list = session.createQuery("select 11, max(grade), min(grade) from StudCourse where course.cid=11").list();
            list.forEach(objects -> System.out.println("Arrays.toString(objects) = " + Arrays.toString(objects)));
    
            // 查询各科考试不及格学生的姓名，科目与成绩
            // 在这里，HQL语句比SQL简单多了
            list = session.createQuery("select student.sname, course.cname, grade from StudCourse where grade >= 60").list();
            list.forEach(objects -> System.out.println("Arrays.toString(objects) = " + Arrays.toString(objects)));
    
            // 查询各个系不及格的学生人数
            list = session.createQuery("select count(*), student.sdept from StudCourse where grade < 60 group by student.sdept").list();
            list.forEach(objects -> System.out.println("Arrays.toString(objects) = " + Arrays.toString(objects)));
    
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw new RuntimeException(e);
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

上例示范了使用`group by having`语法进行分组查询并过滤。输出如下：

Arrays.toString(objects) = [23.0, 外语系]
    Arrays.toString(objects) = [24.0, 生物系]
    Arrays.toString(objects) = [22.0, 计算机系]
    Arrays.toString(objects) = [2, 计算机系]
    Arrays.toString(objects) = 0
    Arrays.toString(objects) = [11, 90, 39]
    Arrays.toString(objects) = [林青霞, java编程, 90]
    Arrays.toString(objects) = [林可欣, javaEE, 99]
    Arrays.toString(objects) = [1, 化学系]
    Arrays.toString(objects) = [1, 数学系]
    Arrays.toString(objects) = [1, 计算机系]

*  **8. order by 对结果进行排序**

public static void queryOrderBy(){
        Session session;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            List<Student> list = session.createQuery("from Student order by sage").list();
            list.forEach(student -> System.out.println("student = " + student));
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw new RuntimeException(e);
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

HQL支持通过`order by`对结果进行排序。上例将学生按照年龄进行排序。

student = Student{sid=20050006, sname='周润发', ssex='M', sdept='数学系', sage=20, saddress='湖北'}
    student = Student{sid=20050003, sname='成龙', ssex='M', sdept='化学系', sage=21, saddress='山东'}
    student = Student{sid=20040001, sname='林青霞', ssex='F', sdept='计算机系', sage=22, saddress='上海'}
    student = Student{sid=20050004, sname='林可欣', ssex='F', sdept='计算机系', sage=22, saddress='北京'}
    student = Student{sid=20040002, sname='刘德华', ssex='M', sdept='外语系', sage=23, saddress='南京'}
    student = Student{sid=20050005, sname='周华健', ssex='M', sdept='生物系', sage=24, saddress='山东'}

*  **9. 分页查询**

public static void queryByPage(int pageSize){
        // 按照学生年龄从小到大取出第1个到到第3个学生
        Session session;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            long size = (Long) session.createQuery("select count(*) from Student").uniqueResult();
            long pageCount = (size -1) / pageSize + 1;
            for (int i = 0; i < pageCount; i++) {
                System.out.println("**********第 " + i + " 页*************");
                List<Student> list = session.createQuery("from Student order by sage").setFirstResult(pageSize * i)
                        .setMaxResults(pageSize).list();
                list.forEach(student -> System.out.println("student = " + student));
            }
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw new RuntimeException(e);
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

分页查询在日常开发中需求很广泛，上例示范了通过HQL进行分页查询。输入pageSize等于2，输出如下：

**********第 0 页*************
    student = Student{sid=20050006, sname='周润发', ssex='M', sdept='数学系', sage=20, saddress='湖北'}
    student = Student{sid=20050003, sname='成龙', ssex='M', sdept='化学系', sage=21, saddress='山东'}
    **********第 1 页*************
    student = Student{sid=20040001, sname='林青霞', ssex='F', sdept='计算机系', sage=22, saddress='上海'}
    student = Student{sid=20050004, sname='林可欣', ssex='F', sdept='计算机系', sage=22, saddress='北京'}
    **********第 2 页*************
    student = Student{sid=20040002, sname='刘德华', ssex='M', sdept='外语系', sage=23, saddress='南京'}
    student = Student{sid=20050005, sname='周华健', ssex='M', sdept='生物系', sage=24, saddress='山东'}

*  **10. 给查询语句设置参数**

下例演示了给HQL语句传递参数的两种方式。

public static void querySetParameter(){
        Session session;
        Transaction transaction = null;
        try {
            session = HibernateSessionFactory.getSession();
            transaction = session.beginTransaction();
            // 第一种传递参数的方法
            // Query query = session.createQuery("from Student where sdept =:sdept and sage > :sage");
            // query.setParameter("sdept","计算机系");
            // query.setParameter("sage", 20);
    
            // 第二种传递参数的方法
            Query query = session.createQuery("from Student where sdept = ? and sage > ?");
            query.setParameter(0,"计算机系");
            query.setParameter(1, 20);
            List<Student> list = query.list();
            list.forEach(student -> System.out.println("student = " + student));
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw new RuntimeException(e);
        }finally {
            HibernateSessionFactory.closeSession();
        }
    }

--------------------

到此，我们已经发现了上述代码存在很多冗余，所以我们可以把相同的代码抽取出来，写一个专门的工具类来负责统一的查询、更新等。

下面是一个完整的工具类`HibernateUtil`：

package com.gavin.util;
    
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    import org.hibernate.query.Query;
    
    import java.util.List;
    
    public class HibernateUtil {
        
        /**
         * 提供一个统一的查询方法
         * @param hql hql语句
         * @param parameters 参数数组
         * @return List结果列表
         */
        public static List executeQuery(String hql, Object[] parameters) {
            Session session = HibernateSessionFactory.getSession();
            Query query = session.createQuery(hql);
            if (parameters != null) {
                for (int i = 0; i < parameters.length; i++) {
                    query.setParameter(i, parameters[i]);
                }
            }
            return query.list();
        }
    
        /**
         * 提供一个统一的带分页的查询方法
         * @param hql hql语句
         * @param parameters 参数数组
         * @param pageSize 每一页的大小
         * @param pageNow 当前的页数
         * @return 结果列表
         */
        public static List executeQueryByPage(String hql, Object[] parameters, int pageSize, int pageNow) {
            Session session = HibernateSessionFactory.getSession();
            Query query = session.createQuery(hql);
            if (parameters != null) {
                for (int i = 0; i < parameters.length; i++) {
                    query.setParameter(i, parameters[i]);
                }
            }
            query.setFirstResult((pageNow - 1) * pageSize).setMaxResults(pageSize);
            return query.list();
        }
    
        /**
         * 提供一个统一的保存对象方法
         * @param object 对象
         */
        public static void save(Object object) {
            Session session = HibernateSessionFactory.getSession();
            Transaction transaction = null;
            try {
                transaction = session.beginTransaction();
                session.save(object);
                transaction.commit();
            } catch (Exception e) {
                if (transaction != null) {
                    transaction.rollback();
                }
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 一个统一的更新方法
         * @param hql hql语句
         * @param parameters 参数列表
         */
        public static void executeUpdate(String hql, Object[] parameters) {
            Session session = HibernateSessionFactory.getSession();
            Transaction transaction = null;
            Query query;
            try {
                transaction = session.beginTransaction();
                query = session.createQuery(hql);
                if (parameters != null) {
                    for (int i = 0; i < parameters.length; i++) {
                        query.setParameter(i, parameters[i]);
                    }
                }
                query.executeUpdate();
                transaction.commit();
            } catch (Exception e) {
                if (transaction != null) {
                    transaction.rollback();
                }
                throw new RuntimeException(e);
            }
        }
    }

现在的项目结构图如下：

![这里写图片描述][70 7]

--------------------

接下来，是我们通过工具类进行查询的一些示例：

public static void query(){
        String hql = "select student.sname, student.sdept from StudCourse where course.cid=?";
        Object[] objects = new Object[]{
       21};
        List<Object[]> list = HibernateUtil.executeQuery(hql, objects);
        list.forEach(obj -> System.out.println(Arrays.toString(obj)));
    
        hql = "from StudCourse where course.cid = 21";
        List<StudCourse> l = HibernateUtil.executeQuery(hql, null);
        for (StudCourse studcourse : l) {
            System.out.println("studCourse.getGrade() = " + studcourse.getGrade());
            Student s = studcourse.getStudent();
            System.out.println("s = " + s);
        }
    }
    
    public static void update(){
        String hql = "update Course set cid = cid - 1";
        HibernateUtil.executeUpdate(hql, null);
    }
    
    public static void add() {
        Course course = new Course();
        course.setCid(111);
        course.setCname("MySQL");
        course.setCcredit(4);
        HibernateUtil.save(course);
    }
    
    public static void queryByPageByUtil(){
        String hql = "from Student";
        List<Student> list = HibernateUtil.executeQueryByPage(hql, null, 2, 2);
        list.forEach(student -> System.out.println("student = " + student));
    }
    
    public static void queryByUtil() {
        String hql = "from Student where sdept = ? and sage > ?";
        Object[] parameters = new Object[]{
       "计算机系", 20};
        List<Student> list = HibernateUtil.executeQuery(hql, parameters);
        list.forEach(student -> System.out.println("student = " + student));
    }

[70]: /images/20220530/97ee0db30c6c4716ab5b720a6802b1d9.png
[Hibernate]: http://blog.csdn.net/gavin_john/article/details/79435674
[70 1]: /images/20220530/dfec7fea44634fb8927621d95f7e9fa3.png
[70 2]: /images/20220530/f72d081ba02c4d9ab671a9d12cda5223.png
[70 3]: /images/20220530/c44a3ebbe3e0427db8f4abccb599b49e.png
[70 4]: /images/20220530/85598da40db1462e8f6894680a58e195.png
[70 5]: /images/20220530/f97fbf25bf5f4380972f2c9c1a87b443.png
[70 6]: /images/20220530/53939f35147c4f12842f3f65384ca7f0.png
[70 7]: /images/20220530/6dfd9b23533842b88952ae3af590c46a.png