Hibernate的查询,二级缓存,连接池

时间:2022-11-08 16:12:24

Hibernate的查询,二级缓存,连接池

1.Hibernate查询数据

Hibernate中的查询方法有5中:

1.1.Get/Load主键查询

使用get或者load方法来查询,两者之间的区别在前面已经分析过了,这里用代码示例一下:


//1.主键查询
@Test
public void all(){
Session session = new Configuration().configure().buildSessionFactory().openSession();
session.beginTransaction(); //1.主键查询
Dept dept= (Dept) session.get(Dept.class, 1);
Dept dept1= (Dept) session.load(Dept.class, 1); session.getTransaction().commit();
session.close(); }

1.2.对象导航查询

    //2.对象导航查询
@Test
public void all(){
Session session = new Configuration().configure().buildSessionFactory().openSession();
session.beginTransaction(); //2.对象导航查询
Dept dept= (Dept) session.load(Dept.class, 1);
System.out.println(dept.getDeptName());
System.out.println(dept.getEmps()); session.getTransaction().commit();
session.close(); }

1.3.HQL查询

HQL:Hibernate Query language, hibernate提供的面向对象的查询语

根据sql语言的查询分类,HQL查询也大致可以分为一下几种:

1.查询全部列

2.查询指定列

3.查询指定的列并封装为对象

4.条件查询(一个条件/多个条件and or/范围查询between and/模糊查询)

5.聚合查询

6.分组查询

7.连接查询

前六种方式的查询方式代码示例为:

    //3.HQL查询
@Test
public void hql(){
Session session = sf.openSession();
session.beginTransaction();
//注意:使用HQL查询的时候,auto-import="true"要设置为true
//如果是false,写HQL的时候,要指定类的全名
SQLQuery q = session.createSQLQuery("FROM Dept");
System.out.println(q.list()); //1.查询全部列
Query q = session.createQuery("from a_query.Dept");
Query q = session.createQuery("select * from a_query.Dept");//错误,不支持*
Query q = session.createQuery("select d from a_query.Dept d");
System.out.println(q.list()); //2.查询指定的列
//返回对象数据Object
Query q = session.createQuery("select d.depId,d.deptName from a_query.Dept as d");
System.out.println(q.list());//[[Ljava.lang.Object;@11cfad4] //3.查询指定的列封装为对象【必须要提供带参构造器】
Query q = session.createQuery("select new a_query.Dept(d.depId,d.deptName) from a_query.Dept d");
System.out.println(q.list()); //4.条件查询:一个条件/多个条件and or/between and/模糊查询
//条件查询:占位符
Query q = session.createQuery("from Dept d where deptNmae=?");
q.setString(0,"财务部");//使用下面方式设置参数也可以、
q.setParameter(0,"财务处")
System.out.println(q.list()); //条件查询:命名参数
Query q = session.createQuery("from Dept d where depId=:myId and deptName=:name");
q.setParameter("myId",121);
q.setParameter("name","财务部");
System.out.println(q.list()); //范围between and
Query q = session.createQuery("from Dept d where depId between ? and ?");
q.setParameter(0,1);
q.setParameter(1,20);
System.out.println(q.list()); //模糊
Query q = session.createQuery("from Dept d where deptName like ?");
q.setString(0,"%部%");
System.out.println(q.list()); //5.聚合函数统计
Query q = session.createQuery("select count(*) from Dept");
Long num = (Long) q.uniqueResult();//不再使用list()方法
System.out.println(num); //6.分组查询
//统计t_employee表中,每个部门的人数
//数据库写法:SELECT dept_id,COUNT(*) FROM t_employee GROUP BY dept_id;
// HQL写法
Query q = session.createQuery("select e.dept,count(*) from Employee e group by e.dept ");
System.out.println(q.list()); session.getTransaction().commit();
session.close();
}

连接查询

连接查询主要分为内连接和左外连接或者右外连接。

先看需求:显示员工名称,薪水,部门

使用SQL来查询可以这样写:

内连接:

SELECT e.empName,e.salary,d.deptName FROM t_dept d,t_employee e WHERE d.depId=e.dept_id;

