当前位置： 首页 > article >正文

Hibernate查询的方法

article 2024/12/23 22:50:59

Hibernate查询的方法

一：hibernate多记录查询

1、原生SQL（Native SQL）查询
2、QBC查询
3、HQL查询

1、原生SQL（Native SQL）查询

session并没有提供直接查询多条记录的方法，但提供了间接查找多条记录的对象
通过session.createNativeQuery()获得query对象，该对象可以执行sql语句完成查询操作

2、QBC查询（Query By Criteria）

语法和机制上（对表的操作变成对对象的操作）都符合面向对象特点
注意：hibernate5.2以后，QBC就不推荐使用，因为在hibernate架构中引入了JPA
通过session.createCriteria(对象)或query.getSingleSelect(); 获得Criteria查询对象，获的Criteria对象的同时也指定了查询目标，Car类对应的表t_car
使用criteria.list() 执行查询操作，返回的查询结果中每条记录组成Car对象

 /**
     * QBC查询  criteria.list()
     */
    public void find2(){
        Session session=HibernateUtil.getSession();
        Criteria criteria= session.createCriteria(Car1.class);
        List<Car1> carList=criteria.list();
        for(Car1 car1:carList){
            System.out.println(car1);
        }
        
    }

2、QBC的过滤查询

 Session session=HibernateUtil.getSession();
       Criteria criteria=session.createCriteria(Car1.class);
       //比较运算符 过滤
        criteria.add(Restrictions.eq("cno",1));//相当于where cno = 1
        criteria.add(Restrictions.ne("cno",1));//相当于where cno!=1
        criteria.add(Restrictions.gt("cno",1));//相当于where cno>1
        criteria.add(Restrictions.lt("cno",1));//相当于where cno<1
        criteria.add(Restrictions.ge("cno",1));//相当于where cno>=1
        criteria.add(Restrictions.le("cno",1));//相当于where cno<=1
      
       //用isNull 或 isNotNull过滤
        criteria.add(Restrictions.isNull("cname"));//where cname==null
        criteria.add(Restrictions.isNotNull("cname"));//where cname!=null
 
        //模糊查询 过滤
        criteria.add(Restrictions.like("cname","%b%"));//相当于where cname like '%b%'
        
        //betWeen（在什么之间的）过滤（区间）
        criteria.add(Restrictions.between("price",2000000,500000));//相当于where price between 20万 and 30万
        
        //in在20，25，30里面的过滤（点）
        criteria.add(Restrictions.in("price",20,25,30));//相当于where price in (20,25,30)
        
         //用and 过滤
criteria.add(Restrictions.and(Restrictions.eq("color","red"),Restrictions.lt("price",3000))); //where color='red' and price<3000 
     
      //or 过滤
criteria.add(Restrictions.or(Restrictions.eq("color","red"),Restrictions.lt("price",3000))); //where color='red' or price<3000 

//注意当连续使用两次add增加过滤条件，自动就是and 如：
        criteria.add(Restrictions.eq("cno",1));//相当于where cno = 1
        criteria.add(Restrictions.eq("color","red"));       
 List<Car1> carList=criteria.list();

3、QBC的排序查询

 /**
     * QBC排序查询
     */
    public void find(){
        Session session=HibernateUtil.getSession();
        Criteria criteria=session.createCriteria(Car1.class);
        criteria.addOrder(Order.desc("price"));//按照price进行降序   相当于order by price desc
        criteria.addOrder(Order.asc("color"));//按照price进行降序再按照color进行升序   相当于按照price进行升序   相当于order by price desc,color asc
        //注意：设置两次排序，自然就是安照两个添加排序
        List<Car1> carList=criteria.list();
    }

注意：设置两次排序，自然就是安照两个添加排序
4、QBC的分页查询

 /**
     * QBC分页查询
     */
    public void find5(){
        Session session=HibernateUtil.getSession();
        Criteria criteria=session.createCriteria(Car1.class);
        criteria.setFirstResult(1);//起始索引
        criteria.setMaxResults(10);//每页显示长度
        List<Car1> carList=criteria.list();
    }

注意：这个分页使用所有的数据库
5、QBC的分组查询
字段投影：只查询表中部分字段的数据，如：select cname,color form t_car;
聚合函数：avg();sum();max();min()；count()等

 /**
     * QBC字段投影和聚合函数
     */
    public void find6(){
        Session session=HibernateUtil.getSession();
        Criteria criteria=session.createCriteria(Car1.class);
        //做字段投影
        criteria.setProjection(Projections.projectionList()
                .add(Projections.property("cname"))
                .add(Projections.property("color")).add(Projections.sum("price")));//相当于select cname,color,sum(price) form t_car
      List list =criteria.list();
    }

注意：投影以后，每条记录字段的信息就无法组成对象，最终组成Object数组
分组：

