首页 > 代码库 > Hibernate检索方式概述

Hibernate检索方式概述

Hibernate检索方式概述

我们在对数据库的操作中,最常用的是select,那么使用Hibernate如何进行select操作呢?本文就来徐徐道来。
Hibernate检索方式可分为5种:

  1. 导航对象图检索方式,根据已加载的对象导航到其它对象。
  2. OID检索方式,按照对象的OID来检索对象。
  3. HQL检索方式,使用面向对象的HQL查询语言。
  4. QBC检索方式,使用QBC(Query by Criteria)API来检索对象,这种API封装了基于字符串形式的查询语句,提供了更加面向对象的查询接口。
  5. 本地SQL检索方式,使用本地数据库的SQL查询语句。

导航对象图检索方式

导航对象图检索这种方式我们也是经常用的,例如:

Customer c = session.get(Customer.class, 2);
System.out.println(c.getOrders().size());

所谓的导航对象图检索方式就是通过在Hibernate中进行映射关系,然后在Hibernate操作时,可以通过导航方式得到其关联的持久化对象信息。

OID检索方式

OID检索这种检索方式我们用的也是比较多的,例如:

session.get(Customer.class, 3);
session.load(Order.class, 1);

Hibernate中通过get/load方法查询指定的对象要通过OID来查询。

HQL

HQL是我们在Hibernate中最常用的一种检索方式。HQL(Hibernate Query Language)提供了更加丰富灵活、更为强大的查询能力,因此Hibernate将HQL查询方式立为官方推荐的标准查询方式,HQL查询在涵盖Criteria查询的所有功能的前提下,提供了类似标准SQL语句的查询方式,同时也提供了更加面向对象的封装。完整的HQL语句形式如下: select/update/delete…… from …… where …… group by …… having …… order by …… asc/desc 其中的update/delete为Hibernate3中所新添加的功能,可见HQL查询非常类似于标准SQL查询。HQL检索的基本步骤:

  1. 得到Session
  2. 编写HQL语句
  3. 通过session.createQuery(hql)创建一个Query对象
  4. 为Query对象设置条件参数
  5. 执行list()查询所有,它返回的是一个List集合或者执行uniqueResult()返回一个查询结果

数据准备

首先肯定是搭建好Hibernate的开发环境啦,我在此也不过多赘述,读者自行实践。接着在src目录下创建一个cn.itheima.domain包,并在该包下创建两个实体类,分别是客户类(Customer)和订单类(Order),而且这两个实体类都使用注解配置,所以就不用编写那个映射配置文件啦!

  • 客户类(Customer)

    // 客户 ---- 一的一方
    @Entity
    @Table(name="t_customer")
    public class Customer {
    
        @Id
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Integer id; // 主键
        private String name; // 姓名
    
        // 描述客户可以有多个订单
        /*
         * targetEntity="...":相当于<one-to-many class="...">
         * mappedBy="...":相当于inverse=true,即放弃关联关系的维护,不然会生成一个中间表
         */
        @OneToMany(targetEntity=Order.class,mappedBy="c")
        private Set<Order> orders = new HashSet<Order>();
    
        public Customer() {
    
        }
    
        public Customer(Integer id, String name) {
            super();
            this.id = id;
            this.name = name;
        }
    
        public Set<Order> getOrders() {
            return orders;
        }
        public void setOrders(Set<Order> orders) {
            this.orders = orders;
        }
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Customer [id=" + id + ", name=" + name + ", orders=" + orders + "]";
        }
    
    }
  • 订单类(Order)

    // 订单 ---- 多的一方
    @Entity
    @Table(name="t_order")
    public class Order {
    
        @Id
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Integer id;
        private Double money;
        private String receiverInfo; // 收货地址
    
        // 订单与客户关联
        @ManyToOne(targetEntity=Customer.class)
        @JoinColumn(name="c_customer_id") // 指定外键列
        @Cascade(CascadeType.SAVE_UPDATE)
        private Customer c; // 描述订单属于某一个客户
    
        public Customer getC() {
            return c;
        }
        public void setC(Customer c) {
            this.c = c;
        }
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public Double getMoney() {
            return money;
        }
        public void setMoney(Double money) {
            this.money = money;
        }
        public String getReceiverInfo() {
            return receiverInfo;
        }
        public void setReceiverInfo(String receiverInfo) {
            this.receiverInfo = receiverInfo;
        }
    
        @Override
        public String toString() {
            return "Order [id=" + id + ", money=" + money + ", receiverInfo=" + receiverInfo + "]";
        }
    
    }