SELECT e.empName,e.salary,d.deptName FROM t_dept d INNER JOIN t_employee e ON d.depId = e.dept_id;

左外连接:

需求:显示部门,以及部门下的员工,如果部门下没有员工,用null

SELECT e.empName,e.salary,d.deptName FROM t_dept d LEFT JOIN t_employee e ON d.depId = e.dept_id;

始终显示right join后面表的数据

SELECT e.empName,e.salary,d.deptName FROM t_employee e LEFT JOIN t_dept d ON d.depId = e.dept_id;

使用HQL查询为:

    //HQL查询的连接查询
@Test
public void join(){
Session session = sf.openSession();
session.beginTransaction();
//1.内连接【映射已经配置好了关系,关联的时候,直接写对象的属性就可以了】
Query q = session.createQuery("from a_query.Employee e inner join e.dept");
//数组中第一个元素是Employee,第二个元素是dept
List<Object[]> list = q.list();//可以遍历得到结果了
System.out.println(q.list()); //2.左外连接
q = session.createQuery("from a_query.Dept d left join d.emps");
System.out.println(q.list()); //右外连接
q = session.createQuery("from a_query.Employee e right join e.dept");
System.out.println(q.list()); //3.迫切连接【使用fetch,会把右表的数据,填充到左表对象中】
//迫切内连接
q = session.createQuery("from Dept d inner join fetch d.emps");
q.list();
//迫切外连接
Query q = session.createQuery("from Dept d left join fetch d.emps");
q.list(); session.getTransaction().commit();
session.close();
}

HQL的优化操作

如果sql写在java代码中是写死的,这样的化维护起来特别困难,常用的做法是将HQL的sql语句放在java对应的映射文件各种,然后在java中直接调用。但是sql放在映射文件中需要注意转义的字符

映射文件:

	<!--存放sql语句-->
<query name="getAllDept">
from Dept d where depId=:myId or deptName=:name
</query>
<!--这里的sql需要转义的字符要转义-->
<query name="getLitter">
from Dept d where depId &lt; ?
</query>
<!--批量转义的时候使用CDATA区域-->
<query name="getLitter2">
<![CDATA[
from Dept d where depId < ?
]]>
</query>

优化代码示例:

    //HQL查询优化
@Test
public void hql_other() {
Session session = sf.openSession();
session.beginTransaction();
// HQL写在java代码中会把HQL写死,不易维护
//Query q = session.createQuery("from Dept d where depId=:myId or deptName=:name"); // 优化做法是将HQL查询语句放到映射文件中
//一般都放在对应的映射文件中
Query q = session.getNamedQuery("getAllDept");//从配置文件中读取sql
q.setParameter("myId",12); //设置参数
q.setParameter("name","财务部");
System.out.println(q.list()); session.getTransaction().commit();
session.close();
}

1.4.Criteria查询

Criteria是完全面向对象的查询:QBC,Query By Criteria

/**
* QBC查询
*/
public class QbcTest {
private static SessionFactory sf;
static {
sf = new Configuration().configure().buildSessionFactory();
} @Test
public void all(){
Session session = sf.openSession();
session.beginTransaction(); Criteria criteria = session.createCriteria(Employee.class);//查询了所有的对象 //添加查询条件,字段=值
// criteria.add(Restrictions.eq("empId",1));
//根据主键查询
criteria.add(Restrictions.idEq(1)); System.out.println(criteria.list()); session.getTransaction().commit();
session.close();
}
}

1.5.SQLQuery,本地SQL查询

缺点:不能跨数据库平台,如果改了数据库,sql语句有可能需要改。

使用场景:对于复杂SQL,HQL实现不了的情况可以使用本地sql查询

    //5.SQLQuery, 本地SQL查询
//不能跨数据库平台: 如果该了数据库,sql语句有肯能要改。
@Test
public void sql(){
Session session = sf.openSession();
session.beginTransaction(); SQLQuery q = session.createSQLQuery("SELECT * FROM t_dept limit 1")//查询数结果
.addEntity(Dept.class);//封装结果
System.out.println(q.list()); session.getTransaction().commit();
session.close();
}