/**
     * QBC分组
     */
    public void find7(){
        Session session=HibernateUtil.getSession();
        Criteria criteria=session.createCriteria(Car1.class);
        //分组
        criteria.setProjection(Projections.projectionList()
                .add(Projections.groupProperty("color"))//按照颜色分组
        .add(Projections.count("cno"))
        .add(Projections.max("price"))
        .add(Projections.min("price").as("minPrice")));
        //相当于：select color,count(cno),max(price),min(price) as minPrice form t_car group by color;
        List list =criteria.list();
    }

6、QBC的子查询
离线查询：子表
DetachedCriteria criteria1=DetachedCriteria.forClass(Car1.class);
criteria1.setProjection(Projections.avg(“price”));//相当于:select avg(price) form t_car;

 /**
     * QBC子查询
     */
    public void find8(){
        Session session=HibernateUtil.getSession();
        Criteria criteria=session.createCriteria(Car1.class);
        //离线查询
        DetachedCriteria criteria1=DetachedCriteria.forClass(Car1.class);
        criteria1.setProjection(Projections.avg("price"));//相当于:select avg(price) form t_car;

        criteria.add(Property.forName("price").gt(criteria1));
        //相当于：select * form t_car where price>(select avg(price) form t_car)
        List list =criteria.list();
    }

7、QBC的关联查询
HIbernate有一个非常强大的功能，就是关联关系处理，需要在ORM配置文件中配置两个对象之间的关联关系，在QBC查询时会自动关联

3、HQL查询

类似sql语法，面向对象机制的查询方式；简单的理解为将sql中的表换成实体，将sql中的字段换成属性，如：
sql：select * from t_tar where cno=?
hql：select * from Car where cno=?
注意：实际上上述hql语句是错误的，正确语句如下：
from Car where cno=?;
注意：hql中也可以使用select 查询部分属性

通过session.createQuery()方法获得hql查询的Query对象
Query query= session.createQuery(“from Car”);
使用query.list()或query.getSingleSelect()执行查询操作，查询的结果会自动组成对象

  /**
     * HQL查询
     */
    public void find9(){
        Session session=HibernateUtil.getSession();
       Query query= session.createQuery("from Car");
        List<Car1> car1s=  query.list();
    }

1、 HQL预处理传参：两种方式
第一种：from car where price >?1 注意：问号后面必须带数字
query.setParameter(1,2000);
第二种：from car where price > :price
query.setParameter(“price”,2000);

    /**
     * HQL 过滤查询
     */
    public void find10(){
        Session session=HibernateUtil.getSession();
        Query query= session.createQuery("from Car where price > ?1");
        query.setParameter(1,300000);
        List<Car1> car1s=  query.list();
    }

2、HQL分页查询

 /**
     * HQL 分页查询
     */
    public void find11(){
        Session session=HibernateUtil.getSession();
        Query query= session.createQuery("from Car where price >:price");
        query.setParameter("price",300000);
        query.setFirstResult(1);//从那条开始
        query.setMaxResults(2);//一页显示几条
        List<Car1> car1s=  query.list();
    }

3、HQL的投影和分组查询

/**
     * HQL 投影和分组查询
     */
    public void find12(){
        Session session=HibernateUtil.getSession();
        Query query= session.createQuery("select color,cout(cno) from Car group by color");
        List car1s=  query.list();
    }

4、扩展：HQL的关联查询
hql有两种关联查询的情况
第一种：逻辑关系：使用hql语句表现两个表的关联关系；如：
from emp e ,Dept d where e.dno = d.dno;
注意：

  1. 不能使用join关联语法 2、查询结果是：List<Object[] {Emp,Dept}>

第二种：物理关联：后面再hibernate关联关系讲解时，需要再ORM中配置关系
物理关系就是：查询单个实体时，自动查询关联实体数据，只需要from emp 进行查询就可以查出关联信息

5、扩展：hql的批量删除和批量修改，类似与编写sql形式的hql删除/修改如：
update Car set price=price+1000;
delete from Car where cno=?1;
然后使用query.executeUpdate()；方法执行增删改操作；注意事务

 /**
     * HQL 批量修改操作
     */
    public void find13(){
        Session session=HibernateUtil.getSession();
        Query query= session.createQuery("update Car set price=price+11000");
        session.beginTransaction();//开始事务
        query.executeUpdate();
        session.getTransaction().commit();//提交事务
    }

4、扩展：JPA查询

