Hibernate入门08_HQL查询

最新推荐文章于 2021-10-20 16:47:31 发布
最新推荐文章于 2021-10-20 16:47:31 发布
阅读量319 收藏
点赞数 1
分类专栏： Hibernate 文章标签： hibernate hql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyl0724/article/details/72872409
版权

一、Hibernate的HQL查询

hql是面向对象查询，格式：from + 类名 + 类对象 + where + 对象的属性，如果是对数据库进行查询操作先比sql比较优。
这里写图片描述

二、代码

import java.util.HashSet;
import java.util.Set;

public class Department {
    private Integer id;
    private String name;
    private Set<Employee> employees = new HashSet<>();
    //get/set...
}
public class Employee {
    private Integer id;
    private String name;
    private float salary;
    private String email;
    private Department dept;

    public Employee() {
    }

    public Employee( String email, float salary,Department dept) {
        super();
        this.salary = salary;
        this.email = email;
        this.dept = dept;
    }
    //get/set...

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + "]";
    }
}

Department.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-4-4 15:42:11 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.hibernate.entities.Department" table="DEPARTMENT">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />

Employee.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-4-4 15:42:11 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.hibernate.entities.Employee" table="EMPLOYEES">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="salary" type="float">
            <column name="SALARY" />
        </property>
        <property name="email" type="java.lang.String">
            <column name="EMAIL" />
        </property>
        <many-to-one name="dept" class="com.hibernate.entities.Department" fetch="join">
            <column name="DEPT_ID" />
        </many-to-one>
    </class>

    <query name="salaryEmps"><![CDATA[FROM Employee e WHERE e.salary > :minSalart AND e.salary < :maxSalary]]></query>
</hibernate-mapping>

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>

    <!-- 配置链接数据库的基本信息 -->
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate01</property>

        <!-- hibernate的基本信息 -->
        <!-- hibernate使用的数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 执行操作时是否在控制台打印sql语句 -->
        <property name="show_sql">true</property>
        <!-- 是否对sql进行格式化 -->
        <property name="format_sql">true</property>
        <!-- 指定自动生成数据表的策略 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 设置hibernate的隔离级别 -->
        <property name="connection.isolation">2</property>
        <!-- 删除对象后，设置其OID为null -->
        <property name="use_identifier_rollback">true</property>

        <!-- 配置C3P0数据源 -->
        <property name="c3p0.max_size">100</property>
        <property name="c3p0.min_size">5</property>
        <property name="c3p0.acquire_increment">2</property>
        <property name="c3p0.idle_test_period">2000</property>
        <property name="c3p0.timeout">2000</property>
        <property name="c3p0.max_statements">10</property>

        <!-- 设置JDBC的statement读取数据库的时候每次从数据库中读取记录条数，这个值100合适，太大会损耗内存，小了速度慢 -->
        <property name="jdbc.fetch_size">100</property>
        <!-- 设置数据库进行批量删除，更新，插入的时候批次的大小，30比较合适 -->
        <property name="jdbc.batch_size">30</property>

        <!-- 指定关联的hbm.xml文件 -->
        <mapping resource="com/hibernate/entities/Department.hbm.xml"/>     
        <mapping resource="com/hibernate/entities/Employee.hbm.xml"/>       

    </session-factory>
</hibernate-configuration>

三、测试代码

import static org.junit.Assert.*;
import java.nio.channels.SeekableByteChannel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.hibernate.entities.Department;
import com.hibernate.entities.Employee;

import javassist.expr.NewArray;

public class HibernateTest {
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;

