HQL数据查询基础（三）

最新推荐文章于 2021-03-16 14:01:24 发布

葡萄干是个程序员

最新推荐文章于 2021-03-16 14:01:24 发布

阅读量657

点赞数

分类专栏： JavaEE 文章标签： intellij idea hibernate HQL HQL数据查询基础 HQL语句

本文链接：https://blog.csdn.net/qq_15096707/article/details/51459462

版权

JavaEE 专栏收录该内容

43 篇文章 2 订阅

订阅专栏

继上回（HQL数据查询基础（二）），针对“网上商店”这个例子，来讲解一些HQL简单的子句用法。

（以下的所有测试方法均在 MyTest.java 测试类（在上文上有提到）中添加）

from子句

1）HQL语句最简形式；

2）from指定了HQL语句查询主体——持久化类及其属性

from子句中持久化类的引用

1）不需要引入持久化类的全限定名，直接引入类名；

2）auto-import（自动引入）缺省情况。

测试from子句的使用——获取customer表中的所有客户信息：

<span style="font-size:18px;">@Test
    public void testFromClause1() {
        String hql = " from Customer ";
        //创建Query实例对象
        Query query = session.createQuery(hql);
        List<Customer> customers = query.list();

        for(Customer customer : customers) {
            System.out.println("name: " + customer.getName());
        }
    }</span>

测试能否通过商品对象获得商家信息：

<span style="font-size:18px;">/**
     * 测试能否通过 商品对象 获取 商家信息
     */
    @Test
    public void testFromClause2() {
        String hql = " from Commodity ";

        Query query = session.createQuery(hql);
        List<Commodity> commodities = query.list();

        for (Commodity c : commodities) {
            System.out.println("name: " + c.getName());
            System.out.println("seller's name: " + c.getSeller().getName());
        }
    }</span>

Hibernate中默认是“懒”加载状态，只有需要到某些关联信息才进行查询。在这个例子中，我们先查询到所有商品信息，根据商品信息获取商家信息，获取商家信息的时候Hibernate才发起查询，并不是在查询到商品信息的同时也查询了商家信息。Hibernate做了延迟加载。

from子句中别名的应用

1）为被查询的类指定别名；

2）在HQL语句其他部分通过别名引用该类；

3）别名命名习惯：一般与持久类类名相同，使用小写。如：from Seller 中 Seller 别名可以为 seller，为了简洁，别名也可以取名为 s。在简洁的同时，需要保证代码的可读性。

具体如： from Seller as seller 或 from Seller as s 或 from Seller seller 或 from Seller s（as 关键字可以省略）

select子句

1）select子句中未指定返回数据类型，默认为Object[]；（注意：当查询的字段只有一个时，返回的数据类型就不再是 Object[]，而是Object）

测试select子句的Object[] 返回数据类型：

<span style="font-size:18px;">/**
     * 1. name 2.tel 3.address 4.star
     */
    @Test
    public void testSelectClauseObjectArray() {
        String hql = "select s.name, s.tel, s.address, s.star from Seller s ";

        Query query = session.createQuery(hql);
        List<Object[]> list = query.list();

        for(Object[] objs : list) {
            System.out.println("name: " + objs[0]);
            System.out.println("tel: " + objs[1]);
            System.out.println("address: " + objs[2]);
            System.out.println("star: " + objs[3]);
        }

        System.out.println();
        System.out.println("特殊实例：");

        //如果查询的字段只有一个的话，那么其返回类型是 Object 而不是Object[]。
        String hql2 = "select s.name from Seller s ";

        Query query2 = session.createQuery(hql2);
        List<Object> list2 = query2.list();

        for(Object objs : list2) {
            System.out.println("name: " + objs);
        }
    }</span>

2）以List形式返回查询结果——select子句中使用new list指定；

测试select子句的 List 返回数据类型：

<span style="font-size:18px;">    @Test
    public void testSelectClauseList() {
        String hql = "select new list(s.name, s.tel, s.address) from Seller s";
        Query query = session.createQuery(hql);
        List<List> lists = query.list();

        for(List list : lists) {
            System.out.println("name: " + list.get(0));
            System.out.println("tel: " + list.get(1));
            System.out.println("address: " + list.get(2));

        }
    }</span>

3）以Map形式返回查询结果——select子句中使用new map指定，key值为索引值，字符串类型；

