HQL查询
package org.leadfar.hibernate.model;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import junit.framework.TestCase;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.ScrollMode;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.AliasToBeanConstructorResultTransformer;
import org.hibernate.transform.AliasToBeanResultTransformer;
import org.leadfar.hibernate.Transfer.MyTransformer;
import org.leadfar.hibernate.web.VO.PersonVO;
import org.leadfar.hibernate.web.VO.PersonVOTrans;
public class TestHQL extends TestCase {
public void save_01() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
Random r = new Random();
for(int i=0;i<100;i++) {
ContactPerson cp = new ContactPerson("李四"+i);
cp.setAge(r.nextInt(99));
cp.setBirthday(new Date());
session.save(cp);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_01() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//类名、属性名对大小写敏感，关键字对大小写不敏感
//使用占位符?并给参数赋值，索引从0开始，赋值顺序严格按照顺序进行赋值，保证类型正确
String hql = "select n FroM ContactPerson n where n.age between ? and ?";
List<ContactPerson> cps = session.createQuery(hql)
.setParameter(0, 10)
.setParameter(1, 20)
.list();
for(ContactPerson cp : cps ) {
System.out.println(cp.getName()+","+cp.getAge());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_02() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//使用命名参数,参数赋值属性任意，保证赋值数据的类型正确
String hql = "select n from ContactPerson n where n.name like :mz and n.age between :lage and :mage";
List<ContactPerson> cps = session.createQuery(hql)
.setParameter("lage", 10)
.setParameter("mage", 20)
.setParameter("mz", "张三6%")
.list();
for(ContactPerson cp : cps ) {
System.out.println(cp.getName()+","+cp.getAge());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_03() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//使用命名参数传递集合数据到查询语句中
String hql = "select n from ContactPerson n where n.age in (:ages)";
Integer[] ages = {15,20,32};
List<ContactPerson> cps = session.createQuery(hql)
.setParameterList("ages", ages)
.list();
for(ContactPerson cp : cps ) {
System.out.println(cp.getName()+","+cp.getAge());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_04() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//使用命名参数传递集合数据到查询语句中
String hql = "select n from ContactPerson n where n.name in (:names)";
List<String> names = new ArrayList<String>();
names.add("张三1");
names.add("张三9");
List<ContactPerson> cps = session.createQuery(hql)
.setParameterList("names", names)
.list();
for(ContactPerson cp : cps ) {
System.out.println(cp.getName()+","+cp.getAge()+","+cp.getBirthday());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_05() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//对null值的查询使用 is null
String hql = "select n from ContactPerson n where n.group is null";
List<ContactPerson> cps = session.createQuery(hql).list();
for(ContactPerson cp : cps ) {
System.out.println(cp.getName()+","+cp.getAge());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_06() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//查询部分属性--投影查询---如果不是全字段查询，那么得到的将不是ContactPerson对象，结果为一个Object[]
String hql = "select n.name,n.age from ContactPerson n where n.age between :lage and :mage";
List<Object[]> cps = session.createQuery(hql)
.setParameter("lage", 10)
.setParameter("mage", 30)
.list();
for(Object[] cp : cps ) {
System.out.println((String)cp[0]+","+(Integer)cp[1]);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_07() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//唯一结果--uniqueResult
String hql = "select count(*) from ContactPerson n";
long rowCount = (Long)session.createQuery(hql).uniqueResult();
System.out.println(rowCount);
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_08() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//唯一结果--uniqueResult(结果只能为0条或1条的情况下使用)
String hql = "select n.age,n.birthday from ContactPerson n where n.id = 1";
Object[] obj = (Object[])session.createQuery(hql).uniqueResult();
if(obj!=null) {
System.out.println((Integer)obj[0]);
System.out.println((Date)obj[1]);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_09() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//查询结果的转化---转化为类的属性，再使用对象获取属性，避免通过下标访问元素的麻烦
String hql = "select new ContactPerson(n.id,n.age,n.name) from ContactPerson n where id > :lid and id < :mid";
List<ContactPerson> cps = session.createQuery(hql)
.setParameter("lid", 10)
.setParameter("mid", 20)
.list();
for(ContactPerson cp : cps) {
System.out.println(cp.getId()+","+cp.getAge()+","+cp.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_10() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//查询结果的转化---转化为类的属性，再使用对象获取属性，避免通过下标访问元素的麻烦
String hql = "select new org.leadfar.hibernate.web.VO.PersonVO(n.name,n.age,n.birthday) from ContactPerson n where id > :lid and id < :mid";
List<PersonVO> cps = session.createQuery(hql)
.setParameter("lid", 10)
.setParameter("mid", 20)
.list();
for(PersonVO cp : cps) {
System.out.println(cp.getName()+","+cp.getAge()+","+cp.getBirthday());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_11() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//查询结果的转化---转化为类的属性，再使用对象获取属性，避免通过下标访问元素的麻烦
String hql = "select new map(n.name as name,n.age as age,n.birthday as birthday) from ContactPerson n where id > :lid and id < :mid";
List<Map> cps = session.createQuery(hql)
.setParameter("lid", 10)
.setParameter("mid", 20)
.list();
for(Map map : cps) {
System.out.println(map);
}
//获取entry,在获取可以对应的value
for(Map map : cps) {
Iterator it = map.entrySet().iterator();
while(it.hasNext()) {
Map.Entry entry = (Map.Entry)it.next();
System.out.print(entry.getKey()+":"+entry.getValue());
System.out.print("\t");
}
System.out.println();
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_12() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//查询结果的转化---转化为map
String hql = "select new map(n.name as name,n.age as age,n.birthday as birthday) from ContactPerson n where id > :lid and id < :mid";
List<Map> cps = session.createQuery(hql)
.setParameter("lid", 10)
.setParameter("mid", 20)
.list();
for(Map map : cps) {
System.out.println(map);
}
//获取entry,在获取可以对应的value
for(Map map : cps) {
System.out.println(map.get("name")+","+map.get("age")+","+map.get("birthday"));
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_13() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//求总记录数
String hql = "select count(*) from ContactPerson n ";
Query query = session.createQuery(hql);
long rowCount = (Long)query.uniqueResult();
System.out.println("总记录数:"+rowCount);
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_14() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//分页
String hql = "select n from ContactPerson n ";
Query query = session.createQuery(hql);
query.setFirstResult(0);//0表示从查询结果的第一条记录开始
query.setMaxResults(5);//一次最大返回记录数(最后一页如果小于5条，则有几条返回几条)
List<ContactPerson> cps = query.list();
for(ContactPerson cp : cps) {
System.out.println(cp.getId()+","+cp.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_15() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//使用iterate()方法查询实体对象，会发生N+1问题---根源：hibernate缓存策略
String hql = "select n from ContactPerson n ";
Query query = session.createQuery(hql);
query.setFirstResult(0);//0表示从查询结果的第一条记录开始
query.setMaxResults(5);//一次最大返回记录数(最后一页如果小于5条，则有几条返回几条)
Iterator<ContactPerson> it = query.iterate();
while(it.hasNext()) {
ContactPerson cp = it.next();
System.out.println(cp.getId()+","+cp.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_16() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//使用iterate()方法查询 非实体 对象，与使用list()没有区别--只发出一条查询语句
String hql = "select new ContactPerson(n.id,n.name) from ContactPerson n ";
Query query = session.createQuery(hql);
query.setFirstResult(0);//0表示从查询结果的第一条记录开始
query.setMaxResults(5);//一次最大返回记录数(最后一页如果小于5条，则有几条返回几条)
Iterator<ContactPerson> it = query.iterate();
while(it.hasNext()) {
ContactPerson cp = it.next();
System.out.println(cp.getId()+","+cp.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_17() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//使用游标进行查询---表特别大时使用
String hql = "select new ContactPerson(n.id,n.name) from ContactPerson n ";
Query query = session.createQuery(hql);
query.setFirstResult(0);//0表示从查询结果的第一条记录开始
query.setMaxResults(5);//一次最大返回记录数(最后一页如果小于5条，则有几条返回几条)
ScrollableResults results = query.scroll(ScrollMode.SCROLL_SENSITIVE);
while(results.next()) {
ContactPerson cp = (ContactPerson)results.get(0);
System.out.println(cp.getId()+","+cp.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
/////////标准化对象查询//////////////////////////
public void HQL_18() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//相当于select n from ContactPerson n
Criteria criteria = session.createCriteria(ContactPerson.class);
//相当于where name like "%1%"
criteria.add(
Restrictions.like("name", "%1%")
);
List<ContactPerson> cps = criteria.list();
for(ContactPerson cp :cps) {
System.out.println(cp.getId()+","+cp.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_19() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个，需要判断是否为NULL才能决定最终的查询语句
ContactPerson condition = new ContactPerson();
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
//如果name属性不为空，则添加对name的查询条件
if(condition.getName()!=null) {//MatchMode.ANYWHERE 构建查询语句时会自动加上"%%"
criteria.add(Restrictions.like("name", condition.getName(),MatchMode.ANYWHERE));
}
if(condition.getBirthday()!=null) {
criteria.add(Restrictions.eq("birthday", condition.getBirthday()));
}
if(condition.getAge()>0) {
criteria.add(Restrictions.lt("age", new Integer(condition.getAge())));
}
List<ContactPerson> cps = criteria.list();
for(ContactPerson c :cps) {
System.out.println(c.getId()+","+c.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_20() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个
//hibernate会自动将属性非NULL的作为查询条件，其中id不论有没有值，都被忽略
ContactPerson condition = new ContactPerson();
//condition.setId(10);//id属性会被忽略，不会作为查询条件
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
criteria.add(
Example.create(condition)
.enableLike(MatchMode.ANYWHERE)//所有字符串，如果不为NULL，则进行模糊查询条件
.excludeZeroes()//所有取0的值，不被作为查询条件
.excludeProperty("address") //不论address属性是否为null，都不作为构建查询条件
);
List<ContactPerson> cps = criteria.list();
for(ContactPerson c :cps) {
System.out.println(c.getId()+","+c.getName());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_21() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个
//hibernate会自动将属性非NULL的作为查询条件，其中id不论有没有值，都被忽略
ContactPerson condition = new ContactPerson();
//condition.setId(10);//id属性会被忽略，不会作为查询条件
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
criteria.add(
Example.create(condition)
.enableLike(MatchMode.ANYWHERE)//所有字符串，如果不为NULL，则进行模糊查询条件
.excludeZeroes()//所有取0的值，不被作为查询条件
.excludeProperty("address") //不论address属性是否为null，都不作为构建查询条件
);
//select name 查询单个属性
criteria.setProjection(
Projections.property("name")
);
List<String> names = criteria.list();
for(String name : names) {
System.out.println(name);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_22() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个
//hibernate会自动将属性非NULL的作为查询条件，其中id不论有没有值，都被忽略
ContactPerson condition = new ContactPerson();
//condition.setId(10);//id属性会被忽略，不会作为查询条件
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
criteria.add(
Example.create(condition)
.enableLike(MatchMode.ANYWHERE)//所有字符串，如果不为NULL，则进行模糊查询条件
.excludeZeroes()//所有取0的值，不被作为查询条件
.excludeProperty("address") //不论address属性是否为null，都不作为构建查询条件
);
//select name,age,birthday 查询多个属性
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("name"))
.add(Projections.property("age"))
.add(Projections.property("birthday"))
);
List<Object[]> objs = criteria.list();
for(Object[] obj : objs) {
System.out.println(obj[0]+","+obj[1]+","+obj[2]);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_23() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个
//hibernate会自动将属性非NULL的作为查询条件，其中id不论有没有值，都被忽略
ContactPerson condition = new ContactPerson();
//condition.setId(10);//id属性会被忽略，不会作为查询条件
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
criteria.add(
Example.create(condition)
.enableLike(MatchMode.ANYWHERE)//所有字符串，如果不为NULL，则进行模糊查询条件
.excludeZeroes()//所有取0的值，不被作为查询条件
.excludeProperty("address") //不论address属性是否为null，都不作为构建查询条件
);
//select name,age,birthday 查询多个属性
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("name"),"p_name")
.add(Projections.property("age"),"p_age")
.add(Projections.property("birthday"),"p_birthday")
);
//转化结果为Map类型
//需要为属性取别名 alias ---限制：别名不能与属性名相同
criteria.setResultTransformer(CriteriaSpecification.ALIAS_TO_ENTITY_MAP);
List<Map> objs = criteria.list();
for(Map obj: objs) {
System.out.println(obj);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_24() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个
//hibernate会自动将属性非NULL的作为查询条件，其中id不论有没有值，都被忽略
ContactPerson condition = new ContactPerson();
//condition.setId(10);//id属性会被忽略，不会作为查询条件
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
criteria.add(
Example.create(condition)
.enableLike(MatchMode.ANYWHERE)//所有字符串，如果不为NULL，则进行模糊查询条件
.excludeZeroes()//所有取0的值，不被作为查询条件
.excludeProperty("address") //不论address属性是否为null，都不作为构建查询条件
);
//select name,age,birthday 查询多个属性
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("name"),"name")
.add(Projections.property("age"),"age")
.add(Projections.property("birthday"),"birthday")
);
//转化结果为VO
//需要为属性取别名 alias ---限制：别名不能与属性名相同
//不取别名：[could not execute query]
//VO中的setters方法需要与别名一致 ，即Property与别名一致
//setters的property不一致：[Could not find setter for p_name on class org.leadfar.hibernate.web.VO.PersonVO]
//另一种办法：自定义一个转化类将别名转化为与property一致的名称，然后就行了
criteria.setResultTransformer(new AliasToBeanResultTransformer(PersonVO.class));
List<PersonVO> objs = criteria.list();
for(PersonVO obj: objs) {
System.out.println(obj);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_25() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个
//hibernate会自动将属性非NULL的作为查询条件，其中id不论有没有值，都被忽略
ContactPerson condition = new ContactPerson();
//condition.setId(10);//id属性会被忽略，不会作为查询条件
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
criteria.add(
Example.create(condition)
.enableLike(MatchMode.ANYWHERE)//所有字符串，如果不为NULL，则进行模糊查询条件
.excludeZeroes()//所有取0的值，不被作为查询条件
.excludeProperty("address") //不论address属性是否为null，都不作为构建查询条件
);
//select name,age,birthday 查询多个属性
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("name"),"p_name")
.add(Projections.property("age"),"p_age")
.add(Projections.property("birthday"),"p_birthday")
);
//转化结果为VO
//需要为属性取别名 alias ---限制：别名不能与属性名相同
//不取别名：[could not execute query]
//VO中的setters方法需要与别名一致 ，即Property与别名一致
//setters的property不一致：[Could not find setter for p_name on class org.leadfar.hibernate.web.VO.PersonVO]
//----------------------------------------------------------------
//另一种办法：自定义一个转化类将别名转化为与property一致的名称，然后就行了
//依赖于setters方法，转化后就能通过setters方法进行赋值，然后VO对象将结果进行包装
//注:通过转化类将别名设置为与property一致的名称，而没有改变VO中的property名称！！！
criteria.setResultTransformer(new MyTransformer(PersonVOTrans.class));
List<PersonVOTrans> objs = criteria.list();
for(PersonVOTrans obj: objs) {
System.out.println(obj.getName()+","+obj.getBirthday());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_26() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
//模拟从页面传入查询参数，有可能有多个，有可能只有一个
//hibernate会自动将属性非NULL的作为查询条件，其中id不论有没有值，都被忽略
ContactPerson condition = new ContactPerson();
//condition.setId(10);//id属性会被忽略，不会作为查询条件
condition.setName("李四");
condition.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("2012-9-14"));
condition.setAge(20);
Criteria criteria = session.createCriteria(ContactPerson.class);
criteria.add(
Example.create(condition)
.enableLike(MatchMode.ANYWHERE)//所有字符串，如果不为NULL，则进行模糊查询条件
.excludeZeroes()//所有取0的值，不被作为查询条件
.excludeProperty("address") //不论address属性是否为null，都不作为构建查询条件
);
//select name,age,birthday 查询多个属性
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("name"))
.add(Projections.property("age"))
.add(Projections.property("birthday"))
);
//----------------------------------------------------------------
//转化结果为VO---不需要为属性取别名
criteria.setResultTransformer(
new AliasToBeanConstructorResultTransformer(
PersonVO.class.getConstructor(String.class,Integer.class,Date.class)
)
);
List<PersonVO> objs = criteria.list();
for(PersonVO obj: objs) {
System.out.println(obj.getName()+","+obj.getBirthday());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
////////////////////////////原生SQL//////////////////
public void HQL_27() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
String sql = "select * from t_person";
SQLQuery query = session.createSQLQuery(sql);
List<Object[]> obj = query.list();
for(Object[] o : obj) {
System.out.println(o[0]+","+o[1]+","+o[2]);
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_28() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
String sql = "select * from t_person";
SQLQuery query = session.createSQLQuery(sql);
//包装为实体对象，必须是全字段查询。部分属性查询不能使用对象进行包装
query.addEntity(ContactPerson.class);
List<ContactPerson> obj = query.list();
for(ContactPerson o : obj) {
System.out.println(o.getName()+","+o.getAge()+","+o.getBirthday());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_29() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
//基于对象的标准化查询，以对象的方式替代sql语句
String sql = "select name,age from t_person";
SQLQuery query = session.createSQLQuery(sql);
//包装为实体对象，必须是全字段查询。
//部分属性查询不能使用对象进行包装
//属性与字段名必须一致
query.addEntity(ContactPerson.class);
List<ContactPerson> obj = query.list();
for(ContactPerson o : obj) {
System.out.println(o.getName()+","+o.getAge()+","+o.getBirthday());
}
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();//session关闭之后，user对象处于离线Detached状态
}
}
public void HQL_30() throws Exception {
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
try {
//开启事务
session.beginTransaction();
String sql = "update t_person set birthday = ? where id < ?";
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, new Date());
query.setParameter(1, 30);
//update,delete,insert
query.executeUpdate();
//提交事务
session.getTransaction().commit();
} catch(Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();
}
}
}
VO
package org.leadfar.hibernate.web.VO;
import java.text.SimpleDateFormat;
import java.util.Date;
public class PersonVO {
private SimpleDateFormat format = new SimpleDateFormat("yy年MM月dd日");
private String name;
private int age;
private String birthday;
public PersonVO() {}
public PersonVO(String name, Integer age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = format.format(birthday);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
}
package org.leadfar.hibernate.web.VO;
import java.text.SimpleDateFormat;
import java.util.Date;
public class PersonVOTrans {
private String name;
private int age;
private Date birthday;
public PersonVOTrans() {}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
package org.leadfar.hibernate.Transfer;
import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.property.ChainedPropertyAccessor;
import org.hibernate.property.PropertyAccessor;
import org.hibernate.property.PropertyAccessorFactory;
import org.hibernate.property.Setter;
import org.hibernate.transform.ResultTransformer;
public class MyTransformer implements ResultTransformer, Serializable{
/**
*
*/
private static final long serialVersionUID = -8264738346888035746L;
private final Class resultClass;
private boolean isInitialized;
private String[] aliases;
private Setter[] setters;
public MyTransformer(Class resultClass) {
if ( resultClass == null ) {
throw new IllegalArgumentException( "resultClass cannot be null" );
}
isInitialized = false;
this.resultClass = resultClass;
}
public Object transformTuple(Object[] tuple, String[] aliases) {
Object result;
try {
if ( ! isInitialized ) {
initialize( aliases );
}
else {
check( aliases );
}
result = resultClass.newInstance();
for ( int i = 0; i < aliases.length; i++ ) {
if ( setters[i] != null ) {
setters[i].set( result, tuple[i], null );
}
}
}
catch ( InstantiationException e ) {
throw new HibernateException( "Could not instantiate resultclass: " + resultClass.getName() );
}
catch ( IllegalAccessException e ) {
throw new HibernateException( "Could not instantiate resultclass: " + resultClass.getName() );
}
return result;
}
private void initialize(String[] aliases) {
PropertyAccessor propertyAccessor = new ChainedPropertyAccessor(
new PropertyAccessor[] {
PropertyAccessorFactory.getPropertyAccessor( resultClass, null ),
PropertyAccessorFactory.getPropertyAccessor( "field" )
}
);
this.aliases = new String[ aliases.length ];
setters = new Setter[ aliases.length ];
for ( int i = 0; i < aliases.length; i++ ) {
String alias = aliases[ i ];
if ( alias != null ) {
this.aliases[ i ] = alias;
//setters[ i ] = propertyAccessor.getSetter( resultClass, alias );
//将别名转化为与PersonVO中的property一致的名称
setters[ i ] = propertyAccessor.getSetter( resultClass, alias.substring(2) );
}
}
isInitialized = true;
}
private void check(String[] aliases) {
if ( ! Arrays.equals( aliases, this.aliases ) ) {
throw new IllegalStateException(
"aliases are different from what is cached; aliases=" + Arrays.asList( aliases ) +
" cached=" + Arrays.asList( this.aliases ) );
}
}
public List transformList(List collection) {
return collection;
}
public boolean equals(Object o) {
if ( this == o ) {
return true;
}
if ( o == null || getClass() != o.getClass() ) {
return false;
}
MyTransformer that = ( MyTransformer ) o;
if ( ! resultClass.equals( that.resultClass ) ) {
return false;
}
if ( ! Arrays.equals( aliases, that.aliases ) ) {
return false;
}
return true;
}
public int hashCode() {
int result = resultClass.hashCode();
result = 31 * result + ( aliases != null ? Arrays.hashCode( aliases ) : 0 );
return result;
}
}
实体类
package org.leadfar.hibernate.model;
public class Group {
private int id;
private String name;
public Group() {
// TODO Auto-generated constructor stub
}
public Group(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package org.leadfar.hibernate.model;
import java.util.Date;
public class ContactPerson {
private int id;
private String name;
private int age;
private Date birthday;
private Group group;
public ContactPerson() {
}
public ContactPerson(String name) {
this.name = name;
}
public ContactPerson(int id,String name) {
this.id = id;
this.name = name;
}
public ContactPerson(int id,int age,String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="org.hibernate.auction"> <!-- name为实体类 table为映射到数据库中的表 lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)--> <class name="org.leadfar.hibernate.model.Group" table="t_group" > <!-- id为数据库标识，作为主键 --> <id name="id"> <generator class="native"/> </id> <property name="name"/> </class> </hibernate-mapping>
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="org.hibernate.auction"> <!-- name为实体类 table为映射到数据库中的表 lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)--> <class name="org.leadfar.hibernate.model.ContactPerson" table="t_person" > <!-- id为数据库标识，作为主键 --> <id name="id"> <generator class="native"/> </id> <property name="name"/> <property name="age"></property> <property name="birthday" type="date"></property> <many-to-one name="group" column="gid"></many-to-one> </class> </hibernate-mapping>
相关推荐
Hibernate中的查询：HQL、Criteria、原生SQl的Demo，希望可以帮助大家理解Hibernate查询。
使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
Hibernate支持强大且易于使用的面向对象查询语言(HQL)。 如果希望通过编程的方式创建查询，Hibernate... 你也可以用原生SQL(native SQL)描述Hibernate查询，Hibernate额外提供了将结果集(result set)转化为对象的支持。
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
原生SQL查询 13.1. 创建一个基于SQL的Query 13.2. 别名和属性引用 13.3. 为SQL查询命名 14. 性能提升（Improving performance） 14.1. 理解集合的性能 14.1.1. 分类 14.1.2. Lists, maps 和...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
11.4.4. 使用原生SQL的查询 11.5. 修改持久对象 11.6. 修改脱管(Detached)对象 11.7. 自动状态检测 11.8. 删除持久对象 11.9. 在两个不同数据库间复制对象 11.10. Session刷出(flush) 11.11. 传播性持久化...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
11.4.4. 使用原生SQL的查询 11.5. 修改持久对象 11.6. 修改脱管(Detached)对象 11.7. 自动状态检测 11.8. 删除持久对象 11.9. 在两个不同数据库间复制对象 11.10. Session刷出(flush) 11.11. 传播性持久化...
原生SQL查询 13.1. 创建一个基于SQL的Query 13.2. 别名和属性引用 13.3. 为SQL查询命名 14. 性能提升（Improving performance） 14.1. 理解集合的性能 14.1.1. 分类 14.1.2. Lists, maps 和...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
使用原生SQL的查询 11.5. 修改持久对象 11.6. 修改脱管(Detached)对象 11.7. 自动状态检测 11.8. 删除持久对象 11.9. 在两个不同数据库间复制对象 11.10. Session刷出(flush) 11.11. 传播性持久化...
10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出(flush) 10.11. 传播性持久化...
9.3.5. 使用原生SQL的查询 9.4. 修改持久化对象 9.4.1. 使用同一个ISession持久化对象 9.4.2. 修改脱管(Detached)对象 9.4.3. 重新附脱管(Detached)对像 9.5. 删除持久化对象 9.6. 刷出 9.7. 结束ISession 9.7.1. ...
9.3.5. 使用原生SQL的查询 9.4. 修改持久化对象 9.4.1. 使用同一个ISession持久化对象 9.4.2. 修改脱管(Detached)对象 9.4.3. 重新附脱管(Detached)对像 9.5. 删除持久化对象 9.6. 刷出 9.7. 结束ISession 9.7.1. ...
1.1.4. Hibernate 配置 .................................................. 7 1.1.5. 用 Maven 构建 .................................................. 9 1.1.6. 启动和辅助类 ..................................