zoukankan html css js c++ java

Hibernate查询语句

1 hql查询

Hibernate的查询语句，hiberante提供的面向对象的查询语言，和sql语句的语法的相似.而且严格区分大小写。

1.1 from字句

 1 /**
 2  * hql: from 字句
 3  * ***/
 4 @Test
 5 public void  testFromHql()
 6 {
 7     //获得Session对象
 8     Session session=sf.openSession();
 9     String hql="from Dept";
10     //获得部门对象的集合
11     List<Dept>   dlist = session.createQuery(hql).list();
12     for(Dept d:dlist){
13         System.out.println(d.getDname());
14     }
15     //释放资源
16     session.close();
17 }

语法：from 类名

1 from 类名

返回值就是该类对应的对象的集合

2 关联查询

From 类名1,…类名N 返回值为Object类的数组的集合

Object类型数组中元素为：类名1 ….类名N对应的对象

1.2 select字句

select:后指定一个属性

Select:后指定两个属性

 1 /**
 2  * hql: select 字句
 3  * select查询获得不是某个pojo类的对象集合
 4  * ***/
 5 @Test
 6 public void  testSelectHql()
 7 {
 8     //获得Session对象
 9     Session session=sf.openSession();
10     //select：后面指定一个属性
11     /*String hql="select dname from Dept";
12         //获得指定属性类型对应的集合
13         List<String>  dlist = session.createQuery(hql).list();
14         for(String d:dlist){
15             System.out.println(d);
16         }*/
17     //select:后面指定多个属性
18     String hql="select did,dname from Dept";
19     //获得Object类型数组的集合
20     List<Object[]>  dlist = session.createQuery(hql).list();
21     for(Object[] d:dlist)
22     {
23         System.out.println(d[0]+"	"+d[1]);
24     }
25     //释放资源
26     session.close();
27 }

Select返回值三种情况

1 select 指定一个属性

返回值为属性对应的类型的集合

2 select指定n个属性

返回值为Object[]数组的集合，数组中元素为指定属性对应的值

3 select获得结果为单行单列

直接返回Object类型的对象，uniqueResult()

1.3关联查询

 1 /***
 2  * 关联查询
 3  * ***/
 4 @Test
 5 public void  testJoinHql()
 6 {
 7     //获得Session对象
 8     Session session=sf.openSession();
 9     /*String hql="from Dept d,Post p where d.did=p.dept.did";
10         //获得Object类型的数组集合，数组中元素是关联的pojo类对象
11         List<Object[]>  dlist = session.createQuery(hql).list();
12         for(Object[] d:dlist){
13             //System.out.println(d[0]+"	"+d[1]);
14             Dept dept=(Dept)d[0];
15             Post post=(Post)d[1];
16             System.out.println(dept.getDname()+"	"+post.getPname());
17         }*/
18     String hql="select d.dname,p.pname from Dept d,Post p where d.did=p.dept.did";
19     //获得Object类型的数组集合，数组中元素是select后面指定的属性
20     List<Object[]>  dlist = session.createQuery(hql).list();
21     for(Object[] d:dlist)
22     {
23         System.out.println(d[0]+"	"+d[1]);
24     }
25     //释放资源
26     session.close();
27 }

1.4连接查询

 1 /***
 2  * 内连接：inner join
 3  * ***/
 4 @Test
 5 public void  testInnerJoinHql()
 6 {
 7     //获得Session对象
 8     Session session=sf.openSession();
 9     String hql="from Dept d inner join d.posts ";
10     List<Object[]> list = session.createQuery(hql).list();
11     //遍历结果集
12     for(Object[] arr:list)
13     {
14         System.out.println(arr[0]+"	"+arr[1]);
15     }
16     //释放资源
17     session.close();
18 }
19 /***
20  * 做外连接：left join
21  * ***/
22 @Test
23 public void  testLeftJoinHql()
24 {
25     //获得Session对象
26     Session session=sf.openSession();
27     String hql="from Dept d left join d.posts p  ";
28     List<Object[]> list = session.createQuery(hql).list();
29     //遍历结果集
30     for(Object[] arr:list)
31     {
32         System.out.println(arr[0]+"	"+arr[1]);
33     }
34     //释放资源
35     session.close();
36 }

不需要指定关联的条件，
hibernate根据映射文件自动关联

1.5聚合和分组查询

 1 /***
 2  * 聚合和分组查询
 3  * max
 4  * min
 5  * avg
 6  * sum
 7  * ***/
 8 @Test
 9 public void  testFunGroup()
10 {
11     //获得Session对象
12     Session session=sf.openSession();
13     /***获得每个部门下的岗位人数***/
14     String hql="select p.dept.dname ,count(pid) from  Post p group by p.dept.did  ";
15     List<Object[]> list = session.createQuery(hql).list();
16     //遍历结果集
17     for(Object[] arr:list)
18     {
19         System.out.println(arr[0]+"	"+arr[1]);
20     }
21     //释放资源
22     session.close();
23 }

1.6 where 字句

和属性的表达式写法一样

And or not

< >= <=

In , not in

Like,not like

Between and

1.7 order by字句