测试select子句的 Map返回数据类型：

<span style="font-size:18px;">    @Test
    public void testSelectClauseMap() {
        String hql = "select new map(s.name, s.tel, s.address) from Seller s";
        Query query = session.createQuery(hql);
        List<Map> maps = query.list();

        for(Map map : maps) {
            System.out.println("name: " + map.get("0"));
            System.out.println("tel: " + map.get("1"));
            System.out.println("address: " + map.get("2"));
        }

        //除了通过序号来获取查询结果外，还可以使用别名来获取
        String hql2 = "select new map(s.name as name, s.tel as tel, s.address as address) from Seller s";
        Query query2 = session.createQuery(hql2);
        List<Map> maps2 = query2.list();

        for(Map map : maps2) {
            System.out.println("name: " + map.get("name"));
            System.out.println("tel: " + map.get("tel"));
            System.out.println("address: " + map.get("address"));
        }
    }</span>

4）以自定义类型返回查询结果——持久化类中定义对应的构造器，构造器的参数就是我们选择返回的属性信息；select子句中调用定义的构造器来完成相应的查询，以自定义类型来返回查询的结果

测试select子句中以自定义类型返回查询结果：

需要我们在查询类中添加自定义的构造方法，本次查询的类为 Seller类，我们需要在Seller类中自定义构造方法，而构造方法中的参数就是我们需要查询返回的信息：

    public Seller(String name, String tel, String address) {
        this.name = name;
        this.tel = tel;
        this.address = address;
    }

测试方法如下：

@Test
    public void testSelectClauseSelf() {
        String hql = "select new Seller(s.name, s.tel, s.address) from Seller s";
        Query query = session.createQuery(hql);
        List<Seller> sellers = query.list();
        for(Seller seller :sellers) {
            System.out.println("name: " + seller.getName());
            System.out.println("tel: " + seller.getTel());
            System.out.println("address: " + seller.getAddress());
        }
    }

注：当我们自定义了构造方法之后，还需要定义无参的构造方法吗？答案是肯定的。我们先来回顾一下之前定义的一个测试方法testSeller：

    @Test
    public void testSeller() {
        String hql = " from Seller s";
        //创建Query实例对象
        Query query = session.createQuery(hql);
        List<Seller> sellers = query.list();

        for(Seller seller : sellers) {
            System.out.println(seller);
        }
    }

这里并未使用到select子句，那么默认返回的是所有Seller的所有属性信息，它此时调用的无参构造方法。如果我们不提供默认的无参构造方法的话，执行上面的测试方法，将出现没有找到 Seller 实体的错误提示。

所以我们需要在自定义构造方法后，在类中同样增加无参的构造方法。

distinct 关键字

使用distinct关键字去除查询结果中的重复元素

测试使用distinct关键字，消除结果集中重复的元素：

    @Test
    public void testDistinct() {
        String hql = "select distinct c.sex from Customer c";
        Query query = session.createQuery(hql);
        List<Object> list = query.list();
        for(Object obj : list) {
            System.out.println(obj);
        }
    }

where子句

我们可以通过where子句设置查询条件，限制返回结果。

（1）比较运算

1. = 、<> 、< 、> 、>= 、<=

2.null值判断——is [not] null，在HQL中可使用 = null 或 <> null 来表示 is [not] null

测试使用比较运算符：

    @Test
    public void testWhere1() {
        String hql = " from Commodity c where c.price > 400";
        Query query = session.createQuery(hql);
        List<Commodity> commodities = query.list();
        for(Commodity c : commodities) {
            System.out.println("name: " + c.getName());
            System.out.println("price: " + c.getPrice());
        }
    }

测试null值判断：

    @Test
    public void testWhere2() {
        //is null 的判断
        //String hql = " from Commodity c where c.description is null";
        //String hql = " from Commodity c where c.description = null";
        //is not null 的判断
        //String hql = " from Commodity c where c.description is not null";
        String hql = " from Commodity c where c.description <> null";

        Query query = session.createQuery(hql);
        List<Commodity> commodities = query.list();
        for(Commodity c : commodities) {
            System.out.println("name: " + c.getName());
            System.out.println("description: " + c.getDescription());
        }
    }

（2）范围运算

1. [not] in(列表)；

2. [not] between 值1 and 值2

