Hibernate查询方式
1 、对象导航查询
（1）根据id查询某个客户，再查询这个客户里面所有的联系人
2、 OID查询
（1）根据id查询某一条记录，返回对象
3 、HQL查询
（1）Query对象，写hql语句实现查询
4、 QBC查询
（1）Criteria对象
5 、本地sql查询
（1）SQLQuery对象，使用普通sql实现查
对象导航查询
1、 查询某个客户里面所有联系人过程，使用对象导航实现
2 、代码
@Test
public void testSelect() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 查询cid是1的客户，在查询这个客户中的所有联系人
Customer customer = session.get(Customer.class, 1);
// 查询客户中的所有联系人
// 直接得到联系人中的set集合
Set<LinkMan> linkman = customer.getSetLinkMan();
System.out.println(linkman.size());
transaction.commit();
} catch (Exception e) {
transaction.rollback();
throw new RuntimeException();
} finally {
session.close();
sessionFactory.close();
}
}OID查询
1 根据id查询记录
（1）调用session里面的get方法实现
HQL查询
1、 hql：hibernate query language，hibernate提供一种查询语言，hql语言和普通sql很相似，区别：普通sql操作数据库表和字段，hql操作实体类和属性
2、 常用的hql语句
（1）查询所有： from 实体类名称
（2）条件查询： from 实体类名称 where 属性名称=?
（3）排序查询： from 实体类名称 order by 实体类属性名称 asc/desc
3、 使用hql查询操作时候，使用Query对象
（1）创建Query对象，写hql语句
（2）调用query对象里面的方法得到结果查询所有
1 、查询所有客户记录
（1）创建Query对象，写hql语句
（2）调用query对象里面的方法得到结果
2 、查询所有： from 实体类名称
// 查询所有的客户记录
@Test
public void testHQLSelectAll() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 实体类名称区分大小写
Query query = session.createQuery("from Customer");
// 得到结果
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer.getCid() + " "
+ customer.getCustName());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
throw new RuntimeException();
} finally {
session.close();
sessionFactory.close();
}
}
条件查询
1 、hql条件查询语句写法：
（1） from 实体类名称 where 实体类属性名称=? and实体类属性名称=?
from 实体类名称 where 实体类属性名称 like ?
2、 代码
// 条件查询
@Test
public void testHQLSelectByCondition() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建Query对象
Query query = session
.createQuery("from Customer where cid=? and custName=? ");
// 设置占位符的值
// setParamter:int是？位置，位置从0开始，第二个参数是具体的参数值
// 先设置第一个问号的值
query.setParameter(0, 1);
query.setParameter(1, "百度");
List<Customer> customers = query.list();
for (Customer customer : customers) {
System.out.println(customer.getCid() + " "
+ customer.getCustName());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
throw new RuntimeException();
} finally {
session.close();
sessionFactory.close();
}
}模糊查询
// 模糊查询
@Test
public void testHQLSelectByLike() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建Query对象
Query query = session
.createQuery("from Customer c where c.custName like ? ");
// 设置占位符的值
// setParamter:int是？位置，位置从0开始，第二个参数是具体的参数值
// 先设置第一个问好的值
query.setParameter(0, "%讯%");
List<Customer> customers = query.list();
for (Customer customer : customers) {
System.out.println(customer.getCid() + " "
+ customer.getCustName());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
throw new RuntimeException();
} finally {
session.close();
sessionFactory.close();
}
}排序查询
1 、hql排序语句写法
（1）from 实体类名称 order by 实体类属性名称 asc/desc
// 排序查询
@Test
public void testHQLSelectOrderBy() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建Query对象
Query query = session
.createQuery("from Customer order by cid desc ");
List<Customer> customers = query.list();
for (Customer customer : customers) {
System.out.println(customer.getCid() + " "
+ customer.getCustName());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
throw new RuntimeException();
} finally {
session.close();
sessionFactory.close();
}
}分页查询
1、 mysql实现分页
（1）使用关键字 limit实现
2 、在hql中实现分页
（1）在hql操作中，在语句里面不能写limit，hibernate的Query对象封装两个方法实现分页操作
// 分页查询
@Test
public void testHQLSelectBinary() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建Query对象
Query query = session.createQuery("from Customer");
// 设置分页数据
// 设置开始位置
query.setFirstResult(0);
query.setMaxResults(5);
// 调用方法得到结果
List<Customer> customers = query.list();
for (Customer customer : customers) {
System.out.println(customer.getCid() + " "
+ customer.getCustName());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
throw new RuntimeException();
} finally {
session.close();
sessionFactory.close();
}
}投影查询
1 、投影查询：查询不是所有字段值，而是部分字段的值
2、 投影查询hql语句写法：
（1）select 实体类属性名称1, 实体类属性名称2 from 实体类名称
（2）select 后面不能写 * ，不支持的
3 、具体实现：
投影查询：查的不是表中的所有字段而是表中部分字段的值，投影查询hql语句：
// 投影查询：查的不是表中的所有字段而是表中部分字段的值，投影查询hql语句：
// select 实体类属性名称，实体类属性名称 form 实体类名称，但是Select之后不可以写*
@Test
public void testHQLSelectProjection() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建Query对象
Query query = session.createQuery("select custName from Customer");
// 调用方法得到结果
List<Object> customers = query.list();
for (Object customer : customers) {
System.out.println(customer);
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
throw new RuntimeException();
} finally {
session.close();
sessionFactory.close();
}
}聚集函数使用
1 、常用的聚集函数
（1）count、sum、avg、max、min
2、 hql聚集函数语句写法
（1）查询表记录数
- select count(*) from 实体类名称
// 聚合函数查询：sum，min，avg，max，count
@Test
public void testHQLSelectJuhe() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建Query对象
Query query = session.createQuery("select count(*) from Customer");
// 在query对象中有方法可以直接返回Object的值而不需要在此遍历
// 在开发中需要将Object类型转化为int
Object uniqueResult = query.uniqueResult();
Long luni = (long) uniqueResult;
int count = luni.intValue();
System.out.println(count);
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
sessionFactory.close();
}
}
直接将统计函数转化为int类型会报类型转化异常错，因为count是long类型，要先转化为long类型，在转化为int类型
QBC查询
qbc查询条件：
1、 使用hql查询需要写hql语句实现，但是使用qbc时候，不需要写语句了，使用方法实现
2 、使用qbc时候，操作实体类和属性
3 、使用qbc，使用Criteria对象实现查询所有
1 、创建Criteria对象
2、 调用方法得到结果
// 查询所有
@Test
public void testHQLSelectAll() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建对象
Criteria criteria = session.createCriteria(Customer.class);
// 调用方法得到结果
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer.getCid() + " "
+ customer.getCustName());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
sessionFactory.close();
}
}
条件查询
1 、没有语句，使用封装的方法实现
// 演示条件查询
@Test
public void testHQLSelectByTrandition() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建对象
Criteria criteria = session.createCriteria(Customer.class);
// 使用criteria里的对象设置条件值
// 首先使用add方法来实现条件的设置
// 准确查询
// criteria.add(Restrictions.eq("cid", 1));
// criteria.add(Restrictions.eq("custName", "百度"));
// 模糊查询
criteria.add(Restrictions.like("custName", "%百%"));
// 调用方法得到结果
List<Customer> customers = criteria.list();
for (Customer customer : customers) {
System.out.println(customer.getCustName() + " "
+ customer.getCid());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
sessionFactory.close();
}
}
qbc查询条件：
模糊查询：
排序查询：
// 演示排序主要用的是criteria里的addOrder实现的
@Test
public void testHQLSelectSort() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建对象
Criteria criteria = session.createCriteria(Customer.class);
// 设置对那个属性进行排序包括设置排序规则
criteria.addOrder(Order.desc("cid"));
// 调用方法查询结果
List<Customer> customers = criteria.list();
for (Customer customer : customers) {
System.out.println(customer.getCustName() + " "
+ customer.getCid());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
sessionFactory.close();
}
}分页查询
* 开始位置计算公式： （当前页-1）*每页记录数
// 分页查询：分页开始位置的计算公式：（当前页－1）*每页记录数
@Test
public void testHQLSelectPage() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建对象
Criteria criteria = session.createCriteria(Customer.class);
// 设置分页数据，开始的位子与每页记录数
criteria.setFirstResult(0);
criteria.setMaxResults(4);
List<Customer> customers = criteria.list();
for (Customer customer : customers) {
System.out.println(customer.getCustName() + " "
+ customer.getCid());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
sessionFactory.close();
}
}统计查询
// 统计查询
@Test
public void testHQLSelectCount() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建对象
Criteria criteria = session.createCriteria(Customer.class);
// 设置统计功能,设置需要做的操作
criteria.setProjection(Projections.rowCount());
// 调用方法得到结果
Object uniqueResult = criteria.uniqueResult();
long luin = (long) uniqueResult;
int count = (int) luin;
System.out.println(count);
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
sessionFactory.close();
}
}
离线查询
1 、应用场景：
// 演示离线查询
// 离线查询：与session没关联也可以操作数据库
// 应用场景：在dao中做的是对数据库crud操作，但是在dao里面使用到hibernate框架时候，调用的是session方法
// 实现，可以使得操作数据库不在到层实现
// 演示离线查询
// 离线查询：与session没关联也可以操作数据库
// 应用场景：在dao中做的是对数据库crud操作，但是在dao里面使用到hibernate框架时候，调用的是session方法
// 实现，可以使得操作数据库不在到层实现
@Test
public void testHQLSelectOutLine() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
transaction = session.beginTransaction();
// 创建对象
// Criteria criteria = session.createCriteria(Customer.class);
DetachedCriteria detachedCriteria = DetachedCriteria
.forClass(Customer.class);
// 最终执行的时候才需要使用session
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
// 调用方法得到结果
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer.getCid() + " "
+ customer.getCustName());
}
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
sessionFactory.close();
}
}HQL多表查询
Mysql里面多表查询
1、内连接查询
2 、左外连接查询
3 、右外连接查询
HQL实现多表查询
Hql多表查询
（1）内连接
（2）左外连接
（3）右外连接
（4）迫切内连接
（5）迫切左外连接
HQL内连接
1 、内连接查询hql语句写法：以客户和联系人为例
（1）from Customer c inner join c.setLinkMan
返回list，list里面每部分是数组形式
迫切内连接
（1）迫切内连接和内连接底层实现一样的
（2）区别：使用内连接返回list中每部分是数组，迫切内连接返回list每部分是对象
（3）hql语句写法
- from Customer c inner join fetch c.setLinkMan
HQL左外连接
1 、左外连接hql语句：
（1）from Customer c left outer join c.setLinkMan
（2）迫切左外连接from Customer c left outer join fetch c.setLinkMan
2、 左外连接返回list中每部分是数组，迫切左外连接返回list每部分是对象
3 、右外连接hql语句：
（1）from Customer c right outer join c.setLinkManHibernate检索策略
检索策略的概念
4.1、 hibernate检索策略分为两类：
（1）立即查询：根据id查询，调用get方法，一调用get方法马上发送语句查询数据库
（2）延迟查询：根据id查询，还有load方法，调用load方法不会马上发送语句查询数据，只有得到对象里面的值时候才会发送语句查询数据库
延迟查询分成两类：
（1）类级别延迟：根据id查询返回实体类对象，调用load方法不会马上发送语句
（2）关联级别延迟：
- 查询某个客户，再查询这个客户的所有联系人，查询客户的所有联系人的过程是否需要延迟，这个过程称为关联级别延迟
关联级别延迟操作
1 、在映射文件中进行配置实现
（1）根据客户得到所有的联系人，在客户映射文件中配置
2、 在set标签上使用属性
（1）fetch：值select（默认）
（2）lazy：值
- true：延迟（默认）
- false：不延迟
- extra：极其延迟
（1）调用get之后，发送两条sql语句
（1）极其懒惰，要什么值给什么值
批量抓取
1 、查询所有的客户，返回list集合，遍历list集合，得到每个客户，得到每个客户的所有联系人
（1）上面操作代码，发送多条sql语句
2 、在客户的映射文件中，set标签配置
（1）batch-size值，值越大发送语句越少
本章内容小结：
1 hibernate的查询方式
2 对象导航查询
3 hql查询
（1）查询所有
（2）条件查询
（3）排序查询
（4）分页查询
（5）投影查询
（6）聚集函数使用
4、 qbc查询
（1）查询所有
（2）条件查询
（3）排序查询
（4）分页查询
（5）统计查询
（6）离线查询
5、 hql多表查询
（1）mysql多表查询回顾
（2）hql多表查询
- 内连接、迫切内连接、左外连接、迫切左外连接、右外连接
6、 hibernate的检索策略
（1）概念
- hibernate分成：立即和延迟查询
- 延迟查询分成：类级别和关联级别延迟
（2）具体操作
扫一扫
105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
