Hibernate检索方式概述
来源：互联网 发布：淘宝手机端怎么排名 编辑：程序博客网 时间：2024/05/22 15:47
Hibernate检索方式概述
我们在对数据库的操作中，最常用的是select，那么使用Hibernate如何进行select操作呢？本文就来徐徐道来。
Hibernate检索方式可分为5种：
- 导航对象图检索方式，根据已加载的对象导航到其它对象。
- OID检索方式，按照对象的OID来检索对象。
- HQL检索方式，使用面向对象的HQL查询语言。
- QBC检索方式，使用QBC(Query by Criteria)API来检索对象，这种API封装了基于字符串形式的查询语句，提供了更加面向对象的查询接口。
- 本地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检索的基本步骤：
- 得到Session
- 编写HQL语句
- 通过
session.createQuery(hql)创建一个Query对象 - 为Query对象设置条件参数
- 执行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语句到底定义在什么位置呢？答案如下：
如果你有hbm映射配置文件，那么当前的hql操作是针对哪一个实体进行操作的，就在哪一个实体的映射配置文件中进行声明。声明如下：
<query name="myHql"> from Customer</query>如果是使用注解来描述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(); } }运行以上方法，不仅查询出了客户的基本信息，还查询出了客户下的所有订单。
现在我们有了这么一个需求：查询【武松】这个客户的所有订单。解决方法如下：
在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 + "]"; }}在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检索的步骤为：
- 通过Session的createCriteria方法得到一个Criteria对象，即
session.createCriteria() - 设定条件，每个Criterion实例就代表一个条件，它的获取可以通过Restrictions类提供的静态方法得到，然后可通过Criteria的add方法添加查询条件
- 调用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语句到底定义在什么位置呢？答案如下：
如果你有hbm映射配置文件，那么当前的sql操作是针对哪一个实体进行操作的，就在哪一个实体的映射配置文件中进行声明。声明如下：
<sql-query name="xxx">...</sql-query>本地命名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类里面的每一个属性跟表中的列是如何对应的。
1 0
- Hibernate检索方式概述
- 1014--Hibernate 检索方式--概述
- hibernate的检索方式
- Hibernate的检索方式
- HIBERNATE检索对象方式
- Hibernate检索方式
- Hibernate检索方式
- Hibernate检索方式
- Hibernate的检索方式
- Hibernate检索方式
- hibernate检索方式
- Hibernate 的检索方式
- Hibernate的检索方式
- Hibernate的检索方式
- Hibernate检索方式
- Hibernate 检索方式
- Hibernate 检索方式
- Hibernate检索方式
- 极化码的原理
- 图像边缘检测-Sobel算子
- JNI ERROR (app bug): local reference table overflow (max=512)
- 周志华 机器学习 模型选择与评估
- Kanzi基础---C++访问Kanzi节点
- Hibernate检索方式概述
- 如何消化一本书
- C++（笔记）纯虚函数（抽象类）
- 南阳OJ 题目98：成绩转换
- 字符串处理函数
- [LeetCode]292. Nim Game
- LeetCode#54. Spiral Matrix
- C语言排序
- javaweb项目之（书城项目）的功能实现（最全没有之一）
