Hibernate入门最后一天第四天，我们进行查询方式的更进一步的细化：

　　先看一下大致的Hibernate的提供的查询的方式：

　　　　1.对象导航查询

　　　　2.OID查询

　　　　3.HQL查询

　　　　4.QBC查询

　　　　5.本地SQL查询

　　使用框架，我们更加关注的是前四种查询的方式。

接下来逐条介绍：

　　1.对象导航查询
　　　　例如昨天的客户联系人的一对多：
　　　　根据id查询到客户，再根据客户下的所有联系人
　　　　这个查询过程称为对象导航
　　　　就是得到表示的那个set就可以
　　　　Set<LinkMan> set = cust.getSet_LinkMan();

  1.     /**
  2.      * 对象导航查询(顺便OID也在里面了)
  3.      * @author jiangbei01
  4.      *
  5.      */
  6.     @Test
  7.     public void query1(){
  8.         //注意规范写法
  9.         SessionFactory sessionFactory = null;
  10.         Session session = null;
  11.         Transaction tx = null;
  12.  
  13.         try{
  14.             //得到工厂
  15.             sessionFactory = HibernateUtils.getSessionFactory();
  16.             //得到session
  17.             session = sessionFactory.openSession();
  18.             //开启事务
  19.             tx = session.beginTransaction();
  20.  
  21.             //查询客户中的所有联系人
  22.             Customer cust = session.get(Customer.class, 1);
  23.             //利用对象导航查询到所有联系人
  24.             //做法就是 得到那个表示所有联系人的set集合
  25.             Set<LinkMan> set = cust.getSet_LinkMan();
  26.             System.out.println(set.size());
  27.             //提交事务
  28.             tx.commit();
  29.         }catch(Exception e){
  30.             //事务回滚
  31.             tx.rollback();
  32.         }finally{
  33.             //关闭资源
  34.             session.close();
  35.             sessionFactory.close();
  36.         }
  37.     }

　　2.OID查询
　　　　根据id查询某一条记录（返回的是对象）
　　　　也就是session.get方法实现
　　　　Customer cust = session.get(Customer.class, 1);

　　3.HQL查询
　　　　使用HQL语言（用到Query对象，昨天只演示了查询所有）==写语句
　　　　HQL与SQL最大的不同是：
　　　　　　　　HQL操作实体类
　　　　　　　　SQL操作表

　　　　HQL常用语句：
　　　　　　　　查询所有 === from 实体类名称

  1. /**
  2.      * HQL Query对象查询所有
  3.      * @author jiangbei01
  4.      *
  5.      */
  6.     @SuppressWarnings("deprecation")
  7.     @Test
  8.     public void query2(){
  9.         //注意规范写法
  10.         SessionFactory sessionFactory = null;
  11.         Session session = null;
  12.         Transaction tx = null;
  13.  
  14.         try{
  15.             //得到工厂
  16.             sessionFactory = HibernateUtils.getSessionFactory();
  17.             //得到session
  18.             session = sessionFactory.openSession();
  19.             //开启事务
  20.             tx = session.beginTransaction();
  21.  
  22.             //得到Query对象 ，显示已过时，待解决
  23.             Query query = session.createQuery("from Customer");
  24.             //调用方法
  25.             List<Customer> list = query.list();
  26.             for (Customer customer : list) {
  27.                 System.out.println(customer.getCustLevel());
  28.             }
  29.             //提交事务
  30.             tx.commit();
  31.         }catch(Exception e){
  32.             //事务回滚
  33.             tx.rollback();
  34.         }finally{
  35.             //关闭资源
  36.             session.close();
  37.             sessionFactory.close();
  38.         }
  39.     }

　　　　　　　　条件查询 === from 实体类名称 where 实体类属性=? ... 写法与SQL基本类似:

