Hibernate框架（二）

书接上回！

命名参数

：name即命名参数

表示了一个名为“name”的查询参数

根据此此参数名进行参数值设定

不需要依照特定的数序

例：

HQL常用聚合函数：

与SQL类似，HQL通过order by 子句实现对查询结果的排序

默认情况下按升序顺序排列

排序策略（asc升序、desc降序）

通过group by子句实现

并用having 子句对group by 返回的结果进行筛选

Query对象提供了简单分页方法

setFirstResult(int firstResult)方法

设置第一条记录的位置

setMaxResults(int maxResults)方法

设置最大返回的记录条数

HQL支持的联结类型

Hibernate对本地sql查询提供了内置的支持

Criteria查询才用面向对象方式封装查询条件，又称为对象查询

对sql语句进行封装

才用对象的方式来组合各种查询条件

有Hibernate自动产生sql查询语句

Criteria有Hibernate Session进行创建

例：

Restrictions常用限定查询方法

Criteria查询不仅能组合出sql中where子句的功能，还可以组合出排序查询功能

使用org.hibernate.criterion.Order对结果进行排序

排序方法为：

asc（）

desc（）

Criteria实现简单分页

setFirstResult( )方法

限定查询返回数据的行数

setMaxResults( )方法

限定查询返回结果的第一行数据的位置

简单的小例子：

package com.jredu.test;


import java.util.Iterator;
import java.util.List;
import java.util.ListResourceBundle;


import javax.swing.text.AbstractDocument.LeafElement;


import oracle.net.aso.i;
import oracle.net.aso.q;


import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;


import com.jredu.entity.B;
import com.jredu.entity.Stu;
import com.jredu.entity.User;


public class HqlTest {


private Session session;

@Before
public void setUp() throws Exception {
//1.读取并解析配置文件
Configuration cfg=new Configuration().configure();
//注册服务对象
StandardServiceRegistry registry=new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()).build();
//2.解析映射文件，创建SessionFactory
SessionFactory factory=cfg.buildSessionFactory(registry);
//3.打开session
session=factory.openSession();
}


@After
public void tearDown() throws Exception {
session.close();
}