编写完以上两个实体类之后,我们可千万不要忘记了下面这一步:我们最终需要在hibernate.cfg.xml文件中将我们类中的注解配置引用生效。即需要在Hibernate核心配置文件中添加如下配置:

<mapping class="cn.itheima.domain.Customer"/>
<mapping class="cn.itheima.domain.Order"/>

接下来,我就来准备一些数据,不然查什么呢?我是这样做的,添加武松和潘金莲两个客户,每个客户都下10个订单,又因为我在订单类中做了级联操作,所以一旦订单关联了客户,那么保存订单时,就会顺便保存客户。怎么做到呢?在src目录下新建一个cn.itheima.test包,在该包下编写一个HQLTest单元测试类,并在该包下编写如下方法:

public class HQLTest {

    // 准备数据(2个Customer,每一个Customer有10个Order)
    @Test
    public void test1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        /*
        // 操作
        Customer c = new Customer();
        c.setName("武松");

        for (int i = 0; i < 10; i++) {
            Order order = new Order();
            order.setMoney(1000d + i * 10);
            order.setReceiverInfo("北京");
            order.setC(c);
            session.save(order);
        }
        */

        Customer c = new Customer();
        c.setName("潘金莲");

        for (int i = 0; i < 10; i++) {
            Order order = new Order();
            order.setMoney(2000d + i * 10);
            order.setReceiverInfo("上海");
            order.setC(c);
            session.save(order);
        }

        session.getTransaction().commit();
        session.close();
    }
}

测试以上方法之后,我们所想要的数据就准备好了,下面就正式进入正题。

基本检索

基本检索就是from 类名,from是关键字,后面是类名,关键字是不区分大小写的,但是类名是区分的。以码明示,在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 基本检索
    @Test
    public void test2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.编写HQL语句
        String hql = "from Customer"; // from是关键字,后面是类名,关键字是不区分大小写的,但是类名是区分的
        // 2.通过session.createQuery(hql)去把HQL语句作为参数传递
        Query query = session.createQuery(hql);
        // 3.通过list方法得到数据
        // List<Customer> list = query.list();

        // Hibernate在操作时还支持链式编程,如下:
        List<Customer> list = session.createQuery(hql).list();
        System.out.println(list.get(0));

        session.getTransaction().commit();
        session.close();
    }

}

从上可知Hibernate在操作时还支持链式编程,即session.createQuery(hql).list()

排序检索

现在我们的需求是查询订单时,根据订单的价格进行降序排序。以码明示,在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 排序检索——查询订单,根据订单的价格进行排序
    @Test
    public void test3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.定义HQL语句
        String hql = "from Order order by money desc"; // desc:降序,默认是asc(升序)
        // 2.执行hql语句,根据价格进行排序
        List<Order> list = session.createQuery(hql).list();

        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

条件检索

我首先来讲根据位置来绑定hql语句参数的条件检索。以码明示,在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 条件查询
    @Test
    public void test4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1根据位置来绑定参数
        // 1.1创建hql语句
        String hql = "from Order where money > ?";

        // 1.2执行hql语句
        List<Order> list = session.createQuery(hql).setParameter(0, 2000d).list();
        // 可以使用例如setString()、setDouble这样的方法来添加参数,参数的序号是从0开始

        session.getTransaction().commit();
        session.close();
    }

}

接着来讲根据名称来绑定hql语句参数的条件检索,将以上test4方法修改为:

public class HQLTest {

    // 条件查询
    @Test
    public void test4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 2.根据名称来绑定
        // 1.1创建hql语句
        String hql = "from Order where money > :mymoney";

        // 1.2执行hql语句
        List<Order> list = session.createQuery(hql).setParameter("mymoney", 2000d).list();

        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

分页检索

现在我们的需求是查询订单时,每页显示6条数据,我们要得到第二页的数据。以码明示,在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 分页检索
    @Test
    public void test5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Order");
        // 每页显示6条数据,我们要得到第二页数据
        query.setFirstResult((2 - 1) * 6); // 设定开始位置
        query.setMaxResults(6); // 设置条数