测试：

    @Test
    public void testWhere3() {
        //String hql = " from Customer c where c.age in(20, 40)";
        //String hql = " from Customer c where c.age not in(20, 40)";
        //String hql = " from Customer c where c.age between 20 and 40";
        String hql = " from Customer c where c.age not between 20 and 40";
        Query query = session.createQuery(hql);
        List<Customer> customers = query.list();
        for(Customer c : customers) {
            System.out.println("name: " + c.getName());
            System.out.println("age: " + c.getAge());
        }
    }

（3）字符串模式匹配

1、like关键字；

2、通配符 %、_ （%：任意个字符；_：一个字符）

测试：

@Test
    public void testWhere4() {
        //String hql = " from Customer c where c.name like '张_'";
        String hql = " from Customer c where c.address like '%北京%'";
        Query query = session.createQuery(hql);

        List<Customer> customers = query.list();
        for(Customer c : customers) {
            System.out.println("name: " + c.getName());
            System.out.println("address: " + c.getAddress());
        }
    }

（4）逻辑运算

1、and（逻辑与）、or（逻辑或）

2、not（逻辑非）

测试：

    @Test
    public void testWhere5() {
        //String hql = " from Commodity c where c.price between 100 and 5000 and c.category like '%电脑%'";
        String hql = " from Commodity c where c.price between 100 and 5000 or c.category like '%电脑%'";
        Query query = session.createQuery(hql);
        List<Commodity> commodities = query.list();
        for(Commodity c : commodities) {
            System.out.println("name: " + c.getName());
            System.out.println("category: " + c.getCategory());
            System.out.println("price: " + c.getPrice());
        }
    }

（5）集合运算

1、is [not] empty 集合[不]为空，不包含任何元素；

2、member of 元素属于集合；

测试：

    @Test
    public void testWhere6() {
        //查询订单信息不为空的有效订单
        String hql = " from Order o where o.orderItems is not empty";
        Query query = session.createQuery(hql);
        List<Order> orders = query.list();
        for(Order order : orders) {
            System.out.println(order.getCustomer().getName());
            System.out.println(order.getAmount());
            System.out.println(order.getTradeDate());
        }
    }

（6）四则运算

1、HQL语句中也可以使用 + - x / 四则运算

2、四则运算可以在where子句和select子句中使用

测试：

    @Test
    public void testWhere7() {
        String hql = " from Commodity c where c.price * 5 > 3000";
        Query query = session.createQuery(hql);
        List<Commodity> commodities = query.list();
        for(Commodity c : commodities) {
            System.out.println("name: " + c.getName());
            System.out.println("price: " + c.getPrice() * 5);
        }
    }

（7）查询单个对象

1、Query接口的uniqueResult方法；

2、where子句条件的设置，我们需要确保where子句设置的条件查询出来的结果只有一条数据或没有数据，否则使用uniqueResult方法过程中会抛出异常 org.hibernate.NonUniqueResultException: query did not return a unique result，中止运行。

测试：

    @Test
    public void testWhere8() {
        //String hql = " from Customer c where c.name = '张三'";
        String hql = " from Customer c where c.age > 20";
        Query query = session.createQuery(hql);

        Customer c = (Customer) query.uniqueResult();
        System.out.println(c.getName());
    }

排序——order by子句

使用order by子句对查询结果排序

1、升序排序 asc；2、降序排序 desc；

测试：

    @Test
    public void testOrderBy() {
        //String hql = " from Commodity order by price asc";
        //String hql = " from Commodity order by price desc";
        String hql = " from Commodity order by seller.id asc, price desc, name asc";
        Query query = session.createQuery(hql);
        List<Commodity> commodities = query.list();
        for(Commodity c : commodities) {
            System.out.println("name: " + c.getName());
            System.out.println("sellerId: " + c.getSeller().getId());
            System.out.println("sellerName: " + c.getSeller().getName());
            System.out.println("price: " + c.getPrice());
        }
    }

葡萄干是个程序员

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HQL数据查询基础（三）

继上回（HQL数据查询基础（二）），针对“网上商店”这个例子，来讲解一些HQL简单的子句用法。（以下的所有测试方法均在 MyTest.java 测试类（在上文上有提到）中添加）from子句1）HQL语句最简形式；2）from指定了HQL语句查询主体——持久化类及其属性from子句中持久化类的引用1）不需要引入持久化类的全限定名，直接引入类名；
复制链接

扫一扫

专栏目录