　　　　　　　　　　from 实体类名称 where 属性 like ?

  1. /**
  2.      * HQL条件查询 第一步都是创建query对象
  3.      * 模糊查询极其类似，不再赘述举例这里 参数为String类型的即可（%浪%）
  4.      */
  5.     @Test
  6.     public void query3(){
  7.         //注意规范写法
  8.         SessionFactory sessionFactory = null;
  9.         Session session = null;
  10.         Transaction tx = null;
  11.  
  12.         try{
  13.             //得到工厂
  14.             sessionFactory = HibernateUtils.getSessionFactory();
  15.             //得到session
  16.             session = sessionFactory.openSession();
  17.             //开启事务
  18.             tx = session.beginTransaction();
  19.  
  20.             //得到Query对象 ，显示已过时，待解决
  21.             Query query = session.createQuery(
  22.                     "from Customer c where c.cid=?");
  23.             //设置条件值，也就是向?设置值,一般都是用这个方法，而较少去使用其它重载方法
  24.             //第一个参数为int ?问号的位置，第二个为Object，这里必须注意：！！
  25.             //pstmt里面？从1 开始 ，这里从0开始！
  26.             query.setParameter(0, 1);
  27.             //调用方法
  28.             List<Customer> list = query.list();
  29.             for (Customer customer : list) {
  30.                 System.out.println(customer.getCustLevel());
  31.             }
  32.  
  33.             //提交事务
  34.             tx.commit();
  35.         }catch(Exception e){
  36.             //事务回滚
  37.             tx.rollback();
  38.         }finally{
  39.             //关闭资源
  40.             session.close();
  41.             sessionFactory.close();
  42.         }
  43.     }

　　　　　　　　
　　　　　　　　排序查询 === from 实体类名称 order by 属性 acs

  1.     /**
  2.      *演示排序
  3.      */
  4.     @Test
  5.     public void query4(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //得到Query对象 ，显示已过时，待解决
  20.             Query query = session.createQuery(
  21.                     "from Customer order by cid asc");
  22.             //调用方法
  23.             List<Customer> list = query.list();
  24.             for (Customer customer : list) {
  25.                 System.out.println(customer.getCid());
  26.             }
  27.  
  28.             //提交事务
  29.             tx.commit();
  30.         }catch(Exception e){
  31.             //事务回滚
  32.             tx.rollback();
  33.         }finally{
  34.             //关闭资源
  35.             session.close();
  36.             sessionFactory.close();
  37.         }
  38.     }

　　　　　　　　分页查询 === mysql中实现分页使用的是关键字 limit,注意此时hibernate不认识Limit这个方言！

  1. /**
  2.      *演示分页
  3.      */
  4.     @Test
  5.     public void query5(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //得到Query对象 ，显示已过时，待解决
  20.             Query query = session.createQuery(
  21.                     "from Customer");
  22.             //设置开始位置
  23.             query.setFirstResult(0);
  24.             //设置每页的记录数
  25.             query.setMaxResults(5);
  26.  
  27.             //提交事务
  28.             tx.commit();
  29.         }catch(Exception e){
  30.             //事务回滚
  31.             tx.rollback();
  32.         }finally{
  33.             //关闭资源
  34.             session.close();
  35.             sessionFactory.close();
  36.         }
  37.     }

　　　　　　　　使用的是query的封装的两个方法：
　　　　　　　　投影查询 === （用的不是很多，原因是查到所有后部分也简单）
　　　　　　　　投影的概念：查的是部分字段 例如 SELECT cid FROM t_stu
　　　　　　　　HQL与SQL这里也是极其相似
　　　　　　　　　　select 属性名1，属性名2 from 实体类名称（注意不能 写* ，写*查询所有应直接 from ...）
　　　　　　　　聚合函数 === 常用的COUNT() SUM() MAX/MIN() AVG()
　　HQL写法：
　　　　　　select count(*) from 实体类名称
　　　　使用这种接收只有某个的结果
　　　　　　Object o = query.uniqueResult();
　　　　　　注意此处返回值不能直接强转成int,因为此处o是long类型
　　　　　　应当先转成long类型，再转
　　　　　　Long不能直接强转，而是使用intValue()返回基本类型的值

  1. /**
  2.      *演示聚合函数
  3.      */
  4.     @Test
  5.     public void query6(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //得到Query对象 ，显示已过时，待解决
  20.             Query query = session.createQuery(
  21.                     "select count(*) from Customer");
  22.             //只返回某个值，而不用list
  23.             Object o = query.uniqueResult();
  24.             System.out.println(o);
  25.  
  26.             //提交事务
  27.             tx.commit();
  28.         }catch(Exception e){
  29.             //事务回滚
  30.             tx.rollback();
  31.         }finally{
  32.             //关闭资源
  33.             session.close();
  34.             sessionFactory.close();
  35.         }
  36.     }
  37. }

　　

