`
可爱の小猪
  • 浏览: 107560 次
  • 性别: Icon_minigender_1
  • 来自: 南充
社区版块
存档分类
最新评论

hibernate报表查询语句

Hibernate 
阅读更多

1. 查询整个映射对象所有字段

Java代码 复制代码
  1. //直接from查询出来的是一个映射对象，即：查询整个映射对象所有字段      
  2.         String hql = "from Users";      
  3.         Query query = session.createQuery(hql);      
  4.               
  5.         List<Users> users = query.list();      
  6.         for(Users user : users){      
  7.             System.out.println(user.getName() + " : " + user.getPasswd() + " : " + user.getId());      
  8.         }      
  9.      
  10.  输出结果为：      
  11. name1 : password1 : 1     
  12. name2 : password2 : 2     
  13. name3 : password3 : 3     
//直接from查询出来的是一个映射对象，即：查询整个映射对象所有字段   
        String hql = "from Users";   
        Query query = session.createQuery(hql);   
           
        List<Users> users = query.list();   
        for(Users user : users){   
            System.out.println(user.getName() + " : " + user.getPasswd() + " : " + user.getId());   
        }   
  
 输出结果为：   
name1 : password1 : 1  
name2 : password2 : 2  
name3 : password3 : 3



2.查询单个字段 

Java代码 复制代码
  1. //查询单个字段      
  2.         String hql = " select name from Users";      
  3.         Query query = session.createQuery(hql);      
  4.               
  5.         List<String> list = query.list();      
  6.         for(String str : list){      
  7.             System.out.println(str);      
  8.         }      
  9. 输出结果为：      
  10. name1      
  11. name2      
  12. name3    
//查询单个字段   
        String hql = " select name from Users";   
        Query query = session.createQuery(hql);   
           
        List<String> list = query.list();   
        for(String str : list){   
            System.out.println(str);   
        }   
输出结果为：   
name1   
name2   
name3



3.查询其中几个字段
 

Java代码 复制代码
  1. //查询其中几个字段      
  2.         String hql = " select name,passwd from Users";      
  3.         Query query = session.createQuery(hql);      
  4.         //默认查询出来的list里存放的是一个Object数组      
  5.         List<Object[]> list = query.list();      
  6.         for(Object[] object : list){      
  7.             String name = (String)object[0];      
  8.             String passwd = (String)object[1];      
  9.                   
  10.             System.out.println(name + " : " + passwd);      
  11.         }      
  12. 输出结果为：      
  13. name1 : password1      
  14. name2 : password2      
  15. name3 : password3    
//查询其中几个字段   
        String hql = " select name,passwd from Users";   
        Query query = session.createQuery(hql);   
        //默认查询出来的list里存放的是一个Object数组   
        List<Object[]> list = query.list();   
        for(Object[] object : list){   
            String name = (String)object[0];   
            String passwd = (String)object[1];   
               
            System.out.println(name + " : " + passwd);   
        }   
输出结果为：   
name1 : password1   
name2 : password2   
name3 : password3



4.修改默认查询结果(query.list())不以Object[]数组形式返回，以List形式返回

引用
//查询其中几个字段,添加new list(),注意list里的l是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是List集合了  
        String hql = " select new list(name,passwd) from Users";  
        Query query = session.createQuery(hql);  
        //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是List集合了  
        List<List> list = query.list();  
        for(List user : list){  
            String name = (String)user.get(0);  
            String passwd = (String)user.get(1);  
              
            System.out.println(name + " : " + passwd);  
        }  
        /** 
        输出结果为： 
         name1 : password1 
        name2 : password2 
        name3 : password3 
         */ 


5.修改默认查询结果(query.list())不以Object[]数组形式返回，以Map形式返回

Java代码 复制代码
  1. //查询其中几个字段,添加new map(),注意map里的m是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是map集合了      
  2.         String hql = " select new map(name,passwd) from Users";      
  3.         Query query = session.createQuery(hql);      
  4.         //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是Map集合了      
  5.         List<Map> list = query.list();      
  6.         for(Map user : list){      
  7.             //一条记录里所有的字段值都是map里的一个元素,key是字符串0,1,2,3....，value是字段值      
  8.             //如果将hql改为：String hql = " select new map(name as username,passwd as password) from Users";,那么key将不是字符串0,1,2...了，而是"username","password"了      
  9.             String name = (String)user.get("0");//get("0");是get(key),注意:0,1,2...是字符串，而不是整形      
  10.             String passwd = (String)user.get("1");      
  11.                   
  12.             System.out.println(name + " : " + passwd);      
  13.         }      
  14.         /**    
  15.         输出结果为：    
  16.          name1 : password1    
  17.         name2 : password2    
  18.         name3 : password3    
  19.          */    
//查询其中几个字段,添加new map(),注意map里的m是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是map集合了   
        String hql = " select new map(name,passwd) from Users";   
        Query query = session.createQuery(hql);   
        //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是Map集合了   
        List<Map> list = query.list();   
        for(Map user : list){   
            //一条记录里所有的字段值都是map里的一个元素,key是字符串0,1,2,3....，value是字段值   
            //如果将hql改为：String hql = " select new map(name as username,passwd as password) from Users";,那么key将不是字符串0,1,2...了，而是"username","password"了   
            String name = (String)user.get("0");//get("0");是get(key),注意:0,1,2...是字符串，而不是整形   
            String passwd = (String)user.get("1");   
               
            System.out.println(name + " : " + passwd);   
        }   
        /**  
        输出结果为：  
         name1 : password1  
        name2 : password2  
        name3 : password3  
         */


6.修改默认查询结果(query.list())不以Object[]数组形式返回，以Set形式返回,但是因为Set里是不允许有重复的元素，所以:username和password的值不能相同。只需将hql改为：String hql = " select new set(name,passwd) from Users";

7.修改默认查询结果(query.list())不以Object[]数组形式返回，以自定义类型返回

自定义类：
 

Java代码 复制代码
  1. package com.domain;      
  2.      
  3. public class MyUser {      
  4.      
  5.     private String username;      
  6.     private String password;      
  7. //因为：String hql = " select new  com.domain.MyUser(name,passwd) from Users";所以必须要有接受2个参数的构造函数      
  8.     public MyUser(String username,String password){      
  9.         this.username = username;      
  10.         this.password = password;      
  11.     }      
  12.           
  13.     public String getUsername() {      
  14.         return username;      
  15.     }      
  16.     public void setUsername(String username) {      
  17.         this.username = username;      
  18.     }      
  19.     public String getPassword() {      
  20.         return password;      
  21.     }      
  22.     public void setPassword(String password) {      
  23.         this.password = password;      
  24.     }      
  25.           
  26.           
  27. }    
package com.domain;   
  
public class MyUser {   
  
    private String username;   
    private String password;   
//因为：String hql = " select new  com.domain.MyUser(name,passwd) from Users";所以必须要有接受2个参数的构造函数   
    public MyUser(String username,String password){   
        this.username = username;   
        this.password = password;   
    }   
       
    public String getUsername() {   
        return username;   
    }   
    public void setUsername(String username) {   
        this.username = username;   
    }   
    public String getPassword() {   
        return password;   
    }   
    public void setPassword(String password) {   
        this.password = password;   
    }   
       
       
}



 

Java代码 复制代码
  1. //通过query.list()出来的list里存放的不再是默认的Object数组了,而是自定义的类MyUser,必须加包名，String hql = "from Users";中的Users类也是必须加包名的，但是因为再Users.hbm.xml里<hibernate-mapping auto-import="true"> auto-import默认值为true（所以auto-import属性也可以不写）,自动导入了      
  2.         String hql = " select new  com.domain.MyUser(name,passwd) from Users";      
  3.         Query query = session.createQuery(hql);      
  4.         //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是MyUser对象了      
  5.         List<MyUser> myUsers = query.list();      
  6.         for(MyUser myUser : myUsers){      
  7.             String name = myUser.getUsername();      
  8.             String passwd = myUser.getPassword();      
  9.             System.out.println(name + " : " + passwd);      
  10.         }      
  11.         /**    
  12.         输出结果为：    
  13.         name1 : password1    
  14.         name2 : password2    
  15.         name3 : password3    
  16.          */    
//通过query.list()出来的list里存放的不再是默认的Object数组了,而是自定义的类MyUser,必须加包名，String hql = "from Users";中的Users类也是必须加包名的，但是因为再Users.hbm.xml里<hibernate-mapping auto-import="true"> auto-import默认值为true（所以auto-import属性也可以不写）,自动导入了   
        String hql = " select new  com.domain.MyUser(name,passwd) from Users";   
        Query query = session.createQuery(hql);   
        //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是MyUser对象了   
        List<MyUser> myUsers = query.list();   
        for(MyUser myUser : myUsers){   
            String name = myUser.getUsername();   
            String passwd = myUser.getPassword();   
            System.out.println(name + " : " + passwd);   
        }   
        /**  
        输出结果为：  
        name1 : password1  
        name2 : password2  
        name3 : password3  
         */



8：条件查询

Java代码 复制代码
  1. //条件查询，参数索引值从0开始，索引位置。通过setString,setParameter设置参数      
  2.         String hql = "from Users where name=? and passwd=?";      
  3.         Query query = session.createQuery(hql);      
  4.         //第1种方式      
  5. //      query.setString(0, "name1");      
  6. //      query.setString(1, "password1");      
  7.         //第2种方式      
  8.         query.setParameter(0, "name1",Hibernate.STRING);      
  9.         query.setParameter(1, "password1",Hibernate.STRING);      
  10.         List<Users> list = query.list();      
  11.         for(Users users : list){      
  12.             System.out.println(users.getId());      
  13.         }     
//条件查询，参数索引值从0开始，索引位置。通过setString,setParameter设置参数   
        String hql = "from Users where name=? and passwd=?";   
        Query query = session.createQuery(hql);   
        //第1种方式   
//      query.setString(0, "name1");   
//      query.setString(1, "password1");   
        //第2种方式   
        query.setParameter(0, "name1",Hibernate.STRING);   
        query.setParameter(1, "password1",Hibernate.STRING);   
        List<Users> list = query.list();   
        for(Users users : list){   
            System.out.println(users.getId());   
        }

         

Java代码 复制代码
  1. //条件查询，自定义索引名(参数名):username,:password.通过setString,setParameter设置参数      
  2.         String hql = "from Users where name=:username and passwd=:password";      
  3.         Query query = session.createQuery(hql);      
  4.         //第1种方式      
  5. //      query.setString("username", "name1");      
  6. //      query.setString("password", "password1");      
  7.         //第2种方式,第3个参数确定类型      
  8.         query.setParameter("username", "name1",Hibernate.STRING);      
  9.         query.setParameter("password", "password1",Hibernate.STRING);      
  10.         List<Users> list = query.list();      
  11.         for(Users users : list){      
  12.             System.out.println(users.getId());      
  13.         }    
//条件查询，自定义索引名(参数名):username,:password.通过setString,setParameter设置参数   
        String hql = "from Users where name=:username and passwd=:password";   
        Query query = session.createQuery(hql);   
        //第1种方式   
//      query.setString("username", "name1");   
//      query.setString("password", "password1");   
        //第2种方式,第3个参数确定类型   
        query.setParameter("username", "name1",Hibernate.STRING);   
        query.setParameter("password", "password1",Hibernate.STRING);   
        List<Users> list = query.list();   
        for(Users users : list){   
            System.out.println(users.getId());   
        }


Java代码 复制代码
  1. //条件查询,通过setProperties设置参数      
  2.         String hql = "from Users where name=:username and passwd=:password";      
  3.         Query query = session.createQuery(hql);      
  4.         //MyUser类的2个属性必须和:username和:password对应      
  5.         MyUser myUser = new MyUser("name1","password1");      
  6.         query.setProperties(myUser);      
  7.         List<Users> list = query.list();      
  8.         for(Users users : list){      
  9.             System.out.println(users.getId());      
  10.         } 
分享到：
| struts2+hibernate+spring的整合
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    在百灵报表BIRT中访问Hibernate POJO

    在百灵报表（BIRT）中访问Hibernate POJO是一个常见的需求，特别是在Java/J2EE Web应用程序中，因为Hibernate...这种方式特别适用于已经有大量业务逻辑封装在Hibernate实体中的项目，避免了在报表中重复编写SQL查询。

    精通 Hibernate：Java 对象持久化技术详解(第2版).part2

    　16.3.5 用带子查询的select语句整批量初始化orders集合（fetch属性为“subselect”） 　16.3.6 迫切左外连接检索（fetch属性为“join”） 　16.4 多对一和一对一关联的检索策略 　16.4.1 迫切左外连接检索（fetch...

    学生管理系统 JSP+Struts+hibernate

    通过Hibernate的HQL（Hibernate Query Language）或 Criteria API，我们可以编写更加简洁、易读的查询语句。 在实际项目中，这三者协同工作，形成了一种高效的开发模式。当用户通过浏览器发送请求时，JSP页面将请求...

    Hibernate的Criteria用法总结.doc

    Hibernate 的 Criteria 是一个完全面向对象、可扩展的条件查询 API，通过它完全不需要考虑数据库底层如何实现、SQL 语句如何实现。Criteria 提供了灵活的查询条件组装方式，能够满足开发中复杂的查询需求。 一、...

    struts1.2+spring+hibernate 简单的实现

    在多表维护中，Hibernate通过HQL（Hibernate查询语言）或Criteria API来执行复杂的关联查询。 关于Excel报表生成，这通常涉及到Apache POI库，一个用于读写Microsoft Office格式文件的Java库。在这个项目中，可能是...

    Hibernate实战(第2版 中文高清版)

    　14.3 联结、报表查询和子查询　 　14.3.1 联结关系和关联　 　14.3.2 报表查询　 　14.3.3 利用子查询　 　14.4 小结　 　第15章 高级查询选项　 　15.1 利用条件和示例查询　 　15.1.1 基本的条件查询　 　15.1.2...

    java之hibernate和spring技术难点及其要点总结

    - **离线查询**：在不连接数据库的情况下预编译查询语句。 - **复合查询**：组合多个查询条件。 - **分页查询**：对查询结果进行分页处理。 3. **`createSQLQuery` 的用法**：该方法允许开发者直接执行原生SQL...

    springmvc+Hibernate配置定时器jar包

    通过Hibernate，开发者可以使用Java对象来操作数据库，而无需编写SQL语句。Hibernate支持实体类、映射文件（hibernate.cfg.xml或注解）、Session工厂和Session接口，使得数据库操作更加便捷。在Spring MVC中，可以...

    hibernate实战(Java Persistence With Hibernate.pdf )

    Hibernate提供了自己的查询语言HQL（Hibernate Query Language），它类似于SQL，但面向对象。此外，还有Criteria API，这是一种更加面向对象的查询方式。这两者使得开发者能以更高级的方式检索和操作数据，避免了...

    Hibernate案例：办公自动系统

    - 查询优化：利用缓存机制提高性能，或者通过HQL和Criteria API编写高效的查询语句。 在这个"办公自动系统"案例中，开发者不仅可以深入学习Hibernate的基本用法，还能了解如何将ORM技术应用于实际项目，提升开发...

    quee快逸报表的实例

    2. **数据源配置**：设置报表所需的数据源，可能需要编写SQL查询语句或利用ORM框架（如Hibernate）获取数据。 3. **报表设计**：在"quee快逸报表"的设计器中创建报表模板，定义数据字段、样式和布局。 4. **后台处理...

    struts2+hibernate汽车租赁系统

    【carmanage.sql】这个文件很可能包含了系统所需的数据库脚本，用于创建汽车租赁系统的数据表结构，初始化数据，或者设置一些初始的查询语句和存储过程。初学者可以通过运行这个SQL文件了解系统的数据库设计。 ...

    Hibernate中Criteria的完整用法.docx

    Hibernate 中 Criteria 的完整用法是 Hibernate 框架中的一种查询机制，允许开发者灵活地根据查询条件来组装查询语句。在使用 Spring 和 Hibernate 进行开发时，Criteria 的优势尤为明显。本文将对 Hibernate 中 ...

    iReport+Hibernate+SubReport

    Hibernate提供了一种无需编写SQL语句即可操作数据库的方式，使得开发过程更加高效。 【SubReport】是iReport中的一个重要概念，它允许在一个报表中嵌套另一个报表。这种方式在处理复杂的数据结构时特别有用，例如，...

    企业人事管理系统Java Swing+Hibernate+Oracal

    在企业人事管理系统中，Hibernate负责将业务对象（如员工、部门等）映射到数据库表，通过HQL（Hibernate Query Language）或SQL语句进行数据查询和操作，减少了大量手动编写数据库操作代码的工作量。 Oracle数据库...

    Hibernate中Criteria的完整用法

    Hibernate中的Criteria API是一种用于执行动态查询的机制，它允许开发者在运行时构建SQL查询，而无需直接编写SQL语句。Criteria API提供了更加面向对象的方式来处理数据库查询，这使得代码更易于理解和维护，尤其是...

    ireport300教程，含框架（IReport+spring+hibernate）

    IReport可以通过Hibernate的实体类来构建报表查询，这极大地提高了开发效率。 6. **报表部署和展示**：完成报表设计后，你可以将其嵌入到Spring MVC或Spring Boot的应用中，通过HTTP请求动态生成报表。同时，也可以...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part4

    　16.3.5 用带子查询的select语句整批量初始化orders集合（fetch属性为“subselect”） 　16.3.6 迫切左外连接检索（fetch属性为“join”） 　16.4 多对一和一对一关联的检索策略 　16.4.1 迫切左外连接检索（fetch...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part3

    　16.3.5 用带子查询的select语句整批量初始化orders集合（fetch属性为“subselect”） 　16.3.6 迫切左外连接检索（fetch属性为“join”） 　16.4 多对一和一对一关联的检索策略 　16.4.1 迫切左外连接检索（fetch...

Magicbox
Global site tag (gtag.js) - Google Analytics