        List<Order> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

分组统计检索

先看我们的第一个需求:统计一共有多少个订单。以码明示,在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 分组统计操作
    @Test
    public void test6() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 统计操作——统计一共有多少订单(count)
        String hql = "select count(*) from Order";

        Object count = session.createQuery(hql).uniqueResult();
        System.out.println(count);

        session.getTransaction().commit();
        session.close();
    }

}

再看我们的第二个需求:分组统计每一个人的订单总价。那么以上test6方法应修改为:

public class HQLTest {

    // 分组统计操作
    @Test
    public void test6() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 分组统计——每一个人的订单总价()
        String hql = "select sum(money) from Order group by c";
        List list = session.createQuery(hql).list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

投影检索

这儿我也只是主要讲解关于实体类中部分属性的查询,这样我们可以使用投影检索将部分属性封装到对象中。下面我步步为营地讲解投影检索。开始,我们的需求可能是这样的:查询出所有Customer的name,故我们可能会在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 投影查询
    @Test
    public void test7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.查询出所有的Customer的name
        String hql = "select name from Customer";

        List list = session.createQuery(hql).list();
        System.out.println(list); // [武松, 潘金莲]

        // 如果只查询一个列,得到的结果是List<Object>

        session.getTransaction().commit();
        session.close();
    }

}

运行以上方法,输出[武松, 潘金莲],则可以得出结论:如果只是查询一个列,那么得到的结果是List<Object>
接着我们的需求又可能会变成这样:查询所有Customer的id、name。故我们可能会在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 投影查询
    @Test
    public void test7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 2.查询所有的Customer的id, name
        String hql = "select id,name from Customer";
        List list = session.createQuery(hql).list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

运行以上方法,输出[[Ljava.lang.Object;@592e843a, [Ljava.lang.Object;@1d1f7216],则说明如果是查询多列,那么得到的结果是List<Object[]>。故可将以上test7方法改为:

public class HQLTest {

    // 投影查询
    @Test
    public void test7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 2.查询所有的Customer的id, name
        String hql = "select id,name from Customer";
        List<Object[]> list = session.createQuery(hql).list();
        for (Object[] objs : list) {
            for (Object obj : objs) {
                System.out.print(obj + "   ");
            }
            System.out.println();
        }
        // 如果是查询多列,得到的结果是List<Object[]>

        session.getTransaction().commit();
        session.close();
    }

}

运行以上方法,输出:

1 武松
2 潘金莲

最后我们可想到使用投影查询将查询的结果封装到Customer对象中。故可将以上test7方法改为:

public class HQLTest {

    // 投影查询
    @Test
    public void test7() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 3.使用投影查询将查询的结果封装到Customer对象中
        String hql = "select new Customer(id,name) from Customer"; // 必须在PO类中提供对应的构造方法
        List<Customer> cs = session.createQuery(hql).list();
        System.out.println(cs);

        session.getTransaction().commit();
        session.close();
    }

}

注意:我们必须在PO类中提供对应属性的构造方法,也要有无参数构造。

命名检索

现在我就来讲命名检索了,我们可以将HQL语句先定义出来,在使用时通过session.getNamedQuery(hqlName);得到一个Query对象,然后再执行检索。那么问题就来了,这个HQL语句到底定义在什么位置呢?答案如下:

  1. 如果你有hbm映射配置文件,那么当前的hql操作是针对哪一个实体进行操作的,就在哪一个实体的映射配置文件中进行声明。声明如下:

    <query name="myHql">
        from Customer
    </query>
  2. 如果是使用注解来描述PO类的配置,那么我们可直接在PO类中使用@NamedQuery注解来声明。例如:

    @Entity
    @Table(name="t_customer")
    @NamedQuery(name="myHql", query="from Customer")
    public class Customer {
        ......
    }

第一种方式我就不讲了,专讲第二种方式。在Customer实体类中使用@NamedQuery注解,如下:

// 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
@NamedQuery(name="myHql", query="from Customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    /*
     * targetEntity="...":相当于<one-to-many class="...">
     * mappedBy="...":相当于inverse=true,即放弃关联关系的维护,不然会生成一个中间表
     */
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

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

}

