http://blog.csdn.net/yerenyuan_pku/article/details/70554816

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 {// 基本检索@Testpublic 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 {// 排序检索——查询订单，根据订单的价格进行排序@Testpublic 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 {// 条件查询@Testpublic 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 {// 条件查询@Testpublic 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 {// 分页检索@Testpublic 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 {// 分组统计操作@Testpublic 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 {// 分组统计操作@Testpublic 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 {// 投影查询@Testpublic 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 {// 投影查询@Testpublic 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 {// 投影查询@Testpublic 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 {// 投影查询@Testpublic 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 {// 命名查询@Testpublic 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 {// 命名查询@Testpublic 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 {// 基本检索@Testpublic 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 {// 排序检索@Testpublic 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 {// 条件检索@Testpublic 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 {// 条件检索@Testpublic 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 {// 分页检索@Testpublic 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 {// 统计检索@Testpublic 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 {// 统计检索@Testpublic 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 {// 离线的检索@Testpublic 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@Testpublic 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>

   • 1
   • 1

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命名查询@Testpublic 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类里面的每一个属性跟表中的列是如何对应的。