hql查询总结

最新推荐文章于 2021-03-13 10:39:33 发布
最新推荐文章于 2021-03-13 10:39:33 发布
阅读量441 收藏
点赞数
文章标签： string object list interceptor java query
以以个普通Users表为例：
建表语句：
Java代码 复制代码  收藏代码
  1. CREATE DATABASE `interceptor`   
  2. CHARACTER SET 'utf8';   
  3.   
  4. USE `interceptor`;   
  5.   
  6. DROP TABLE IF EXISTS `users`;   
  7. create table users(   
  8.     id int auto_increment primary key,   
  9.     name varchar(10) not null,   
  10.     passwd varchar(10) not null  
  11. )ENGINE=InnoDB DEFAULT CHARSET=utf8;  
CREATE DATABASE `interceptor`
CHARACTER SET 'utf8';

USE `interceptor`;

DROP TABLE IF EXISTS `users`;
create table users(
	id int auto_increment primary key,
	name varchar(10) not null,
	passwd varchar(10) not null
)ENGINE=InnoDB DEFAULT CHARSET=utf8;



User.java:
Java代码 复制代码  收藏代码
  1. package com.domain;   
  2.   
  3. public class Users implements java.io.Serializable {   
  4.   
  5.     private Integer id;   
  6.   
  7.     private String name;   
  8.   
  9.     private String passwd;   
  10.   
  11.     public Users() {   
  12.     }   
  13.   
  14.     public Users(String name, String passwd) {   
  15.         this.name = name;   
  16.         this.passwd = passwd;   
  17.     }   
  18.   
  19.     public Integer getId() {   
  20.         return this.id;   
  21.     }   
  22.   
  23.     public void setId(Integer id) {   
  24.         this.id = id;   
  25.     }   
  26.   
  27.     public String getName() {   
  28.         return this.name;   
  29.     }   
  30.   
  31.     public void setName(String name) {   
  32.         this.name = name;   
  33.     }   
  34.   
  35.     public String getPasswd() {   
  36.         return this.passwd;   
  37.     }   
  38.   
  39.     public void setPasswd(String passwd) {   
  40.         this.passwd = passwd;   
  41.     }   
  42.   
  43. }  
package com.domain;

public class Users implements java.io.Serializable {

	private Integer id;

	private String name;

	private String passwd;

	public Users() {
	}

	public Users(String name, String passwd) {
		this.name = name;
		this.passwd = passwd;
	}