此时我们是准备查询所有客户的,以码明示,在HQLTest单元测试类中编写如下单元测试方法:

public class HQLTest {

    // 命名查询
    @Test
    public void test8() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Query query = session.getNamedQuery("myHql");
        List<Customer> list = query.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }   

}

运行以上方法,不仅查询出了客户的基本信息,还查询出了客户下的所有订单。
现在我们有了这么一个需求:查询【武松】这个客户的所有订单。解决方法如下:

  1. 在Order实体类中使用@NamedQuery注解,如下:

    // 订单 ---- 多的一方
    @Entity
    @Table(name="t_order")
    @NamedQuery(name="findOrderByCustomer", query="from Order where c = :c")
    public class Order {
    
        @Id
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Integer id;
        private Double money;
        private String receiverInfo; // 收货地址
    
        // 订单与客户关联
        @ManyToOne(targetEntity=Customer.class)
        @JoinColumn(name="c_customer_id") // 指定外键列
        @Cascade(CascadeType.SAVE_UPDATE)
        private Customer c; // 描述订单属于某一个客户
    
        public Customer getC() {
            return c;
        }
        public void setC(Customer c) {
            this.c = c;
        }
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public Double getMoney() {
            return money;
        }
        public void setMoney(Double money) {
            this.money = money;
        }
        public String getReceiverInfo() {
            return receiverInfo;
        }
        public void setReceiverInfo(String receiverInfo) {
            this.receiverInfo = receiverInfo;
        }
    
        @Override
        public String toString() {
            return "Order [id=" + id + ", money=" + money + ", receiverInfo=" + receiverInfo + "]";
        }
    
    }
  2. 在HQLTest单元测试类中编写如下单元测试方法:

    public class HQLTest {
    
        // 命名查询
        @Test
        public void test9() {
            Session session = HibernateUtils.openSession();
            session.beginTransaction();
    
            // 1.我要查询武松这个客户的订单
            Customer c = session.get(Customer.class, 1);
    
            Query query = session.getNamedQuery("findOrderByCustomer");
            // 现在hql语句里面的参数是一个实体,那么我们在操作它时怎么办?
            List<Order> list = query.setEntity("c", c).list();
    
            System.out.println(list);
    
    
            session.getTransaction().commit();
            session.close();
        }   
    
    }

QBC

QBC(query by criteria),它是一种更加面向对象的检索方式。使用QBC检索的步骤为:

  1. 通过Session的createCriteria方法得到一个Criteria对象,即session.createCriteria()
  2. 设定条件,每个Criterion实例就代表一个条件,它的获取可以通过Restrictions类提供的静态方法得到,然后可通过Criteria的add方法添加查询条件
  3. 调用Criterion的list方法进行查询,即criterion.list()

基本检索

有一个需求:查询所有的Customer对象。以码明示,在cn.itheima.test包下编写一个QBCTest单元测试类,并在改类中编写如下测试方法:

public class QBCTest {