@Test
public void test() {
//1.编写HQL语句
String hql="from User";
//2.创建Query对象
Query query=session.createQuery(hql);
//3.执行查询，得到结果
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test1() {
String hql="select u.name from User u where u.id=?";
//创建查询对象
Query query=session.createQuery(hql);
//传参,下标从0开始
//JDBC下标从1开始
query.setParameter(0, 1);
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test2() {
//命名参数，语法        :参数名字
String hql="select u.name from User u where u.id=:id";
Query query=session.createQuery(hql);
query.setParameter("id", 2);
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test3() {
//封装参数
String hql="select u.name from User u where 1=1";
User user=new User();
user.setId(1);

if(user.getId()>0) {
hql+=" and id=:id";
}
if(user.getName()!=null) {
hql+=" and name=:name";
}
Query query=session.createQuery(hql);
//传参
query.setProperties(user);
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test4() {
//分页查询
String hql="from User u";
Query query=session.createQuery(hql);
//查询 页码:1,分页大小：5
int page=2;
int pageSize=5;
query.setFirstResult((page-1)*pageSize);
query.setMaxResults(pageSize);
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test5() {
//hibernate子查询必须出现在where子句当中
//不要再hql当中使用*，可以使用别名代替*
//查询成绩>平均成绩的人的平均成绩
String hql="select stu from Stu stu where stu.score>"
+ "(select avg(s.score) from Stu s)";
Query query=session.createQuery(hql);
List<Stu> list=query.list();
System.out.println(list);
}

@Test
public void test6() {
//内链接
String hql="from B b inner join b.a a";
Query query = session.createQuery(hql);
List list=query.list();
Iterator iter=list.iterator();
while(iter.hasNext()) {
Object[] objs=(Object[]) iter.next();
for(int i=0;i<objs.length;i++) {
System.out.print(objs[i]+"#");
}
System.out.println("-------------");
}
// System.out.println(list);
}

@Test
public void test7() {
//内链接
String hql="from B b inner join fetch b.a a";
Query query = session.createQuery(hql);
List<B> list=query.list();
Iterator<B> iter=list.iterator();
while(iter.hasNext()) {
B b=iter.next();
System.out.println(b);
}
// System.out.println(list);
}

@Test
public void test8() {
String hql="from B b left join fetch b.a a";
Query query=session.createQuery(hql);
List<B> list=query.list();
System.out.println(list);
}

@Test
public void test9() {
String hql="from B b right join b.a a";
Query query=session.createQuery(hql);
List list=query.list();
Iterator iter=list.iterator();
while(iter.hasNext()) {
Object[] objs=(Object[]) iter.next();
for(int i=0;i<objs.length;i++) {
System.out.print(objs[i]);
}
System.out.println();
}
}

@Test
public void test10() {
Query query=session.getNamedQuery("leftjoin");
List<B> list=query.list();
System.out.println(list);
}

@Test
public void test11() {
Query query=session.getNamedQuery("test2");
query.setParameter("id", 2);
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test12() {
String sql="select * from h_user";
SQLQuery query=session.createSQLQuery(sql);
//设置结果集转换的类型
query.addEntity(User.class);
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test13() {
SQLQuery query=(SQLQuery) session.getNamedQuery("selectById");
//设置转换类型
query.addEntity(User.class);
query.setInteger(0, 2);
List<User> list=query.list();
System.out.println(list);
}

@Test
public void test14() {
//标准查询
Criteria criteria=session.createCriteria(User.class);
List<User> list=criteria.list();
System.out.println(list);
}

@Test
public void test15() {
//标准查询
Criteria criteria=session.createCriteria(User.class);
//添加条件
criteria.add(Restrictions.idEq(2));
List<User> list=criteria.list();
System.out.println(list);
}

@Test
public void test16() {
Criteria criteria=session.createCriteria(Stu.class);
//条件
criteria.add(Restrictions.eq("classNo", 1));
criteria.add(Restrictions.gt("score", 70));
List<Stu> list=criteria.list();
System.out.println(list);
}

@Test
public void test17() {
Criteria criteria=session.createCriteria(Stu.class);
//把多个条件封装起来
Stu stu=new Stu();
// stu.setId(1);
// stu.setName("aaa");
// stu.setClassNo(1);
// stu.setScore(70);
criteria.add(Example.create(stu));
List<Stu> list=criteria.list();
System.out.println(list);
}

@Test
public void test18() {
Criteria criteria=session.createCriteria(Stu.class);
//把多个条件封装起来
Stu stu=new Stu();
// stu.setId(1);
stu.setName("aaa");
// stu.setClassNo(0);
// stu.setScore(70);
criteria.add(Example.create(stu));
List<Stu> list=criteria.list();
System.out.println(list);
}

@Test
public void test19() {
Criteria criteria=session.createCriteria(Stu.class);
//添加排序规则
criteria.addOrder(Order.desc("score"));
List<Stu> list=criteria.list();
System.out.println(list);
}

@Test
public void test20() {
Criteria criteria=session.createCriteria(Stu.class);
//分页
//页码，分页大小
int page=2;
int pageSize=3;
criteria.setFirstResult((page-1)*pageSize);
criteria.setMaxResults(pageSize);
List<Stu> list=criteria.list();
System.out.println(list);
}

@Test
public void test21() {
//开启事务
Transaction transaction=session.beginTransaction();
String hql="delete from Stu stu where stu.id=:id";
Query query=session.createQuery(hql);
//添加参数
query.setInteger("id", 5);
int code=query.executeUpdate();
if(code>0) {
System.out.println("删除成功");
transaction.commit();
} else {
transaction.rollback();
}
}

}