    @Test
    public void testSave() {
        List<Department> departments = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            Department department = new Department();
            department.setName("DEPT_" + ("A" + i));
            departments.add(department);

            Employee employee1 = new Employee();
            employee1.setName("EMP1_" + ("a" + i));
            employee1.setEmail("EMAIL1_" + ("a" + i));
            employee1.setSalary(1000 + i);
            employee1.setDept(departments.get(i));

            Employee employee2 = new Employee();
            employee2.setName("EMP2_" + ("b" + i));
            employee2.setEmail("EMAIL2_" + ("b" + i));
            employee2.setSalary(2000 + i);
            employee2.setDept(departments.get(i));

            department.getEmployees().add(employee1);
            department.getEmployees().add(employee2);

            employee1.setDept(department);
            employee2.setDept(department);

            session.save(department);
            session.save(employee1);
            session.save(employee2);
        }

    }

    /***
     * 基于位置的参数
     */
    @Test
    public void testHQL() {
        // 1、创建Query对象
        // Employee-对象而不是表名
        String hql = "FROM Employee e WHERE e.salary > ? AND e.email LIKE ? AND e.dept = ? ORDER BY e.salary DESC";
        Query query = session.createQuery(hql);
        // 2、绑定参数
        Department dept = new Department();
        dept.setId(27);
        query.setFloat(0, 100f).setString(1, "%a0%").setEntity(2, dept);
        // 3、查询
        List<Employee> employees = query.list();
        System.out.println(employees.size());
    }

    /***
     * 基于命名参数
     */
    @Test
    public void testHQLNameParam() {
        // 1、创建Query对象
        // Employee-对象而不是表名
        String hql = "FROM Employee e WHERE e.salary > :sal AND e.email LIKE :email";
        Query query = session.createQuery(hql);
        // 2、绑定参数
        query.setFloat("sal", 1500f).setString("email", "%b5%");
        // 3、查询
        List<Employee> employees = query.list();
        System.out.println(employees.size());
    }

    /***
     * 分页查询
     */
    @Test
    public void testPageQuery() {
        String hql = "FROM Employee";
        Query query = session.createQuery(hql);
        int numPage = 3;// 第3页
        int pageSize = 5;// 每一页5条
        List<Employee> employees = query.setFirstResult((numPage - 1) * pageSize).setMaxResults(pageSize).list();
        System.out.println(employees);
    }

    /***
     * 命名查询
     */
    @Test
    public void testNameQuery() {
        //salaryEmps-<query name="salaryEmps">
        Query query = session.getNamedQuery("salaryEmps");
        //查询工资大于1000小于1020 的员工
        List<Employee> employees = query.setFloat("minSalart", 1000f).setFloat("maxSalary", 1020f).list();
        System.out.println(employees.size());
    }

    /***
     * 投影查询
     */
    @Test
    public void testFieldQuery() {
        //Employee类中要有对应的构造器
        String hql = "SELECT new Employee(e.email, e.salary, e.dept) "
                + "FROM Employee e "
                + "WHERE e.dept =:dept";
        Query query = session.createQuery(hql);
        Department dept = new Department();
        dept.setId(28);
//      List<Object[]> employees = query.setEntity("dept", dept).list();
//      for(Object[] objs : employees){
//          System.out.println(Arrays.asList(objs));
//      }
        List<Employee> employees = query.setEntity("dept", dept).list();
        for(Employee employee : employees){
            System.out.println(employee.getSalary()+ " "+employee.getDept().getName());
        }
    }

    @Test
    public void testGroupBy(){
        //查询每个部门 最低工资 > minsal,和最高工资
        String hql = "SELECT min(e.salary), max(e.salary) FROM Employee e GROUP BY e.dept HAVING min(salary) > :minsal";
        Query query = session.createQuery(hql);
        List<Object[]> objects = query.setFloat("minsal", 1000).list();
        for(Object[] objs : objects){
            System.out.println(Arrays.asList(objs));
        }
    }

    /***
     * 迫切左外链接  推荐使用
     * employees被初始化
     */
    @Test
    public void testLeftJoinFetch(){
        //SELECT DISTINCT -去除重复的元素
        String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN FETCH d.employees";
//      String hql2 = "FROM Department d LEFT JOIN FETCH d.employees";
        Query query = session.createQuery(hql);
        List<Department> departments = query.list();
        System.out.println(departments.size());
    }

    /***
     * 左外链接
     * employees没有被初始化，使用的时候会再去查
     */
    @Test
    public void testLeftJoin(){
        //SELECT DISTINCT -去除重复的元素
//      String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN d.employees";
//      Query query = session.createQuery(hql);
        String hql2 = "FROM Department d LEFT JOIN d.employees";
        Query query = session.createQuery(hql2);
        List<Object[]> departments = query.list();
        for(Object[] objects : departments){
            System.out.println(Arrays.asList(objects));
        }
    }

    /***
     * 内链接
     * employees没有被初始化，使用的时候会再去查
     */
    @Test
    public void testInnerJoin(){
        //SELECT DISTINCT -去除重复的元素
//      String hql = "SELECT DISTINCT d FROM Department d INNER JOIN d.employees";
//      Query query = session.createQuery(hql);
        String hql2 = "FROM Department d INNER JOIN d.employees";
        Query query = session.createQuery(hql2);
        List<Object[]> departments = query.list();
        for(Object[] objects : departments){
            System.out.println(Arrays.asList(objects));
        }
    }

    @Before
    public void init() {
        System.out.println("HibernateTest.init()");

        // 1.创建一个sessionFactory对象
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                .buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);

        // 2.创建一个session对象
        session = sessionFactory.openSession();

        // 3.开启事务
        transaction = session.beginTransaction();

    }

    @After
    public void destroy() {
        System.out.println("HibernateTest.destroy()");
        // 5.提交事务
        transaction.commit();
        // 6.关闭session
        session.close();
        // 7.关闭SessionFactory
        sessionFactory.close();

    }

}
Mr_LGZ
关注
专栏目录
Hibernate框架之HQL查询
hestyle的博客
11-20 579
在一篇博客 Hibernate框架之Query、Criteria、SQLQuery三个数据查询对象，介绍了Hibernate中的Query查询对象。Query对象使用的是一种面向对象类似SQL的HQL查询，HQL语法与SQL语法基本一致，本篇博客将进行HQL查询演示，并且会贴出对应的SQL语句。 一、创建基于Hibernate框架的Java项目 为了方便演示，数据库中将插入Customer、Ord...
hibernate连接mysql 反射_hibernate,hql_Hibernate HQL查询时 条件字段没有被反射成数据库表字段，hibernate,hql,java,数据库 - phpStud...
weixin_31908803的博客
01-19 181
Hibernate HQL查询时 条件字段没有被反射成数据库表字段业务场景非常简单：采用hibernate hql查询数据库。ps:为了隐私起见，关键类，表明用xxx代替，还请见谅下面是dao层方法：String queryString="from XXXX where bizSN=:bizsn";Query query=this.getSession().createQuery(querySt...
12-hibernate实战 多对一根据查询员工获取部门的信息
高调做事，低调做人！
02-24 1885
static Employee query(int empId) { Session session = null; Transaction transaction = null; try { session=HibernateUtil.getSession(); transaction=session.beginTransaction(); Employee emp
Hibernate04-HQL连接查询和Hibernate注解
weixin_43094361的博客
04-02 4254
一、使用HQL连接查询 和SQL查询一样，HQL也支持多种连接查询，如内连接查询、外连接查询。在SQL中可通过join子句实现多表之间的连接查询。HQL同样提供了连接查询机制，还允许显式指定迫切内连接和迫切左外连接。迫切连接是指不仅指定了连接查询方式，而且显式的指定了关联级别的查询策略。迫切连接使用fetch关键字实现，fetch关键字表明“左边”对象用来与“右边”对象关联的属性会立即被初始化。 ...
Hibernate5入门（五）查询方式之HQL
半清半醒半明白
08-14 3199
学习笔记，为了加强记忆和深入理解在此记录备忘。如有错误和理解不当之处，还望指正。万分感谢！ 另外，实例和内容有些是参照网络其他博文，如有侵权可联系删掉。 参考博客 地址：https://www.cnblogs.com/whgk/p/6159336.html 目录 一、导航对象图查询 二、OID查询 三、本地sql查询 四、hql查询 4.1 查询全部员工 4.2 查询员工编号是1...
Hibernate入门（7）：HQL查询
Al_assad的博客
09-08 1778
使用 Hibernate 进行 CURD 操作时候，插入、更新、删除操作可以直接通过对持久化实体（PO）实例来进行，对于查询操作，Hibernate 提供了以下3种方式来进行：HQL 查询；Criteria 条件查询（hibernate 5.x 已经废弃）；SQL 查询；以下示例代码中出现的 HibernateUtil 类是一个封装的Session管理类，详看：HibernateUtilHiber...
HQL排序查询 --- Hibernate入门学习之HQL数据库查询方式之二
༺清风暖云༻
08-28 516
叙：HQL是一个完全面向对象的数据库查询语言，提供有针对多种情况下的查询方式，之前已有一些已经学习并记录了，下面电虫就排序查询进行记录一下，后面的会继续学习； Hibernate的HQL查询之排序查询 其实排序查询只要在查询语句后边加上order by+排序属性名+desc/asc;就可以了，下面是代码展示： @Test /* * 排序查询 */ ...
Hibernate之HQL
weixin_60389087的博客
10-20 365
一、HQL入门 1、HQL的含义: HQL是Hibernate Query Language（专属于hibernate框架的一个查询语言）的缩写 2. hql和sql区别/异同 HQL SQL 类名/属性 ...
hibernate之HQL入门
hardly555的博客
08-05 197
1. 查询整个映射对象所有字段//直接from查询出来的是一个映射对象，即：查询整个映射对象所有字段 String hql = "from Users"; Query query = session.createQuery(hql); List<Users> users = query.list();
06_传智播客hibernate教程_完善HibernateUtil类及hql查询入门
11-24
本教程聚焦于“完善HibernateUtil类及HQL查询入门”，让我们深入探讨这两个关键概念。 首先，`HibernateUtil` 类是 Hibernate 教程中常见的一种工具类，它的主要作用是提供对 Hibernate 框架的简单封装，以方便进行...
Hibernate查询指南：HQL入门与应用
第二种是Hibernate Query Language（HQL），它是Hibernate提供的一种面向对象的查询语言，专门用于在ORM框架下进行数据查询。HQL的优势在于它将数据库查询语句与Java对象模型相结合，使得查询更加直观，同时也提高了...
Hibernate4查询语言HQL入门
Hibernate4查询语言（HQL）是一种基于对象关系映射（ORM）框架Hibernate的查询语言。它提供了一种类似于SQL的查询语法，用于在Hibernate中对持久化对象进行查询。 ## 1.2 HQL与SQL的区别 HQL与传统的SQL语言有一些...
在Hibernate4中，使用原生JDBC进行批操作
回不去的编程之路lgz
03-02 557
在hibernate中，一级缓存session和二级缓存，为编码提供了便利，同时也会有一些副作用。比如有批量插入或者更新操作的话，反而会降低效率。 解决方法：在hibernate中调用jdbc批量处理的API，使用原生的jdbc来进行批量操作。 public void setStatus(String arrMsgID[]) { //sql语句 String u...
Hibernate入门07_继承映射01_discriminator方式
回不去的编程之路lgz
06-02 528
一、映射继承三种方式1、discriminator方式，子类和父类公用一张表2、joined方式3、union方式二、以Student继承Person为例，先说第1种，后两种分别下一篇文章说及。三、代码public class Person { private Integer id; private String name; private String age; /
Hibernate入门07_继承映射03_union方式
回不去的编程之路lgz
06-04 479
一、hibernate继承映射之union方式union方式：子类从父类继承的字段和自己独有的字段都存放在自己的表里。 二、Student继承Person为例三、代码public class Person { private Integer id; private String name; private String age; //get/set... }publ
Hibernate入门01_HelloWord
回不去的编程之路lgz
05-29 402
Hibernate简介： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完
Hibernate入门10_二级缓存02_集合级别
回不去的编程之路lgz
06-07 389
一、测试项目目录二、代码public class Department { private Integer id; private String name; private Set<Employee> employees = new HashSet<>(); //get/set... } Department.hbm.xml<?xml version="1.0"?>
Hibernate入门02_Session
回不去的编程之路lgz
05-29 381
1、 News.java与上一遍文章一样import java.sql.Blob; import java.util.Date;public class News { private Integer id; private String title; private String author; private Date data; // 大文本 pr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值