1、需要创建CriteriaBuilder对象，构建查询模式
CriteriaBuilder builder=session.getCriteriaBuilder();
2、获得查询对象CriteriaQuery
CriteriaBuilder builder=session.getCriteriaBuilder();
注意：Car.class类型，表示查询结果组成的对象类型
3、获得目标对象Root
Root《Car1》 table=query.from(Car1.class);
4、构建查询
query.select(table);相当于 select * from t_car;
5、执行查询
List cars= session.createQuery(query).list();
Car1 car1= session.createQuery(query).getSingleResult();

 /**
     * API查询
     */
    public void find14(){
        Session session=HibernateUtil.getSession();
        //1、需要创建CriteriaBuilder对象，构建查询模式
        CriteriaBuilder builder=session.getCriteriaBuilder();
        //2、获得查询对象CriteriaQuery
        CriteriaQuery<Car1> query=builder.createQuery(Car1.class);
        //3、获得目标对象Root
        Root<Car1> table=query.from(Car1.class);
        //4、构建查询
        query.select(table);//相当于 select * from t_car;
        //5、执行查询
        List<Car1> cars= session.createQuery(query).list();
         Car1 car1= session.createQuery(query).getSingleResult();
    }

1、JAP过滤查询

 /**
     * JAP过滤查询
     */
    public void find15(){
        Session session=HibernateUtil.getSession();
        //1、需要创建CriteriaBuilder对象，构建查询模式
        CriteriaBuilder builder=session.getCriteriaBuilder();
        //2、获得查询对象CriteriaQuery
        CriteriaQuery<Car1> query=builder.createQuery(Car1.class);
        //3、获得目标对象Root
        Root<Car1> table=query.from(Car1.class);
        //4、构建查询
        query.select(table).where(builder.notEqual(table.get("cno"),1));//相当于 select * from t_car where cno!=1;
        //5、执行查询
        List<Car1> cars= session.createQuery(query).list();
        Car1 car1= session.createQuery(query).getSingleResult();
    }

在这里插入图片描述
query.select(table).where(builder.notEqual(table.get(“cno”),1));其余方法用builder点就出来了
2、JPA排序查询

 /**
     * JAP排序查询
     */
    public void find16(){
        Session session=HibernateUtil.getSession();
        //1、需要创建CriteriaBuilder对象，构建查询模式
        CriteriaBuilder builder=session.getCriteriaBuilder();
        //2、获得查询对象CriteriaQuery
        CriteriaQuery<Car1> query=builder.createQuery(Car1.class);
        //3、获得目标对象Root
        Root<Car1> table=query.from(Car1.class);
        //4、构建查询
        query.select(table);
        query.orderBy(builder.desc(table.get("price")),builder.asc(table.get("cno")));
        //5、执行查询
        List<Car1> cars= session.createQuery(query).list();
        Car1 car1= session.createQuery(query).getSingleResult();
    }

3、JAP分页查询

 /**
     * JAP分页查询
     */
    public void find17(){
        Session session=HibernateUtil.getSession();
        //1、需要创建CriteriaBuilder对象，构建查询模式
        CriteriaBuilder builder=session.getCriteriaBuilder();
        //2、获得查询对象CriteriaQuery
        CriteriaQuery<Car1> query=builder.createQuery(Car1.class);
        //3、获得目标对象Root
        Root<Car1> table=query.from(Car1.class);
        //4、构建查询
        query.select(table);
        //5、执行分页查询
        List<Car1> cars= session.createQuery(query).setFirstResult(2).setMaxResults(3).list();

    }

4、JAP分组查询
投影查询（查询部分字段）：注意投影查询的部分字段不能组成完整的Car对象，需要为投影字段专门定义一个类对象（再单独写一个投影字段的类）设置CriteriaQuery的泛型为新类型Car2
CriteriaQuery《Car2》query=builder.createQuery(Car2.class);
构建查询时，不再使用query.select()方法，而是如下方法：
query.multiselect(table.get(“cname”),table.get(“color”));
List《Car2》 cars= session.createQuery(query).list();
基于投影查询的聚合查询
分组查询
5、JPA子查询


http://www.kler.cn/a/137093.html

相关文章：

  • vue2使用render，js中写html
  • airflow docker 安装
  • postman读取文件执行
  • 靜態IP與DHCP的區別和用法
  • 全脐点曲面当且仅当平面或者球面的一部分
  • Python中的上下文管理器：从资源管理到自定义实现
  • 维基百科文章爬虫和聚类【二】：KMeans
  • py Selenium来启动多个浏览器窗口或标签页，并操作它们
  • 回顾以前的java
  • 泗博MODBUS转PROFINET网关助力电子天平与西门子PLC无缝对接
  • 679 - Dropping Balls （UVA）
  • vue3定时器的清除
  • （论文阅读51-57）图像描述3 53
  • 【django+vue】连接数据库、登录功能
  • java中stream常用api介绍
  • 鸿蒙原生应用/元服务开发-AGC分发如何配置版本信息（上）
  • Python try except 用法
  • Linux ps -ef|grep去除 grep --color=auto信息
  • windows对话框
  • 字节8年经验之谈 —— 10大自动化测试框架总结！
  • 深入 Django 的 URL 分发器
  • 国产化区块链平台-FISCO BCOS 区块链
  • 代码随想录算法训练营第25天|216.组合总和III 17.电话号码的字母组合
  • 关于“研发效能冷思考”的冷思考 | IDCF
  • 【Linux】 线程
  • CSS中常用的伪元素选择器