　　4.QBC查询 （实际开发更倾向于此而少写HQL）
　　　　用到的是 Criteria对象 ==不写语句，这是与HQL不同的部分，而是使用方法操作实体类进行的操作
　　包含的也是这些：
　　　　查询所有：
　　　　　　得到对象，调用方法即可

  1. /**
  2.      *演示QBC查询所有
  3.      */
  4.     @Test
  5.     public void query6(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //创建对象 ，显示已过时，待解决
  20.             Criteria criteria = session.createCriteria(Customer.class);
  21.             //调用方法实现
  22.             List<Customer> list = criteria.list();
  23.             //遍历结果集
  24.             for (Customer customer : list) {
  25.                 System.out.println(customer.getCustName());
  26.             }
  27.  
  28.             //提交事务
  29.             tx.commit();
  30.         }catch(Exception e){
  31.             //事务回滚
  32.             tx.rollback();
  33.         }finally{
  34.             //关闭资源
  35.             session.close();
  36.             sessionFactory.close();
  37.         }
  38.     }

　　　　条件查询：
　　　　　　通过方法控制条件

  1.     /**
  2.      *演示QBC条件查询
  3.      */
  4.     @Test
  5.     public void query5(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //创建对象 ，显示已过时，待解决
  20.             Criteria criteria = session.createCriteria(Customer.class);
  21.             //使用add()方法设置条件的值，更多请百度Restrictions静态类的用法
  22.             criteria.add(Restrictions.eq("cid", 1));
  23.             List<Customer> list = criteria.list();
  24.             for (Customer customer : list) {
  25.                 System.out.println(customer.getCustName());
  26.             }
  27.  
  28.             //提交事务
  29.             tx.commit();
  30.         }catch(Exception e){
  31.             //事务回滚
  32.             tx.rollback();
  33.         }finally{
  34.             //关闭资源
  35.             session.close();
  36.             sessionFactory.close();
  37.         }
  38.     }

　　以下概念不再赘述，直接见案例
　　　　排序查询：

  1. /**
  2.      *演示QBC排序查询
  3.      */
  4.     @Test
  5.     public void query4(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //创建对象 ，显示已过时，待解决
  20.             Criteria criteria = session.createCriteria(Customer.class);
  21.             //设置对哪个属性进行排序，包括排序方式和排序规则（似乎不如HQL方便）
  22.             criteria.addOrder(Order.desc("cid"));
  23.  
  24.             List<Customer> list = criteria.list();
  25.             for (Customer customer : list) {
  26.                 System.out.println(customer.getCustName());
  27.             }
  28.  
  29.             //提交事务
  30.             tx.commit();
  31.         }catch(Exception e){
  32.             //事务回滚
  33.             tx.rollback();
  34.         }finally{
  35.             //关闭资源
  36.             session.close();
  37.             sessionFactory.close();
  38.         }
  39.     }

　　　　分页查询：

  1.     /**
  2.      *演示QBC分页查询
  3.      */
  4.     @Test
  5.     public void query3(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //创建对象 ，显示已过时，待解决
  20.             Criteria criteria = session.createCriteria(Customer.class);
  21.             //也是调方法，和HQL有点相似,设置分页的两个数据,注意：凡是设置的方法，一般都是先打set前缀
  22.             criteria.setFirstResult(0);
  23.             criteria.setMaxResults(2);
  24.  
  25.             List<Customer> list = criteria.list();
  26.             for (Customer customer : list) {
  27.                 System.out.println(customer.getCustName());
  28.             }
  29.  
  30.             //提交事务
  31.             tx.commit();
  32.         }catch(Exception e){
  33.             //事务回滚
  34.             tx.rollback();
  35.         }finally{
  36.             //关闭资源
  37.             session.close();
  38.             sessionFactory.close();
  39.         }
  40.     }

