Hibernate三种查询详解

最新推荐文章于 2021-04-21 19:40:24 发布
最新推荐文章于 2021-04-21 19:40:24 发布
阅读量139 收藏
点赞数
文章标签： java 数据库
原文链接：http://www.cnblogs.com/setlilei/p/10629450.html
版权

HQL查询

HQL基本查询

Transaction transaction = session.beginTransaction();

String hql1 = "from java.lang.Object";//获取所有数据

String hql2 = "from com.java.Customer";//完整写法
//String hql2 = "from Customer";//简写 在此项目中Customer不能重复

//把获得的数据封装在Customer中
String hql3 = "select new Customer(id,name) from com.java.Customer";

//聚合函数 count sum avg max min 用Number类接收不确定类型的数据
//String hql3 = "select sum(id) com.java.Customer";
//String hql3 = "select avg(id) com.java.Customer";
//String hql3 = "select max(id) com.java.Customer";
//String hql3 = "select min(*) com.java.Customer";
String hql4 = "select count(*) com.java.Customer";

//设置参数
String hq5 = "from Customer where id = ?";
//String hql4 = "form Customer where id = :id";
Query query = session.createQuery(hql6);
//query.setParameter(0, 3);
query.setParameter("id", 3l);

//设置参数分页给limit
query.setFirstResult(0);//从0条开始查
query.setMaxResults(3);//每页显示两条

List<Customer> customers = query.list();
System.out.println(customers);

transaction.commit();
session.close();
sessionFactory.close();

HQL内外连接查询(无笛卡尔积)

Transaction transaction = session.beginTransaction();

//相当于select * from A a inner join B b on a.id = b.id  
String hql = "from Customer c inner join c.linkMans";
Query query = session.createQuery(hql);
//返回的每条数据都是两个对象 一条数据一个Object[]
List<Object[]> objects = query.list();

transaction.commit();

HQL迫切内连接查询

Transaction transaction = session.beginTransaction();

//相当于select * from A a inner join fetch B b on a.id = b.id  
String hql = "from Customer c inner join c.linkMans";
Query query = session.createQuery(hql);
//返回的每条数据是一个对象 把linkMan放在Customer里面
List<Customer> objects = query.list();

transaction.commit();

HQL左外连接查询&HQL右外连接查询 与实例相同 inner 改为 left|right
迫切HQL左外连接查询&迫切HQL右外连接查询 与实例相同 封装对象

Criteria查询

Criteria基本查询

Transaction transaction = session.beginTransaction();

//查询所有Customer对象
Criteria criteria = session.createCriteria(Customer.class);
//为Criteria查询添加条件 查询id为3的数据
criteria.add(Restrictions.eq("id", 3l));
//设置参数分页给limit
criteria.setFirstResult(0);//从0条开始查
criteria.setMaxResults(3);//每页显示两条
//排序 按照id列的升序对数据排序
//criteria.addOrder(Order.asc("id"));
//排序 按照id列的降序对数据排序
criteria.addOrder(Order.desc("id"));
//统计查询 设置条件为最大的id的值
criteria.setProjection(Projections.max("id"));
List<Customer> customers = criteria.list();

transaction.commit();

Restrictions的函数实现设置条件
方法名说明
Restrictions.eq=
Restrictions.allEq利用Map来进行多个等于的限制
Restrictions.gt>
Restrictions.ge>=
Restrictions.lt<
Restrictions.le<=
Restrictions.betweenBETWEEN
Restrictions.likeLIKE
Restrictions.inIN
Restrictions.andAND
Restrictions.orOR
Restrictions.sqlRestriction用SQL限定查询
Projections的函数实现聚合函数
方法名说明
avg(String propertyName)计算属性字段的平均值
count(String propertyName)统计一个属性在结果中出现次数
countDistinct(String propertyName)统计属性包含的不重复值的数量
max(String propertyName)计算属性值最大值
min(String propertyName)计算属性值最小值
sum(String propertyName)计算属性值总和

Criteria离线查询(脱离session创建)

/*
* 离线对象作用
* 离线对象可体现JavaEE三层架构
* 在控制层离线的对象 并组装数据
* 在业务层对数据进行处理
* 在持久层操作数据库
*/

//获得离线的Criteria对象
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
//与Criteria对象使用相同 运行时需要关联Session对象
detachedCriteria.add(Restrictions.eq("id", 3l));

Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();

//从离线Criteria对象上获得可被执行的Criteria对象
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
Customer customer = (Customer) criteria.uniqueResult();

transaction.commit();

查询优化(懒加载|延迟加载)

类级别延迟加载

/*
* load方法:原理返回代理对象 使用此对象时加载
* 注意 使用此对象时加载时Session为开启状态
* 延迟加载 仅获得没有使用 不会查询 在使用时才进行查询
* 是否对类进行延迟加载 可以通过在class元素上配置lazy属性来控制
* <class name="User" table="user" lazy="true" ></class>
* lazy:true		加载时 不查询 使用时才查询
* lazy:false	加载时立即查询 此时等于get
*/
Transaction transaction = session.beginTransaction();