	public Integer getId() {
		return this.id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPasswd() {
		return this.passwd;
	}

	public void setPasswd(String passwd) {
		this.passwd = passwd;
	}

}


User.hbm.xml:

Java代码 复制代码  收藏代码
  1.   
  2. <?xml version="1.0" encoding="utf-8"?>   
  3. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">   
  5. <hibernate-mapping>   
  6.     <class name="com.domain.Users" table="users" catalog="interceptor">   
  7.         <id name="id" type="java.lang.Integer">   
  8.             <column name="id" />   
  9.             <generator class="native" />   
  10.         </id>   
  11.         <property name="name" type="java.lang.String">   
  12.             <column name="name" length="10" not-null="true" />   
  13.         </property>   
  14.         <property name="passwd" type="java.lang.String">   
  15.             <column name="passwd" length="10" not-null="true" />   
  16.         </property>   
  17.     </class>   
  18. </hibernate-mapping>  
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.domain.Users" table="users" catalog="interceptor">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="name" length="10" not-null="true" />
        </property>
        <property name="passwd" type="java.lang.String">
            <column name="passwd" length="10" not-null="true" />
        </property>
    </class>
</hibernate-mapping>

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. //查询单个字段   
  3.         String hql = " select name from Users";   
  4.         Query query = session.createQuery(hql);   
  5.            
  6.         List<String> list = query.list();   
  7.         for(String str : list){   
  8.             System.out.println(str);   
  9.         }   
  10. 输出结果为：   
  11. name1   
  12. name2   
  13. 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. //查询其中几个字段   
  3.         String hql = " select name,passwd from Users";   
  4.         Query query = session.createQuery(hql);   
  5.         //默认查询出来的list里存放的是一个Object数组   
  6.         List<Object[]> list = query.list();   
  7.         for(Object[] object : list){   
  8.             String name = (String)object[0];   
  9.             String passwd = (String)object[1];   
  10.                
  11.             System.out.println(name + " : " + passwd);   
  12.         }   
  13. 输出结果为：   
  14. name1 : password1   
  15. name2 : password2   
  16. 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形式返回
Java代码 复制代码  收藏代码
  1. //查询其中几个字段,添加new list(),注意list里的l是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是List集合了   
  2.         String hql = " select new list(name,passwd) from Users";   
  3.         Query query = session.createQuery(hql);   
  4.         //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是List集合了   
  5.         List<List> list = query.list();   
  6.         for(List user : list){   
  7.             String name = (String)user.get(0);   
  8.             String passwd = (String)user.get(1);   
  9.                
  10.             System.out.println(name + " : " + passwd);   
  11.         }   
  12.         /**  
  13.         输出结果为：  
  14.         name1 : password1  
  15.         name2 : password2  
  16.         name3 : password3  
  17.          */  
//查询其中几个字段,添加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.   
  2. //查询其中几个字段,添加new map(),注意map里的m是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是map集合了   
  3.         String hql = " select new map(name,passwd) from Users";   
  4.         Query query = session.createQuery(hql);   
  5.         //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是Map集合了   
  6.         List<Map> list = query.list();   
  7.         for(Map user : list){   
  8.             //一条记录里所有的字段值都是map里的一个元素,key是字符串0,1,2,3....，value是字段值   
  9.             //如果将hql改为：String hql = " select new map(name as username,passwd as password) from Users";,那么key将不是字符串0,1,2...了，而是"username","password"了   
  10.             String name = (String)user.get("0");//get("0");是get(key),注意:0,1,2...是字符串，而不是整形   
  11.             String passwd = (String)user.get("1");   
  12.                
  13.             System.out.println(name + " : " + passwd);   
  14.         }   
  15.         /**  
  16.         输出结果为：  
  17.         name1 : password1  
  18.         name2 : password2  
  19.         name3 : password3  
  20.          */  
//查询其中几个字段,添加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.   
  2. package com.domain;   
  3.   
  4. public class MyUser {   
  5.   
  6.     private String username;   
  7.     private String password;   
  8. //因为：String hql = " select new  com.domain.MyUser(name,passwd) from Users";所以必须要有接受2个参数的构造函数   
  9.     public MyUser(String username,String password){   
  10.         this.username = username;   
  11.         this.password = password;   
  12.     }   
  13.        
  14.     public String getUsername() {   
  15.         return username;   
  16.     }   
  17.     public void setUsername(String username) {   
  18.         this.username = username;   
  19.     }   
  20.     public String getPassword() {   
  21.         return password;   
  22.     }   
  23.     public void setPassword(String password) {   
  24.         this.password = password;   
  25.     }   
  26.        
  27.        
  28. }  
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.   
  2. //通过query.list()出来的list里存放的不再是默认的Object数组了,而是自定义的类MyUser,必须加包名，String hql = "from Users";中的Users类也是必须加包名的，但是因为再Users.hbm.xml里<hibernate-mapping auto-import="true"> auto-import默认值为true（所以auto-import属性也可以不写）,自动导入了   
  3.         String hql = " select new  com.domain.MyUser(name,passwd) from Users";   
  4.         Query query = session.createQuery(hql);   
  5.         //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是MyUser对象了   
  6.         List<MyUser> myUsers = query.list();   
  7.         for(MyUser myUser : myUsers){   
  8.             String name = myUser.getUsername();   
  9.             String passwd = myUser.getPassword();   
  10.             System.out.println(name + " : " + passwd);   
  11.         }   
  12.         /**  
  13.         输出结果为：  
  14.         name1 : password1  
  15.         name2 : password2  
  16.         name3 : password3  
  17.          */  
//通过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.         }   
  14.           
//条件查询，参数索引值从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.         } 

mutu_du
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HQL 语法总结 实体查询
09-21
HQL 例如对于TUser类 1.实体查询 String hql = " from TUser"; HQL 语法总结
HQL连接查询和注解使用总结
07-11
HQL是指定连接查询方式，而且显式指定了关联级别的查询策略
hibernate——HQL查询总结
程序员小哲的博客
04-24 9375
hibernate——HQL查询总结HQL概述:HQL的简单查询HQL的别名查询:HQL的多态查询:HQL的排序查询:HQL的分页查询:HQL检索单个对象:HQL的条件查询:HQL使用聚集函数:HQL分组统计:HQL的投影查询: HQL概述: HQL(Hibernate Query Language) 是面向对象的查询语言, 它和 SQL 查询语言有些相似. 在 Hibernate 提供的各种检索...
java hql 查询所有内容,HQL查询语言<转载>
weixin_39640203的博客
03-13 686
上一章介绍了Hibernate的关联映射，在11章的例子中接触到了Hibernate的添加、查询和删除的操作。这一章将介绍Hibernate。Hibernate查询语言为HQL(HibernateQueryLanguage)，可以直接使用实体类名及属性。HQL语法类似于SQL，有SQL的关键词如select、from、orderby、count()、where等等。12.1HQL语言基础H...
java hql查询_Spring 中常用的hql查询方法(getHibernateTemplate())(转)
weixin_42497828的博客
03-04 237
示例：this.getHibernateTemplate().find(”from bean.User”);返回所有User对象二、find(String queryString , Object value);示例：this.getHibernateTemplate().find(”from bean.User u whereu.name=?”, “test”);或模糊查询：this.getHi...
java hql查询_Hibernate的查询 HQL查询 查询某几列
weixin_29959015的博客
02-12 157
HQL 是Hibernate Query Language的简写，即 hibernate 查询语言：HQL采用面向对象的查询方式。HQL查询提供了更加丰富的和灵活的查询特性，因此Hibernate将HQL查询方式立为官方推荐的标准查询方式，HQL查询在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装。在HQL中，你可以直接From你的实...
JAVA Hibernate HQL查询、详解
草根的理想
10-28 3378
本文转载自：http://hi.baidu.com/ceoct/blog/item/7dbf2210504501cba6ef3f78.html    Hibernate Query Language（HQL）提供了十分强大的功能，推荐大家使用这种查询方式。HQL具有与SQL语言类似的语法规范，只不过SQL针对表中字段进行查询，而HQL针对持久化对象，它用来取得对象，而不进行update、dele
Hibernate hql查询语法总结
06-09
本文将对Hibernate HQL查询语法进行总结，涵盖基础查询、属性查询、实例化查询以及查询链接等多个方面。 1. 基础查询： 基础查询是最简单的HQL语句，用于获取所有`Student`对象。例如： ```java from Student ``` ...
Hiberbate hql总结
12-18
默认情况下，HQL查询返回的结果是`Object[]`数组，但你可以通过创建一个新的实例来改变这个行为。例如，如果你想让结果直接是一个包含多个字段值的`List`，可以这样做： ```java String hql = "select new list...
Hibernate 查询方式总结
10-30
get() and load() HQL 等查询方式
Hibernate注解方式、HQL查询
08-17
Hibernate注解方式、HQL查询
java SSH第一章学习内容（HQL查询）
JayVergil的博客
08-23 300
HQL：查询日志 8个例子 例子准备工作 1.先自动生成实体类以及DAO类 2.创建一个HqlSelect类继承UserDAO，用于直接调用Session使用 3.测试类调用HqlSelect类方法注意：query.uniqueResult().toString()使用查询一行数据，query.list()结果集的数据            q.setInteger(1, 10);    mysq...
hibernate-hql查询
登峰小蚁
10-04 6801
select可以省略，但不建议这么做，尽量做到查询精确。 hql是面向对象的不管返回值还是条件都是对对象而言，不是数据库表。数据库中的一条记录就是一个对象。 1、根据条件查询某个具体对象 Student s = (Student) session.createQuery("select s from Student s where s.id=2").uniqueResult(); uniq...
hibernate中一对多关系hql条件查询
Stand by
11-10 6992
当hibernate中难免遇到一对多的情况,并且需要对多方添加条件,使用sql查询会简单很多,hql的语法如下 Teacher对应下有多个Student Teacher中Set students; select t from Teacher t,Student s where t.tNo ='001' and s.sName like '张%' and s in elements(t
Java JPA通过hql语句查询数据
a54325的博客
03-27 389
import javax.persistence.PersistenceContext; import javax.persistence.Query; public class StudentServiceImpl { @PersistenceContext private EntityManager entityManager; ...
Java hibernate HQL查询（全部查询，参数查询，模糊查询，投影查询）
念着倒障智
08-01 2203
Student.java类 package cn.com.edu; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.p...
hibernate的HQL查询语言总结
tuke_tuke的博客
11-11 3441
HQL是Hibernate Query Language的缩写，HQL的语法很像SQL的语法，但HQL是一种面向对象的查询语言。因此，SQL的操作对象是数据表和列等数据对象，而HQL的操作对象是类、实例、属性等。 HQL是完全面向对象的查询语言，因此可以支持继承和多态等特征 HQL查询的步骤： 1，获取 Hibernate Session 对象。 2，编写HQL语句。 3
HQL连接查询与左外连接详解
在提供的示例中，`createQuery`方法被用来执行一个HQL查询，从`Prj`（项目）对象关联到`joinedEmp`（参与员工）集合。 2. **HQL左外连接**： 左外连接（LEFT JOIN）在HQL中被用来包含所有左表（在上述例子中是`Prj...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值