　　　　统计查询：
，　　统计记录条数等：

  1. /**
  2.      *演示QBC统计查询
  3.      */
  4.     @Test
  5.     public void query2(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //创建对象 ，显示已过时，待解决
  20.             Criteria criteria = session.createCriteria(Customer.class);
  21.             //设置操作，其它操作举一反三
  22.             criteria.setProjection(Projections.rowCount());
  23.             //调用方法
  24.             Object o = criteria.uniqueResult();
  25.             Long l = (Long) o;
  26.             int r = l.intValue();
  27.  
  28.             System.out.println(r);
  29.  
  30.             //提交事务
  31.             tx.commit();
  32.         }catch(Exception e){
  33.             //事务回滚
  34.             tx.rollback();
  35.         }finally{
  36.             //关闭资源
  37.             session.close();
  38.             sessionFactory.close();
  39.         }
  40.     }

离线查询：
　　步骤：
　　　　创建对象
　　　　设置操作
　　　　调用方法
　　　　离线查询：
　　之前的criteria是通过session查询的，是依赖session的
　　场景例子：希望在条件查询时就在servlet中实现条件的拼接
　　就是可以离线的操作

  1. /**
  2.      *演示QBC离线查询
  3.      */
  4.     @Test
  5.     public void query1(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //创建离线
  20.             DetachedCriteria detachedCriteria = DetachedCriteria
  21.                     .forClass(Customer.class);
  22.             //最终执行的时候才用session
  23.             Criteria criteria = detachedCriteria.getExecutableCriteria(session);
  24.  
  25.             //再执行
  26.             List<Customer> list = criteria.list();
  27.             for (Customer customer : list) {
  28.                 System.out.println(customer.getCustPhone());
  29.             }
  30.  
  31.             //提交事务
  32.             tx.commit();
  33.         }catch(Exception e){
  34.             //事务回滚
  35.             tx.rollback();
  36.         }finally{
  37.             //关闭资源
  38.             session.close();
  39.             sessionFactory.close();
  40.         }
  41.     }

　　5.本地SQL查询
　　　　SQLQuery对象，使用本地SQL查询（前面有类似的案例，用的少的不再赘述）

　　　　当然，这里重点应该关注前4种查询方式

　　使用了上面的单表查询后，来看看HQL如何进行多表查询：

　　　　HQL多表查询（达到会用的水平先）
　　　　　　回顾mysql的一般多表查询：
　　　　　　　　　　　　内连接 INNER JOIN ON
　　　　　　　　　　　　左外连接 LEFT OUTER JOIN ON
　　　　　　　　　　　　右外连接 RIGHT OUTER JOIN ON
　　　　HQL实现多表查询：
　　　　　　1.内连接
　　　　　　2.左外连接
　　　　　　3.右外连接
　　　　　　4.迫切内连接
　　　　　　5.迫切左外连接（没有右外！勿擅自创造）

　　再次强调，HQL操作的是实体类，而不是表！

　　　　1.HQL内连接：
　　　　　　from Customer c inner join c.set_LinkMan
　　　　　　注意点：join后加的是表示联系人的set集合，并且后面没有on!

  1. /**
  2.      *演示HQL内连接
  3.      */
  4.     @Test
  5.     public void query1(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.  
  19.             //HQL使用的是Query对象
  20.             Query query = session.createQuery("from Customer c inner join c.set_LinkMan");
  21.             List list = query.list();
  22.             //提交事务
  23.             tx.commit();
  24.         }catch(Exception e){
  25.             //事务回滚
  26.             tx.rollback();
  27.         }finally{
  28.             //关闭资源
  29.             session.close();
  30.             sessionFactory.close();
  31.         }
  32.     }

　　2.迫切内连接和内连接的底层实现是一样的
　　　　迫切内连接返回的list每部分是对象
　　　　而内连接返回的list每部分是数组
　　　　from Customer c inner join fetch c.set_LinkMan

　　3.左外连接与迫切左外连接：
　　　　from Customer c left outer join c.set_LinkMan
　　　　from Customer c left outer join fetch c.set_LinkMan
　　　　同样的，左外连接返回的每部分是数组
　　　　迫切左外连接返回的是对象

迫切与普通连接查询的区别：

 我们可以看到采用左外连接查询返回的结果集中包含的是对象数组，对象数组中的每个元素存放了一对相互关联的Customer对象和Order对象，
而迫切左外连接会返回Customer对象，与Customer对象相关联的Order对象存放在Customer对象的集合元素对象中，
这就是迫切左外连接和左外连接查询的其中一个区别（这两种检索生成的SQL语句是一样的） 