//传统获得数据方式 执行完此行立即执行select
//Customer customer = session.get(Customer.class, 3l);
//懒加载方式获得数据 执行完此行会返回一个对象 此对象被使用时执行select
Customer customer = session.load(Customer.class, 3l);

transaction.commit();

关联级别延迟加载

<!-- 
	lazy属性:决定是否延迟加载
		true(默认值):延迟加载
		false:立即加载
		extra:极其懒惰
	fetch属性:决定加载策略 设置加载集合sql语句的数据类型
		select(默认值):单表查询加载
		join:使用多表查询加载集合
		subselect:使用子查询加载集合
-->
<!-- 
	batch-size:抓取集合的数量为3
	抓取客户的集合时 单次抓取客户的联系人集合的数量
-->
<set name="linkMens" batch-size="3"  >
	<key column="lkm_cust_id" ></key>
	<one-to-many class="LinkMan" />
</set>

lazy属性&fetch属性

//集合级别的关联
//fetch:select 单表查询
//lazy:true 使用时才加载集合数据
@Test
public void test1() {
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	Customer c = session.get(Customer.class, 3l);
	Set<LinkMan> linkMens = c.getLinkMens();//关联级别
	System.out.println(linkMens);

	tx.commit();
	session.close();
}

//集合级别的关联
//fetch:select 单表查询
//lazy:false 立即记载集合数据
@Test
public void test2() {
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	Customer c = session.get(Customer.class, 3l);
	Set<LinkMan> linkMens = c.getLinkMens();// 关联级别
	System.out.println(linkMens);

	tx.commit();
	session.close();
}

//集合级别的关联
//fetch:select 单表查询
//lazy:extra 极其懒惰 与懒加载效果基本一致 如果只获得集合的size 只查询集合的size(count语句)
@Test
public void test3() {
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	Customer c = session.get(Customer.class, 3l);
	Set<LinkMan> linkMens = c.getLinkMens();// 关联级别
	System.out.println(linkMens.size());
	System.out.println(linkMens);

	tx.commit();
	session.close();
}

//集合级别的关联
//fetch:join 多表查询
//lazy:true|false|extra 失效 立即加载
@Test
public void test4() {
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	Customer c = session.get(Customer.class, 3l);
	Set<LinkMan> linkMens = c.getLinkMens();// 关联级别
	System.out.println(linkMens.size());
	System.out.println(linkMens);

	tx.commit();
	session.close();
}

//fetch:subselect 子查询
//lazy:true 懒加载
@Test
public void test5() {
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	String hql = "from Customer";
	Query query = session.createQuery(hql);
	List<Customer> list = query.list();
	for (Customer c : list) {
		System.out.println(c);
		System.out.println(c.getLinkMens().size());
		System.out.println(c.getLinkMens());
	}

	tx.commit();
	session.close();
}

//fetch:subselect 子查询
//lazy:false 立即加载
@Test
public void test6() {
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	String hql = "from Customer";
	Query query = session.createQuery(hql);
	List<Customer> list = query.list();
	for (Customer c : list) {
		System.out.println(c);
		System.out.println(c.getLinkMens().size());
		System.out.println(c.getLinkMens());
	}

	tx.commit();
	session.close();
}

//fetch:subselect 子查询
//lazy:extra 极其懒惰
@Test
public void test7() {
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	String hql = "from Customer";
	Query query = session.createQuery(hql);
	List<Customer> list = query.list();
	for (Customer c : list) {
		System.out.println(c);
		System.out.println(c.getLinkMens().size());
		System.out.println(c.getLinkMens());
	}

	tx.commit();
	session.close();
}

//fetch:select 单表查询
//lazy:proxy
//customer-true 懒加载
@Test
public void fun1(){
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	LinkMan lm = session.get(LinkMan.class, 3l);
	Customer customer = lm.getCustomer();
	System.out.println(customer);

	tx.commit();
	session.close();
}

@Test
//fetch:select 单表查询
//lazy:proxy
//customer-false 立即加载
public void fun2(){
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	LinkMan lm = session.get(LinkMan.class, 3l);
	Customer customer = lm.getCustomer();
	System.out.println(customer);

	tx.commit();
	session.close();
}

@Test
//fetch:join 多表
//lazy:失效
public void fun3(){
	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();

	LinkMan lm = session.get(LinkMan.class, 3l);
	Customer customer = lm.getCustomer();
	System.out.println(customer);

	tx.commit();
	session.close();
}

结论:为了提高效率 fetch的选择上应选择select lazy的取值应选择true 全部使用默认值

no-session问题解决:扩大session的作用范围
	使用JavaEE Filter
		Filter 前处理 打开session&事务
		chain.doFilter(request,response) 放行->servlet->service->dao
		Filter 后处理 关闭session&事务