    // 基本检索
    @Test
    public void test1() {
        // 查询所有的Customer对象
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.得到Criteria对象
        Criteria criteria = session.createCriteria(Customer.class);

        // 2.调用list方法得到List集合
        List<Customer> list = criteria.list();

        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

排序检索

有这样一个需求:查询订单信息,并根据订单的价格进行排序。以码明示,在QBCTest单元测试类中编写如下测试方法:

public class QBCTest {

    // 排序检索
    @Test
    public void test2() {
        // 查询订单信息,根据订单的价格进行排序
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Criteria criteria = session.createCriteria(Order.class);
        // 指定排序
        // criteria.addOrder(org.hibernate.criterion.Order.desc("money")); // 降序排序
        criteria.addOrder(org.hibernate.criterion.Order.asc("money")); // 升序排序

        List<Order> list = criteria.list();

        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

条件检索

有这样一个需求:查询名称叫武某(武_)的客户。 以码明示,在QBCTest单元测试类中编写如下测试方法:

public class QBCTest {

    // 条件检索
    @Test
    public void test3() {

        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.查询名称叫武某的客户   武_
        Criteria criteria = session.createCriteria(Customer.class);
        Criterion like = Restrictions.like("name", "武_");
        criteria.add(like); // 添加条件
        /*
         * 其他条件:
         * lt:<
         * gt:>
         * le:<=
         * ge:>=
         * eq:==
         */
        Customer c = (Customer) criteria.uniqueResult();
        System.out.println(c);

        session.getTransaction().commit();
        session.close();

    }

}

现在又有这样一个需求:查询订单价格在1050以上的订单,并且它的客户是武某。以码明示,将QBCTest单元测试类中的test3方法修改为:

public class QBCTest {

    // 条件检索
    @Test
    public void test3() {

        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 2.查询订单价格在1050以上的订单,并且它的客户是武某
        Criteria cri = session.createCriteria(Order.class);

        SimpleExpression lt = Restrictions.gt("money", 1050d);
        SimpleExpression eq = Restrictions.eq("c", c);
        LogicalExpression and = Restrictions.and(lt, eq);
        cri.add(and);
        List<Order> orders = cri.list();

        // 上面代码写的非常臃肿,可简化为
        // List<Order> orders = cri.add(Restrictions.and(Restrictions.gt("money", 1050d), Restrictions.eq("c", c))).list();

        System.out.println(orders);

        session.getTransaction().commit();
        session.close();

    }

}

分页检索

有这样一个需求:查询订单时,每页显示6条数据,我们要得到第二页的数据。以码明示,在QBCTest单元测试类中编写如下单元测试方法:

public class QBCTest {

    // 分页检索
    @Test
    public void test4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Criteria criteria = session.createCriteria(Order.class);
        criteria.setFirstResult((2 - 1) * 6);
        criteria.setMaxResults(6);
        List<Order> list = criteria.list();

        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }

}

统计分组检索

有这样一个需求:统计订单总数。以码明示,在QBCTest单元测试类中编写如下单元测试方法:

public class QBCTest {

    // 统计检索
    @Test
    public void test5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.统计订单总数
        Criteria criteria = session.createCriteria(Order.class);
        Object obj = criteria.setProjection(Projections.rowCount()).uniqueResult(); // 统计总行数,可以理解为count(*)
        System.out.println(obj);

        session.getTransaction().commit();
        session.close();
    }

}

现在又有这样一个需求:根据客户分组统计订单的总价格。以码明示,将QBCTest单元测试类中的test5方法修改为:

public class QBCTest {

    // 统计检索
    @Test
    public void test5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 2.订单的总价格——根据客户分组统计
        // criteria.setProjection(Projections.sum("money")); // 统计总金额

        criteria.setProjection(Projections.projectionList().add(Projections.sum("money")).add(Projections.groupProperty("c")));

        List<Object[]> list = criteria.list(); // 在这个集合中,保存的是Object[money的统计信息, 客户信息]       

        for (Object[] objs : list) {
            for (Object obj : objs) {
                System.out.println(obj);
            }
        }

        session.getTransaction().commit();
        session.close();
    }

}

从以上代码可知,criteria.list()所得结果类型是List<Object[]>,在这个集合中,保存的是Object数组,数组的第一个元素是money的统计信息,第二个元素是客户信息。

离线条件检索

Hibernate框架支持在运行时动态生成查询语句,DetachedCriteria对象可以脱离session而使用。之前我们在三层架构之间传递用户提交的参数可能是这样的:
技术分享
但使用离线条件对象进行检索时,情况又可能是这样的:
技术分享
现在有这样一个需求:查询名称叫武某(武_)的客户。以码明示, 在QBCTest单元测试类中编写如下单元测试方法:

public class QBCTest {

    // 离线的检索
    @Test
    public void test6() {
        // 1.得到一个DetachedCriteria对象
        DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
        dc.add(Restrictions.like("name", "武_"));

        // 2.生成Criteria执行我们的操作
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        Criteria criteria = dc.getExecutableCriteria(session);
        List<Customer> list = criteria.list();

        System.out.println(list);
        session.getTransaction().commit();
        session.close();
    }

}

本地SQL

有这样一个需求:查询所有的Customer对象。以码明示, 在cn.itheima.test包中编写一个SQLTest单元测试类,并在类中编写如下方法:

public class SQLTest {