以上两种用法与1都相差无几。

Hibernate检索策略：
　　主要分为两类：
　　　　立即检索：
　　　　　　一调用get()方法马上发送SQL语句去查询
　　　　延迟检索：
　　　　　　调用load()方法，不会马上发送语句，
　　只有得到对象里面的值的时候，也就是什么时候用那个值
　　才发送语句，查询数据库，调用load()时，初始里面只有传入的id值
　　验证的方式是debug看发送语句的时机（F6一步一步走）

　　延迟查询中又分两类：（默认会有相关的延迟优化方式，自己修改的机会少）
　　类级别的延迟：
　　　　返回一个实体类的对象
　　在class标签上设置lazy值（选值见下）

　　关联级别的延迟：
　　　　查询某个客户，再查询客户里的所有联系人，
　　　　查询客户所有联系人的过程是否需要延迟
　　　　　　关联级别的延迟方式也可以自己修改（当然，默认的优化已经可以，作了解）
　　　　　　修改方式是在映射文件中进行配置
　　　　　　根据客户得到联系人，则配置客户的映射文件
　　　　　　在set标签上设置属性：
　　fetch:值select（默认）
　　lazy:值true 延迟（默认）
　　　　　 false 不延迟(遇到要用时都查出来给你)
　　　　　 extra 极其延迟（要什么给的什么，用size就只发送count(*)）

  1. /**
  2.      *演示立即查询与延迟查询
  3.      */
  4.     @Test
  5.     public void query1(){
  6.         //注意规范写法
  7.         SessionFactory sessionFactory = null;
  8.         Session session = null;
  9.         Transaction tx = null;
  10.  
  11.         try{
  12.             //得到工厂
  13.             sessionFactory = HibernateUtils.getSessionFactory();
  14.             //得到session
  15.             session = sessionFactory.openSession();
  16.             //开启事务
  17.             tx = session.beginTransaction();
  18.             //一调用get方法，马上去查询
  19.             Customer cust = session.get(Customer.class, 1);
  20.             System.out.println(cust.getCustName());
  21.  
  22.             Customer cust1 = session.load(Customer.class, 2);//此时Customer中只有一个id值
  23.             System.out.println(cust1.getCustName());//去拿它的名字时才发语句去查询
  24.  
  25.             //提交事务
  26.             tx.commit();
  27.         }catch(Exception e){
  28.             //事务回滚
  29.             tx.rollback();
  30.         }finally{
  31.             //关闭资源
  32.             session.close();
  33.             sessionFactory.close();
  34.         }
  35.     }

Hibernate的批量抓取（会用）
比如使用场景，需要查询所有客户（返回list）的联系人
可以先查出list,再逐个遍历（性能低）
这种对象导航仅仅实现了功能，却使得性能低下（发送了很多次的语句）

完成批量抓取的优化是通过映射文件的配置完成的
在set标签上配置属性 batch-size=""
这里面配置一个整形，没有固定值，值越大发的语句越少，性能越高（当然应当根据数据库记录数调优）
（可以查看底层SQL，使用的是in(?,?...)的形式，减少了语句的发送）

