hibernate有五种检索方式，这儿用 单向的一对多的映射关系 例子，这儿有后三种的方式；
导航对象图检索方式: 根据已经加载的对象导航到其他对象
OID 检索方式: 按照对象的 OID 来检索对象
HQL 检索方式: 使用面向对象的 HQL 查询语言
QBC 检索方式: 使用 QBC(Query By Criteria) API 来检索对象. 这种 API 封装了基于字符串形式的查询语句, 提供了更加面向对象的查询接口.
本地 SQL 检索方式: 使用本地数据库的 SQL 查询语句
建立封装数据库中数据属性的封装类：n-1;
n的一端封装类：
package com.atguigu.hibernate.entities; import java.util.HashSet;
import java.util.Set; public class Department { private Integer id;
private String name; private Set<Employee> emps=new HashSet<>(); public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Set<Employee> getEmps() {
return emps;
} public void setEmps(Set<Employee> emps) {
this.emps = emps;
}
@Override
public String toString() {
return "Department [id=" + id + "]";
} }
1的一端封装的类：
package com.atguigu.hibernate.entities;
public class Employee {
private Integer id;
private String name;
private float salary;
private String email;
private Department dept;
public Employee() {
super();
}
public Employee(String name, float salary, String email,
Department dept) {
super();
this.name = name;
this.salary = salary;
this.email = email;
this.dept = dept;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getSalary() {
return salary;
}
public void setSalary(float salary) {
this.salary = salary;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Department getDept() {
return dept;
}
public void setDept(Department dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Employee [id=" + id + "]";
}
}
在该包下自动生成对用的关系映射文件，只需进行一些修改；
单向的n-1映射关联关系，1的一端，关系映射文件；
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-9-26 8:08:56 by Hibernate Tools 3.4.0.CR1 --> <hibernate-mapping package="com.atguigu.hibernate.entities"> <class name="Employee" table="LL_EMPLOYEE"> <id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="native" />
</id> <property name="name" type="java.lang.String">
<column name="NAME" />
</property> <property name="salary" type="float">
<column name="SALARY" />
</property> <property name="email" type="java.lang.String">
<column name="EMAIL" />
</property> <many-to-one name="dept" class="Department">
<column name="DEPT_id" />
</many-to-one> </class> <!-- 在映射文件中定义命名查询语句 ,书写的位置不在class范围内，注意书写的位置-->
<query name="salaryemp"><![CDATA[from Employee e where e.salary >:minSal and e.salary <:maxSal]]></query>
</hibernate-mapping>
单向的n-1映射关联关系，n的一端，关系映射文件；
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-9-26 8:08:56 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.atguigu.hibernate.entities"> <class name="Department" table="LL_DEPARTMENT"> <id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="native" />
</id> <property name="name" type="java.lang.String">
<column name="NAME" />
</property> <set name="emps" table="LL_EMPLOYEE" inverse="true" lazy="true">
<key>
<column name="DEPT_ID" />
</key>
<one-to-many class="Employee" />
</set> </class>
</hibernate-mapping>
在src目录下建立hibernate的配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory> <!-- Hibernate 连接数据库的基本信息 -->
<property name="connection.username">lxn123</property>
<property name="connection.password">lxn123</property>
<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl1</property> <!-- -->
<!-- Hibernate 的基本配置 -->
<!-- Hibernate 使用的数据库方言 ,是oracle书籍库的基本方言-->
<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property> <!-- 运行时是否打印 SQL -->
<property name="show_sql">true</property> <!-- 运行时是否格式化 SQL -->
<property name="format_sql">true</property> <!-- 生成数据表的策略 -->
<property name="hbm2ddl.auto">update</property> <!-- 设置 Hibernate 的事务隔离级别 -->
<property name="connection.isolation">2</property> <!-- 删除对象后, 使其 OID 置为 null -->
<property name="use_identifier_rollback">true</property> <!-- 配置 C3P0 数据源，不是开发 这儿就不配置了 --> <!-- 设定 JDBC 的 Statement 读取数据的时候每次从数据库中取出的记录条数 -->
<property name="hibernate.jdbc.fetch_size">100</property> <!-- 设定对数据库进行批量删除，批量更新和批量插入的时候的批次大小 -->
<property name="jdbc.batch_size">30</property> <!-- 需要关联的 hibernate 映射文件 .hbm.xml -->
<mapping resource="com/atguigu/hibernate/entities/Department.hbm.xml"/>
<mapping resource="com/atguigu/hibernate/entities/Employee.hbm.xml"/> </session-factory>
</hibernate-configuration>
建立测试类，进行测试方法；
package com.atguigu.hibernate.test; import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List; import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Conjunction;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test; import com.atguigu.hibernate.entities.Department;
import com.atguigu.hibernate.entities.Employee; public class HqlTest { private static SessionFactory sessionFactory;
private static Session session;
private static Transaction transaction; @Before
public void init(){
Configuration configuration=new Configuration().configure();
ServiceRegistry serviceRegistry=
new ServiceRegistryBuilder()
.applySettings(configuration.getProperties())
.buildServiceRegistry();
sessionFactory=configuration.buildSessionFactory(serviceRegistry); session=sessionFactory.openSession();
transaction=session.beginTransaction();
} @After
public void destroy(){
transaction.commit();
session.close();
sessionFactory.close();
} @Test
//hql也可以进行曾删改的操作
public void testHQLUpdate(){
String hql = "DELETE FROM Department d WHERE d.id = :id"; session.createQuery(hql).setInteger("id", 280)
.executeUpdate();
} @Test
//本地 SQL 检索
public void testNativeSQL(){
String sql = "INSERT INTO ll_department VALUES(?, ?)";
Query query = session.createSQLQuery(sql); query.setInteger(0, 280)
.setString(1, "ATGUIGU")
.executeUpdate();
} @Test
//QBC检索, 添加排序,添加翻页方法
public void testQBC4(){
Criteria criteria = session.createCriteria(Employee.class); //1. 添加排序
criteria.addOrder(Order.asc("salary"));
criteria.addOrder(Order.desc("email"));
List<Employee> empss=criteria.list();
System.out.println(empss); //2. 添加翻页方法
int pageSize = 5;
int pageNo = 3;
List<Employee> emps=criteria.setFirstResult((pageNo - 1) * pageSize)
.setMaxResults(pageSize)
.list();
System.out.println(emps);
} @Test
//QBC检索,统计查询
public void testQBC3(){
Criteria criteria = session.createCriteria(Employee.class); //统计查询: 使用 Projection 来表示: 可以由 Projections 的静态方法得到
criteria.setProjection(Projections.max("salary")); System.out.println(criteria.uniqueResult());
} @Test
//QBC检索,AND OR
public void testQBC2(){
Criteria criteria = session.createCriteria(Employee.class); //1. AND: 使用 Conjunction 表示
//Conjunction 本身就是一个 Criterion 对象
//且其中还可以添加 Criterion 对象
Conjunction conjunction = Restrictions.conjunction();
conjunction.add(Restrictions.like("name", "a", MatchMode.ANYWHERE));
Department dept = new Department();
dept.setId(80);
conjunction.add(Restrictions.eq("dept", dept));
System.out.println(conjunction); //2. OR
Disjunction disjunction = Restrictions.disjunction();
disjunction.add(Restrictions.ge("salary", 6000F));
disjunction.add(Restrictions.isNull("email")); criteria.add(disjunction);
criteria.add(conjunction); criteria.list();
System.out.println(criteria);
} @Test
//QBC检索
public void testQBC(){
//1. 创建一个 Criteria 对象
Criteria criteria = session.createCriteria(Employee.class); //2. 添加查询条件: 在 QBC 中查询条件使用 Criterion 来表示
//Criterion 可以通过 Restrictions 的静态方法得到
//eq,是等于，gt是大于
criteria.add(Restrictions.eq("email", "SKUMAR"));
criteria.add(Restrictions.gt("salary", 5000F)); //3. 执行查询
Employee employee = (Employee) criteria.uniqueResult();
System.out.println(employee);
} @Test
//内连接
public void testinnerjoin(){
String hql = "SELECT e FROM Employee e INNER JOIN e.dept";
Query query = session.createQuery(hql); List<Employee> emps = query.list();
emps=new ArrayList<>(new LinkedHashSet<>(emps));
System.out.println(emps.size()); for(Employee emp: emps){
System.out.println(emp.getName() + ", " + emp.getDept().getName());
}
} @Test
//迫切内连接
public void testinnerjoinfetch(){ String hql = "FROM Department d INNER JOIN FETCH d.emps";
Query query = session.createQuery(hql); List<Department> depts = query.list();
//取消重复的行
depts = new ArrayList<>(new LinkedHashSet(depts));
System.out.println(depts.size()); for(Department dept: depts){
System.out.println(dept.getName() + "-" + dept.getEmps().size());
}
} @Test
//左外连接，DISTINCT取消重复的行
public void testLeftJoin(){
String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN d.emps";
Query query = session.createQuery(hql); List<Department> depts = query.list();
System.out.println(depts.size()); for(Department dept: depts){
System.out.println(dept.getName() + ", " + dept.getEmps());
} // List<Object []> result = query.list();
// result = new ArrayList<>(new LinkedHashSet<>(result));，取消重复的行
// System.out.println(result);
//
// for(Object [] objs: result){
// System.out.println(Arrays.asList(objs));
// }
} //迫切左外连接LEFT JOIN FETCH,DISTINCT是取消重复的行
public void testLeftJoinFetch(){
String hql="select distinct d from Department d left join fetch d.emps";
Query query=session.createQuery(hql); List<Department> depts=query.list(); //取消重复的行,set集合中没有重复的值
depts=new ArrayList<>(new LinkedHashSet<>(depts));
System.out.println(depts.size()); for(Department dept:depts){
System.out.println(dept.getName()+"--"+dept.getEmps());
} } //报表查询,即在sql是分组查询，只查询部分属性
public void testGroupBy(){
String hql="select min(e.salary),max(e.salary) "
+ "from Employee e group by e.dept having min(salary)>:de"; Query query=session.createQuery(hql).setFloat("de", 5000); //数组的形式
List<Object []> result=query.list();
for(Object [] emp:result){
System.out.println(Arrays.asList(emp));
}
} //投影查询，即查询部分属性
public void testFieldQuery2(){ String hql="select new Employee(e.name,e.salary,e.email,e.dept) "
+ "from Employee e where e.dept=:dept";
Query query=session.createQuery(hql); Department dept=new Department();
dept.setId(80); //封装类形式的
List<Employee> result=query.setEntity("dept", dept).list();
for(Employee emp:result){
System.out.println(emp.getName()+"，"+emp.getSalary()+"，"+emp.getEmail()+"，"+emp.getDept());
}
} @Test
//投影查询，即查询部分属性
public void testFieldQuery(){
String hql="select e.email,e.salary,e.dept from Employee e where e.dept=:dept";
Query query=session.createQuery(hql); Department dept=new Department();
dept.setId(80); //数组形式的
List<Object[]> result=query.setEntity("dept", dept).list();
for(Object [] emps:result){
System.out.println(Arrays.asList(emps));
}
} //在映射文件中定义命名查询语句方式的命名查询,在映射文件中要配置的。。。
//此查询方法，只能查询到在此范围内的个数，不能查询到具体的属性值
public void testNamedQuery(){
Query query =session.getNamedQuery("salaryemp"); List<Employee> emps=
query.setFloat("minSal", 5000)
.setFloat("maxSal", 10000)
.list();
System.out.println(emps.size());
} //分页查询,此查询只能查询到，对应的id
@Test
public void testPageQuery(){
String hql="from Employee";
Query query=session.createQuery(hql); //第三页
int pageNo=3;
//每页的大小为5
int pageSize=5; /*
* setFirstResult(int firstResult): 设定从哪一个对象开始检索,
* 参数 firstResult 表示这个对象在查询结果中的索引位置, 索引位置的起始值为 0.
* 默认情况下, Query 从查询结果中的第一个对象开始检索
*
* setMaxResults(int maxResults): 设定一次最多检索出的对象的数目.
* 在默认情况下, Query 和 Criteria 接口检索出查询结果中所有的对象
* */
List<Employee> emps=
query.setFirstResult((pageNo-1)*pageSize)
.setMaxResults(pageSize).list();
System.out.println(emps);
} //基于命名参数的查询
//此查询方法，只能查询到在此范围内的个数，不能查询到具体的属性值
public void testHQLNamedParameter(){
//1. 创建 Query 对象
//基于命名参数.
String hql="from Employee e where e.salary > :sal and e.email like :ema";
Query query = session.createQuery(hql); //2. 绑定参数。setFloat,setString,都为设置属性的类型
query.setFloat("sal", 7000).setString("ema", "%A%"); //3. 执行查询
List<Employee> emp=query.list();
System.out.println(emp.size());
} //此查询方法，只能查询到在此范围内的个数，不能查询到具体的属性值
public void testHql(){ //1. 创建 Query 对象
//基于位置的参数.hql是面向对象的，所以，书写表名时 为封装属性的类名；
String hql="FROM Employee e WHERE e.salary > ? AND e.email LIKE ? AND e.dept = ? "
+ "ORDER BY e.salary";
Query query=session.createQuery(hql); //2. 绑定参数
//Query 对象调用 setXxx 方法支持方法链的编程风格.
Department dept=new Department();
dept.setId(80);
query.setFloat(0, 5000).setString(1, "%A%").setEntity(2, dept); //3. 执行查询
List<Employee> emp=query.list();
System.out.println(emp.size());
}
}