2 条件查询

标准的面向对象的查询，

  1 public class TestMany2One 
  2 {
  3     /**
  4      * 通过静态代码块加载配置文件
  5      * ****/
  6     static SessionFactory sf=null;
  7     static
  8     {
  9         //1 创建Configuration对象，用来加载hibernate的配置文件
 10         Configuration  cfg = new Configuration();
 11         //2加载配置文件
 12         cfg.configure("hibernate.cfg.xml");
 13         //3通过cfg构造一个会话工厂对象
 14         sf=cfg.buildSessionFactory();
 15     }
 16     /**
 17      * criteria：查询所有（所有列，所有行）
 18      * ***/
 19     @Test
 20     public void  testCriteria()
 21     {
 22         //获得Session对象
 23         Session session=sf.openSession();
 24         List<Dept> list=session.createCriteria(Dept.class, "d").list();
 25         for(Dept d:list){
 26             System.out.println(d.getDname());
 27         }
 28         //释放资源
 29         session.close();
 30     }
 31     /**
 32      * criteria：查询所有（所有列，所有行）
 33      * 进行结果的过滤
 34      * ***/
 35     @Test
 36     public void  testCriteria2()
 37     {
 38         //获得Session对象
 39         Session session=sf.openSession();
 40         Criteria c = session.createCriteria(Dept.class, "d");
 41         //加where过滤条件
 42         //c.add(Restrictions.eq("d.did", 11));
 43         //c.add(Restrictions.like("d.dname", "安慰%"));
 44         //c.add(Restrictions.)
 45         List<Dept> list = c.list();
 46         for(Dept d:list)
 47         {
 48             System.out.println(d.getDname());
 49         }
 50         //释放资源
 51         session.close();
 52     }
 53     /**
 54      * criteria：查询所有（所有列，所有行）
 55      * 进行结果的过滤
 56      * 查询指定的列：进行投影查询Projections
 57      * ***/
 58     @Test
 59     public void  testCriteria3()
 60     {
 61         //获得Session对象
 62         Session session=sf.openSession();
 63         Criteria c = session.createCriteria(Dept.class, "d");
 64         //查询指定的列
 65         c.setProjection(Projections.projectionList().add(Projections.property("dname"))
 66                 .add(Projections.property("did")));
 67         List<Object[]> list = c.list();
 68         for(Object[] d:list)
 69         {
 70             System.out.println(d[0]+"	"+d[1]);
 71         }
 72         //释放资源
 73         session.close();
 74     }
 75     /**
 76      * criteria：查询所有（所有列，所有行）
 77      * 进行结果的过滤
 78      * 查询指定的列：进行投影查询Projections
 79      * 投影，聚合 ，分组
 80      *
 81      * ***/
 82     @Test
 83     public void  testCriteria4()
 84     {
 85         //获得Session对象
 86         Session session=sf.openSession();
 87         Criteria c = session.createCriteria(Dept.class, "d");
 88         //查询指定的列
 89         c.setProjection(Projections.projectionList().add(Projections.property("d.dname"))
 90                 .add(Projections.property("d.did"))
 91                 .add(Projections.count("d.did"))
 92                 .add(Projections.groupProperty("d.dname")));
 93         List<Object[]> list = c.list();
 94         for(Object[] d:list)
 95         {
 96             System.out.println(d[0]+"	"+d[1]+"	"+d[2]);
 97         }
 98         //释放资源
 99         session.close();
100     }
101     /***
102      * 关联查询
103      *
104      * ****/
105     @Test
106     public void  testCriteria5()
107     {
108         //获得Session对象
109         Session session=sf.openSession();
110         Criteria c = session.createCriteria(Dept.class, "d");
111         //关联岗位
112         c.createAlias("d.posts", "p");
113         //查询指定的列
114         //c.add(Restrictions.eqProperty("d.did", "p.dept.did"));
115         List<Dept> list = c.list();
116         for(Dept d:list)
117         {
118             System.out.print(d.getDname()+"	");
119             Set<Post> posts=d.getPosts();
120             for(Post p:posts)
121             {
122                 System.out.print(p.getPname()+"		");
123             }
124             System.out.println();
125         }
126         //释放资源
127         session.close();
128     }
129 }

3 Hql语句的参数封装

 1 /**
 2  * Hql:的参数
 3  * ***/
 4 @Test
 5 public void  testHqlParam()
 6 {
 7     //获得Session对象
 8     Session session=sf.openSession();
 9     //定义hql语句，hql语句中包含占位符
10     String hql="from Dept d where d.dname=? ";
11     session.createQuery(hql).setString(0, "研发部");
12     //常用的
13     String hql2="from Dept d where d.dname=:dname";
14     List<Dept> list=session.createQuery(hql2).setString("dname", "研发部").list();
15     for(Dept d:list)
16     {
17         System.out.println(d.getDid()+"	"+d.getDname());
18     }
19     //释放资源
20     session.close();
21 }

1 from 类名

返回值就是该类对应的对象的集合

2 关联查询

From 类名1,…类名N

返回值为Object类的数组的集合

Object类型数组中元素为：类名1

….类名N对应的对象