1.6.Hibernate分页查询

数据库SQL分页的时候,是先查询总记录数,再分页查询。

Hibernate对这个功能有简化,更方便一些:

代码示例:


/**
* 分页查询
*/
public class QbcTest {
private static SessionFactory sf;
static {
sf = new Configuration().configure().buildSessionFactory();
} // 分页查询
@Test
public void paginator() { Session session = sf.openSession();
session.beginTransaction(); //1.获取数据库表里面的数据
Query q = session.createQuery("from Employee"); // 2.从记录数
ScrollableResults scroll = q.scroll(); // 得到滚动的结果集
scroll.last(); // 滚动到最后一行
int totalCount = scroll.getRowNumber() + 1;// 得到滚到的记录数,即总记录数 // 3.设置分页参数
q.setFirstResult(0);
q.setMaxResults(3); // 4.查询
System.out.println(q.list());
System.out.println("总记录数:" + totalCount); session.getTransaction().commit();
session.close();
}
}

2.Hibernate对连接池的支持

连接池作用:管理连接,提升连接的利用效率!

常用的连接池有:C3P0连接池

Hibernate自带的也有一个连接池,且对c3p0连接池也有支持

Hibernate自带的连接池,只维护一个连接,比较简陋,可以查询Hibernate.properties文件查看连接池详细配置

#################################
### Hibernate Connection Pool ###
################################# hibernate.connection.pool_size 1 【Hbm 自带连接池: 只有一个连接】 ###########################
### C3P0 Connection Pool### 【Hbm对C3P0连接池支持】
########################### #hibernate.c3p0.max_size 2 最大连接数
#hibernate.c3p0.min_size 2 最小连接数
#hibernate.c3p0.timeout 5000 超时时间
#hibernate.c3p0.max_statements 100 最大执行的命令的个数
#hibernate.c3p0.idle_test_period 3000 空闲测试时间
#hibernate.c3p0.acquire_increment 2 连接不够用的时候, 每次增加的连接数
#hibernate.c3p0.validate false 【Hbm对C3P0连接池支持, 核心类】
告诉hib使用的是哪一个连接池技术。
#hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider

Hibernate对c3p0连接池支持,用到的核心类

hibernate.connection.provider_class

即:org.hibernate.connection.C3P0ConnectionProvider

Hibernate中配置连接池的地方在Hibernate.cfg.xml 中配置,此处的配置不会对已经配置好的数据库连接有影响,所有直接下数据库连接下面写就可以了.


<!-- 【连接池配置】 -->
<!-- 配置连接驱动管理类 -->
<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<!-- 配置连接池参数信息 -->
<property name="hibernate.c3p0.min_size">2</property>
<property name="hibernate.c3p0.max_size">4</property>
<property name="hibernate.c3p0.timeout">5000</property>
<property name="hibernate.c3p0.max_statements">10</property>
<property name="hibernate.c3p0.idle_test_period">30000</property>
<property name="hibernate.c3p0.acquire_increment">2</property>

3.二级缓存

Hibernate提供的缓存有一级缓存,二级缓存.目的是为了减少对数据库的访问次数,提高程序执行效率.

对于一级缓存:

基于session的缓存,缓存内容只在当前session有效,session关闭,缓存内容失效!

特点是:作用范围小,缓存的时间短,缓存效果不明显.

1.二级缓存概述

Hibernate提供了基于应用程序级别的缓存,可以跨多个session,即不同的seesion都可以访问缓存数据,这个缓存也叫二级缓存.

Hibernate提供的二级缓存有默认的实现,且是一种可插配的缓存框架!如果用户想用二级缓存,只需要在Hibernate.cfg.xml中配置即可;不想用,直接移除,不影响代码.

如果用户觉得Hibernate提供的框架不好用,自己可以换其他的缓存框架或自己实现缓存框架都可以

2.使用二级缓存

查看Hibernate.properties配置文件,二级缓存如何配置:

##########################
### Second-level Cache ###
########################## #hibernate.cache.use_second_level_cache false【二级缓存默认不开启,需要手动开启】
#hibernate.cache.use_query_cache true 【开启查询缓存】 ## choose a cache implementation 【二级缓存框架的实现】 #hibernate.cache.provider_class org.hibernate.cache.EhCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.EmptyCacheProvider
hibernate.cache.provider_class org.hibernate.cache.HashtableCacheProvider 默认实现
#hibernate.cache.provider_class org.hibernate.cache.TreeCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.OSCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.SwarmCacheProvider

二级缓存使用步骤:

1.开始二级缓存

2.指定缓存框架

3.指定哪些类加入二级缓存

4.测试

3.缓存策略

<class-cache usage="read-only"/>     放入二级缓存的对象,只读;
<class-cache usage="nonstrict-read-write"/> 非严格的读写
<class-cache usage="read-write"/> 读写; 放入二级缓存的对象可以读、写;
<class-cache usage="transactional"/> (基于事务的策略)

4.集合缓存

<!-- 集合缓存[集合缓存的元素对象,也加加入二级缓存] -->
<collection-cache
usage="read-write" collection="cn.itcast.b_second_cache.Dept.emps"/>

5.查询缓存

list()默认情况只会放入缓存,不会从一级缓存中取出.

使用查询缓存,可以让list()查询从二级缓存中取出

代码示例:

Hibernate.cfg.xml中配置二级缓存

<!-- 【二级缓存配置】 -->
<!-- a. 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- b. 指定使用哪一个缓存框架(默认提供的) -->
<property name="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</property>
<!-- 开启查询缓存 -->
<property name="hibernate.cache.use_query_cache">true</property>
<!-- c. 指定哪一些类,需要加入二级缓存 -->
<class-cache usage="read-write" class="cn.itcast.b_second_cache.Dept"/>
<class-cache usage="read-only" class="cn.itcast.b_second_cache.Employee"/>
<!-- 集合缓存[集合缓存的元素对象,也加加入二级缓存] -->
<collection-cache usage="read-write" collection="cn.itcast.b_second_cache.Dept.emps"/>

测试类:

public class App {

	private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Dept.class)
.buildSessionFactory();
}
// 1. 测试二级缓存的使用
// 没有/有用 二级缓存
@Test
public void testCache() {
Session session1 = sf.openSession();
session1.beginTransaction();
// a. 查询一次
Dept dept = (Dept) session1.get(Dept.class, 10);
dept.getEmps().size();// 集合
session1.getTransaction().commit();
session1.close(); System.out.println("------"); // 第二个session
Session session2 = sf.openSession();
session2.beginTransaction();
// a. 查询一次
dept = (Dept) session2.get(Dept.class, 10); // 二级缓存配置好; 这里不查询数据库
dept.getEmps().size(); session2.getTransaction().commit();
session2.close();
} @Test
public void listCache() {
Session session1 = sf.openSession();
session1.beginTransaction();
// HQL查询 【setCacheable 指定从二级缓存找,或者是放入二级缓存】
Query q = session1.createQuery("from Dept").setCacheable(true);
System.out.println(q.list());
session1.getTransaction().commit();
session1.close(); Session session2 = sf.openSession();
session2.beginTransaction();
q = session2.createQuery("from Dept").setCacheable(true);
System.out.println(q.list()); // 不查询数据库: 需要开启查询缓存
session2.getTransaction().commit();
session2.close();
}
}

4.项目中session的管理方式

    //项目中session的管理方式
@Test
public void testSession() throws Exception{
SessionFactory sf = new Configuration().configure().buildSessionFactory(); //openSession:创建Session,每次都会创建一个新的session
Session session1 = sf.openSession();
Session session2 = sf.openSession();
System.out.println(session1==session2);//false
session1.close();
session2.close(); //线程方式创建session
// 一定要配置:<property name="hibernate.current_session_context_class">thread</property>
//getCurrentSession()创建或者获取session
Session session3 = sf.getCurrentSession();
Session session4 = sf.getCurrentSession();
System.out.println(session3==session4);//true //关闭:以线程方式创建的session,可以不用关闭,线程结束时session自动结束
// session3.close();
// session4.close();//报错,因为同一个session已经关闭 }