转载于:https://www.cnblogs.com/setlilei/p/10629450.html

weixin_30266885
关注
Hibernate组件映射代码详解
08-28
Hibernate组件映射代码是Hibernate框架中的一种映射方式，用于将Java类转换为数据库表。组件关联映射是指在实体类中包含一个或多个组件类，组件类中包含多个属性，这些属性将被映射到数据库表中。 2. 组件关联映射...
hibernate多表查询详解
10-20
**hibernate多表查询详解** 在Java的持久化框架中，Hibernate是一个广泛使用的ORM（对象关系映射）工具，它允许开发者用面向对象的方式来处理数据库操作。在实际的业务场景中，数据往往不是孤立存在的，而是存在于...
hibernate 三种查询方式
04-14 929
（一）HQLHQL：Hibernate Qusery Language，如果你已经熟悉它，就会发现它跟SQL非常相像。不过 你不要被表面的假象迷惑，HQL是面向对象的（OO，用生命的眼光看待每一个对象，他们是如此 鲜活）。如果你对JAVA和SQL语句有一定了解的话，那么HQL对你简直易如反掌，你完全可以利用在公车上的时间掌握它。以下从几个方面进行慢慢深入：1。大小些敏感大家知道SQL-92 Que
Hibernate的三种查询方式
weixin_30270889的博客
09-25 326
Hibernate的查询方式 hibernate的查询方式常见的主要分为三种: HQL, QBC, 以及使用原生SQL查询 HQL查询 • HQL（Hibernate Query Language）提供了丰富灵活的查询方式，使用HQL进行查询也是Hibernate官方推荐使用的查询方式。 • HQL在语法结构上和SQL语句十分的相同，所以可以很快的上手进行使用。使用HQL需要用到Hib...
Hibernate查询详解
shengfakun1234的专栏
11-29 660
Hibernate查询 首先介绍get()和load()方法的区别: get()方法和load()方法的区别主要在于对二级缓存的使用上。 load()方法会使用二级缓存，而get()方法在一级缓存没有找到会直接查询数据库，不会去二级缓存中查找。 get():如果在数据库中没有记录会返回空，get()无论如何都会返回数据. load():如果数据库中没有记录会抛出异常，如果有数据返回的是一个代理对象。 list和iterator()方法之间的区别：(N+1?) list()方法在执行时，直接运行查询结果所需要
hibernate的三种查询方式
t2736416901的博客
04-21 578
hibernate的三种查询方式 文章目录hibernate的三种查询方式1、HQL查询1.1、SQL概述1.2、实体查询1.3、带where的查询1.3、属性查询1.4、实体的更新和删除1.5、分组与排序**1.6、参数绑定**1.7、连接查询1.8、分页2、QBC查询2.1、查询实现2.2、Projections 列投射2.3、Restrictions 条件限制2.3、Order排序2.4、分页查询3、原生SQL查询1、查询2、 addEntity()3、 uniqueResult hibernate的
hibernate查询详解
01-05
hibernate查询详解 在Java开发中，Hibernate作为一款强大的ORM（Object-Relational Mapping）框架，极大地简化了数据库操作。本文将详细介绍Hibernate的五种查询方式，包括HQL查询、Criteria方法、动态查询...
Hibernate连接三种数据库的配置文件
08-26
Hibernate连接三种数据库的配置文件详解 Hibernate是一种流行的Java持久层框架，用于将Java对象映射到关系数据库中。在使用Hibernate时，需要配置连接数据库的信息，包括数据库驱动、连接URL、用户名、密码等信息。...
Hibernate连接Mycat例子详解.zip
最新发布
07-30
总之，`Hibernate连接Mycat例子详解.zip`提供的资源是一个很好的学习材料，它涵盖了从Mycat的配置、数据分片，到Hibernate的配置、实体操作等一系列步骤，帮助开发者理解如何在Java应用中集成这两种技术，实现高效的...
Hibernate查询
weixin_30888027的博客
03-11 75
Hibernate Query Language Query q =session.createQuery("from Categoryc orderby c.name desc"); List<Category> categories =(List<Category>)q.list(); HQL语言大小写不敏感，但是涉及到Java类名、packag...
hibernate的三种查询
Tomsheng321的专栏
09-08 598
项目中的方便查阅 1）Criteria查询接口 2）hql语句查询 3)原生SQL查询
hibernate三种查询方式
PBB的博客
08-12 607
查询大体流程 //获取SessionFactory SessionFactory sf = new Configuration().configure().buildSessionFactory(); //通过SessionFactory获取一个session Session s = sf.openSession(); //开启一个事务 s.beginTransaction();
hibernate查询
泥锅巴的空间
12-18 2536
第 14 章 批量处理（Batch processing）使用Hibernate将 100 000 条记录插入到数据库的一个很自然的做法可能是这样的 Session session = sessionFactory.openSession();Transaction tx = session.beginTransaction();for ( int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值