Hibernate第四天——查询方式的更多相关文章

  1. Hibernate的四种查询方式（主键查询，HQL查询，Criteria查询，本地sql查询）和修改和添加

    Hibernate的添加,修改,查询(三种查询方式)的方法: 案例演示: 1:第一步,导包,老生常谈了都是,省略: 2:第二步,创建数据库和数据表,表结构如下所示: 3:第三步创建实体类User.ja ...

  2. hibernate的三种查询方式

    hibernate的三种查询方式 目录 hibernate的三种查询方式 1.HQL查询 1.1.SQL概述 1.2.实体查询 1.3.带where的查询 1.3.属性查询 1.4.实体的更新和删除 ...

  3. hibernate学习笔记6--Criteria查询方式、完整小练习（开发步骤）

    一.Criteria查询方式没有sql语了,因此更加面向对象一些.Criteria是一种比HQL更面向对象的查询方式:Criteria的创建方式: Criteria c = s.createCrite ...

  4. Hibernate之HQL检索(查询)方式

    HQL(Hibernate Query Language)是面向对象的查询语言,与SQL非常相似.在Hibernate中,HQL是使用最广泛的检索方式. 具有下面经常使用功能: (1)在查询语句中,能 ...

  5. Hibernate的几种查询方式-HQL,QBC,QBE,离线查询,复合查询,分页查询

    HQL查询方式 这一种我最常用,也是最喜欢用的,因为它写起来灵活直观,而且与所熟悉的SQL的语法差不太多.条件查询.分页查询.连接查询.嵌套查询,写起来与SQL语法基本一致,唯一不同的就是把表名换成了 ...

  6. sessionFactory的创建和四种查询方式

    1,关于sessionFactory的创建 5.0版本之前,下面这种方式在5.0及之后,可能会出问题,建议修改为5.0之后的方式 // 实例化Configuration Configuration c ...

  7. Spring Data Jpa的四种查询方式

    一.调用接口的方式 1.基本介绍 通过调用接口里的方法查询,需要我们自定义的接口继承Spring Data Jpa规定的接口 public interface UserDao extends JpaR ...

  8. hibernate 查询方式汇总

    主要摘自  http://blog.sina.com.cn/s/blog_7ffb8dd501014a6o.html ,http://blog.csdn.net/xingtianyiyun/artic ...

  9. Hibernate查询方式汇总

    Hibernate总的来说共有三种查询方式:HQL.QBC和SQL三种.但是细分可以有如下几种: 一.HQL查询方式    这一种我最常用,也是最喜欢用的,因为它写起来灵活直观,而且与所熟悉的SQL的 ...

随机推荐

  1. MYSQL数据类型 表基本操作 表记录增删改 单表查询

    一.数据类型 常用的数据类型如下: 整数:int,bit 小数:decimal 字符串:varchar,char 日期时间: date, time, datetime 枚举类型(enum) 特别说明的 ...

  2. C++虚函数原理

    类中的成员函数分为静态成员函数和非静态成员函数,而非静态成员函数又分为普通函数和虚函数. Q: 为什么使用虚函数 A: 使用虚函数,我们可以获得良好的可扩展性.在一个设计比较好的面向对象程序中,大多数 ...

  3. 在centos系统安装mongodb

    在Linux CentOS系统上安装完php和MySQL后,为了使用方便,需要将php和mysql命令加到系统命令中,如果在没有添加到环境变量之前,执行“php -v”命令查看当前php版本信息时时, ...

  4. 转：Window_Open详解

       引:Window_Open详解一.window.open()支持环境:JavaScript1.0+/JScript1.0+/Nav2+/IE3+/Opera3+ 二.基本语法:window.op ...

  5. ORACLE 参数设置绑定变量

    使用 CURSOR_SHARING 参数 EXACT  默认,不替换 SIMIAR 当替换不会影响到执行计划时,才会将字面量替换成绑定变量 FORCE 只要有可能,字面量会被替换为绑定变量

  6. 构造个人轻量级XSS平台获取管理员cookie并登录

    一.前言 本平台是个人轻量级XSS测试平台,仅作为练习参考. 二.实验环境 服务器操作系统:Centos 7 Web容器:Apache 三.平台搭建过程 安装Apache 安装PHP 安装Git工具 ...

  7. ZT 查找字符串中连续最长的数字串

    查找字符串中连续最长的数字串 有俩方法,1)比较好理解一些.2)晦涩 1) /* 功能:在字符串中找出连续最长的数字串,并把这个串的长度返回, 并把这个最长数字串付给其中一个函数参数outputstr ...

  8. 小白学svn

    该博客是本人第一次在自己的电脑中部署svnserver后的一些心得,希望对小白们有所帮助.尽管本人之前有使用svn开发的经验,可是那都是使用百度开发人员平台的,我一直以为在自己的电脑中弄svnserv ...

  9. CentOS 7.4 yum安装LAMP环境

    配置防火墙,开启80.3306端口.CentOS 7.0默认使用的是firewall作为防火墙,这里改为iptables防火墙. #停止firewall服务 systemctl stop firewa ...

  10. [HAOI2015]按位或

    题目 好神的题啊 我们发现我们求这个东西如果常规\(dp\)的话可以建出一张拓扑图来,但是边的级别高达\(3^n\),转移的时候还要解方程显然不能通过本题 我们考虑神仙的\(min-max\)容斥 设 ...