    // 测试执行本地sql
    @Test
    public void test1() {

        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 执行本地sql
        SQLQuery sqlQuery = session.createSQLQuery("select * from t_customer");
        // List list = sqlQuery.list();
        // System.out.println(list);

        // List<Object[]> list = sqlQuery.list();

        sqlQuery.addEntity(Customer.class); // 如何能得到一个对象呢?
                                            // 将查询结果绑定到指定对象
        List list = sqlQuery.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();

    }

}

需要说明的是本地sql也支持命名查询。那么问题就来了,这个本地sql语句到底定义在什么位置呢?答案如下:

  1. 如果你有hbm映射配置文件,那么当前的sql操作是针对哪一个实体进行操作的,就在哪一个实体的映射配置文件中进行声明。声明如下:

    <sql-query name="xxx">...</sql-query>
  2. 本地命名sql使用注解来定义,例如,在Customer实体类上添加一个@NamedNativeQuery注解,如下:

    // 客户 ---- 一的一方
    @Entity
    @Table(name="t_customer")
    @NamedQuery(name="myHql", query="from Customer")
    @NamedNativeQuery(name="findCustomer",query="select * from t_customer")
    public class Customer {
    
        .......
    
    }

    接着在SQLTest单元测试类中编写如下方法:

    public class SQLTest {
    
        // 测试本地sql命名查询
        @Test
        public void test2() {
    
            Session session = HibernateUtils.openSession();
            session.beginTransaction();
    
            Query query = session.getNamedQuery("findCustomer");
            List list = query.list();
            System.out.println(list);
    
            session.getTransaction().commit();
            session.close();
    
        }
    
    }

    test2方法正常运行,并没有所谓的异常。可能有些同学运行时,会报以下异常:
    技术分享
    出现问题的原因是Hibernate框架不知道执行select * from t_customer语句后如何将结果封装。要想解决该异常,Customer实体类的代码应修改为:

    // 客户 ---- 一的一方
    @Entity
    @Table(name="t_customer")
    @NamedQuery(name="myHql", query="from Customer")
    // @SqlResultSetMapping注解才真正帮我们去规定执行sql语句如何将结果封装到Customer对象
    @SqlResultSetMapping(name="customerSetMapping",entities={ @EntityResult(entityClass=Customer.class,fields={ 
            @FieldResult(name="id",column="id"),@FieldResult(name="name",column="name") }) })
            // fields指定类里面的每一个属性跟表中的列是如何对应的
    @NamedNativeQuery(name="findCustomer",query="select * from t_customer",resultSetMapping="customerSetMapping")
                                                                       // resultSetMapping需要指定一个名字,它用来指定结果如何封装的操作
    public class Customer {
    
        @Id
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Integer id; // 主键
        private String name; // 姓名
    
        // 描述客户可以有多个订单
        /*
         * targetEntity="...":相当于<one-to-many class="...">
         * mappedBy="...":相当于inverse=true,即放弃关联关系的维护,不然会生成一个中间表
         */
        @OneToMany(targetEntity=Order.class,mappedBy="c")
        private Set<Order> orders = new HashSet<Order>();
    
        public Customer() {
    
        }
    
        public Customer(Integer id, String name) {
            super();
            this.id = id;
            this.name = name;
        }
    
        public Set<Order> getOrders() {
            return orders;
        }
        public void setOrders(Set<Order> orders) {
            this.orders = orders;
        }
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Customer [id=" + id + ", name=" + name + "]";
        }
    
    }

    注意:@NamedNativeQuery注解中的resultSetMapping属性需要指定一个名字,它用来指定结果如何进行封装,但@SqlResultSetMapping注解才真正帮我们去规定了执行sql语句如何将结果封装到Customer对象中,而且@EntityResult注解中的fields属性指定了PO类里面的每一个属性跟表中的列是如何对应的。

<script type="text/javascript"> $(function () { $(‘pre.prettyprint code‘).each(function () { var lines = $(this).text().split(‘\n‘).length; var $numbering = $(‘
    ‘).addClass(‘pre-numbering‘).hide(); $(this).addClass(‘has-numbering‘).parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($(‘
  • ‘).text(i)); }; $numbering.fadeIn(1700); }); }); </script>

    Hibernate检索方式概述