Hibernate-day04

HIbernate中的HQL查询

Hibernate中的查询方式:
1,使用HQL:使用hibernate提供的面向对象的查询语句;
2,使用SQL:在hibernate中允许使用原生的SQL直接查询;
3,使用Criteria:hibernate提供的完全的面向对象的查询方式;

1,HQL:
HQL的学习方法HQL是面向对象的,但是HQL借鉴了SQL的语法结构,把SQL中关系模型的概念替换成面向对象的概念;

		//HQL是模型对象的,但是HQL借鉴了SQL的语法结构,把SQL中的关系模型的概念替换为面向对象的概念
		String hql = "SELECT e FROM Employee e WHERE e.name LIKE ? AND e.id BETWEEN ? AND ? ";
		List<Employee> ems = session.createQuery(hql)
							.setParameter(0, "%a%")
							.setParameter(1, 1L)
							.setParameter(2, 10L).list();
		System.out.println(ems);

2,SQL:使用session.createQuery来创建基于SQL的查询,
查询出来的结果是Object[]的集合;

		//使用SQL查询到的结果集是Object[] 的列表(list)
		String sql = "select * from employee where name like ? and id between ? and ?";
		List<Object[]> ret = session.createSQLQuery(sql)
					.setParameter(0, "%a%")
					.setParameter(1, 1L)
					.setParameter(2, 10L).list();
		for (int i = 0; i < ret.size(); i++) {
			System.out.println(Arrays.toString(ret.get(i)));
		}

3,Criteria:完全的面向对象的查询,所有的查询及条件的拼装都是通过Criteria对象的方法完成的（使用较少）;

		//select * from employee
		//List<Employee> ret = session.createCriteria(Employee.class).list();
		List<Employee> ret = session.createCriteria(Employee.class)
							.add(Restrictions.like("name", "a",MatchMode.ANYWHERE))
							.add(Restrictions.between("id", 1L, 10L)).list();
		System.out.println(ret);

选择:
1,HQL:面向对象的查询,查询出来的实体都是持久化的,hibernate为HQL做了很多的查询相关的优化,一般来说,对于简单的查询,我们都可以使用HQL(我们都是学过SQL的人)
2,SQL:对于性能要求较高的查询,我们一般直接使用SQL来完成查询;
3,Criteria:完全面向对象的,学习非常简单,对于某些简单的查询,可以直接使用Criteria,对于稍微复杂一点的查询,Criteria完全没有办法处理

分页查询:
1,分页需要些什么东西?总条数,每一页需要多少条数据,当前是第几页,当前页的数据;
2,查询当前页的数据,对于mysql来说,LIMIT ?,?
3,使用query.setFirstResult()方法来设置从第几条数据开始查询;
4,使用query.setMaxResult()方法来设置查询多少条数据;
5,setFristResult和setMaxResult对于SQL和Criteria的查询都有效;

		String hql = "select e from Employee e where e.name like ? and e.id between ? and ?";
		List<Employee> ems = session.createQuery(hql).setParameter(0, "%a%").setParameter(1, 1L).setParameter(2, 10L)
				.setFirstResult((currentPage -1)*pageSize)//setFirstResult==limit的第一个参数,代表从第几条数据开始查询
				.setMaxResults(pageSize)//setMaxResults==limit的第二个参数,代表最大查询多少条数据
				.list();
		System.out.println(ems);

查询总条数:
但是使用这种方式非常的不方便,因为我们知道我们查询出来的结果就只有一行数据;

		String hql = "select count(e) from Employee e";
		//在count中写e比写e.id要好,因为hibernate可以自动根据映射文件找到Employee的主键列,并使用主键列来替换count的内容
		List<Long> count = session.createQuery(hql).list();
		System.out.println(count.get(0));

使用query.uniqueResult()方法;

		//使用uniqueResult,这个方法可以真正的去执行查询
		//注意,这个方法只能用在我们确定结果集只有一行数据的时候,如果查询结果多于一行,则报错
		//uniqueResult方法对HQL和Criteria都有效
		Long count = (Long) session.createQuery("select count(e) from Employee e").uniqueResult();
		System.out.println(count);

　　

查询参数设置:
位置占位符:就是使用?号来代表查询参数,通过setParameter(index,object)来根据?的位置来设置参数的;
1,写HQL的时候很方便;
2,如果参数值不多,还是比较容易识别;
3,如果参数值过多,会造成索引不容易识别;如果调整参数位置,所有的设置参数的位置都要变;如果一个参数在多个条件中使用,必须重复设置;

名称占位符:
1,使用 :参数名称 格式来添加名称占位符;

		String hql = "select e from Employee e where e.name like :name and e.id between :low and :hi";
		List<Employee> ret = session.createQuery(hql)
							.setParameter("name", "%a%")
							.setParameter("low", 1L)
							.setParameter("hi", 10L).list();
		System.out.println(ret);

2,使用setParamter(String name,object)这个方法为名称占位符添加参数;
3,可以为多个参数起相同名字的名称占位符,在设置参数的时候只需要设置一次值,就可以在所有的位置设置好参数;
4,使用名称占位符可以给参数传列表值进去,很容易的完成in等查询;但是使用位置占位不行(只能直接拼在HQL里面);

		String hql = "select e from Employee e where e.id in (:ids)";
		List<Employee> ret = session.createQuery(hql).setParameterList("ids", new Long[]{1L, 2L,3L}).list();
		System.out.println(ret);

3,可以通过setEntity方法直接给HQL设置一个实体对象的参数,hibernate会自动的根据实体的关系,创建好对应的SQL

		Department dept = new Department();
		dept.setId(1L);
		//在hibernate中可以直接给查询语句的参数设置一个实体对象(可以使用位置占位符或者名称占位符)
		String hql = "select e from Employee e where e.dept = ?";
		List<Employee> ret = session.createQuery(hql).setEntity(0, dept).list();
		System.out.println(ret);

　　

查询结果:
1,查询一个实体对象;
　　直接查询实体对象返回的是实体对象的列表;注意,这个列表中所有的对象都是持久化对象,所以如果查询的数据量过大,记得分页+及时清空一级缓存;
2,投影查询;
　　1,查询一个简单属性;

		//查询一个简单属性,返回该属性类型的list集合
		List<String> ret = session.createQuery("select e.name from Employee e").list();
		System.out.println(ret);

		//如果查询的属性是一个实体对象,返回这个实体对象的列表
		//这个列表里的所有对象也都是持久化对象
		//使用属性的导航查询(e.dept),此处使用join来连接查询
		List<Department> dept = session.createQuery("select e.dept from Employee e").list();
		System.out.println(dept);

		//查询多个简单属性,返回Object[]类型的list集合
		List<Object[]> ret = session.createQuery("select e.name,e.salary from Employee e").list();
		for (int i = 0; i < ret.size(); i++) {
			System.out.println(Arrays.toString(ret.get(i)));
		}

		//查询多个简单属性并且其中包含实体对象属性,返回Object[]类型的list集
		//查询出来的实体对象都是持久化的对象
		List<Object[]> ret = session.createQuery("select e.name,e.salary,e.dept from Employee e").list();
		for (int i = 0; i < ret.size(); i++) {
			System.out.println(Arrays.toString(ret.get(i)));
		}

hibernate查询结果的封装:
员工的id,员工的工资,员工的姓名,员工对应部门的编号和部门名称,员工所在的城市

		//返回一个Object[]类型的list集合(1)
		String hql = "select e.id,e.name,e.salary,e.dept.name,e.dept.address.city,e.dept.sn from Employee e";
		List<Object[]> ret = session.createQuery(hql).list();
		for (Object[] os : ret) {
			System.out.println(Arrays.toString(os));
		}

		//使用new list把每一行数据包装成list对象(2)
		String hql = "select new list(e.id,e.name,e.salary,e.dept.name,e.dept.address.city,e.dept.sn) from Employee e";
		List<List<Object>> ret = session.createQuery(hql).list();
		for (List<Object> os : ret){
			System.out.println(os);
		}

		//使用new map 把每一行数据包装成map对象(3)
		//1.默认情况下,把查询的属性的位置作为map的key
		//2.可以给查询的属性添加别名,别名作为map的key,查询结果作为map的value
		String hql = "select new Map(e.id as eid,e.name as ename,e.salary as esalary,e.dept.name as dname,e.dept.address.city as dcity,e.dept.sn as dsn) from Employee e";
		List<Map<String, Object>> ret = session.createQuery(hql).list();
		for (Map<String, Object> os : ret){
			System.out.println(os);
		}

		//直接通过new VO对象来把结果包装成一个VO对象(4)
		//注意,VO对象需要一个构造方法,这个构造方法参数的顺序必须和查询的顺序匹配
		String hql = "select new EmployeeVO(e.id,e.name,e.salary,e.dept.name,e.dept.address.city,e.dept.sn) from Employee e";
		List<EmployeeVO> ret = session.createQuery(hql).list();
		for (EmployeeVO os : ret){
			System.out.println(os);
		}

　　

NamedQuery查询:
在hibernate中，执行查询需要先将HQL先翻译成SQL，再执行SQL。如果HQL比较复杂翻译的效率是比较低的。如果一条HQL重复执行，会重复翻译。效率低下。
如果在代码不同的地方重复使用到了相同的HQL,需要在不同的地方反复重写HQL;
hibernate提供了NamedQuery方式，来稍微提高静态HQL语句的执行效率。和对HQL的统一管理
NamedQuery使用：
在实体映射文件中添加：
<!--为HQL起名为findCustomersByName，该HQL在hibernate启动的时候就会翻译成SQL -->
<query name="findCustomersByName">
<![CDATA[from Customer c where c.name like :name]]>
</query>
查询的时候使用：
//通过getNamedQuery，得到的就是已经翻译为SQL的query对象，只需要设置参数查询就行了
NamedQuery的使用限制：NamedQuery里面只能配置静态的HQL。

二级缓存概念：
1，生命周期为整个应用的缓存（二级缓存是sessionFactory上的缓存，能提供整个应用中所有的session使用。）
2，所有的get,load方法，总是先查一级缓存，再查二级缓存，如果都没有，在去数据库里面查询。
3，不是所有的对象都适合放到二级缓存中。（读>>>写）
4，二级缓存有一些性能的指标
　　1），命中率（总的从二级缓存中取得的数量/总的取的数量）
　　2），最大对象数量；
　　3），最大空闲时间；
5，二级缓存实际上就是一个缓存，所以，hibernate并没有实现自己的二级缓存框架，而是用的开源的。
对象缓存策略：
　　1）,usage="read-only" ：放到二级缓存里面的对象是只读（性能最高）
　　2）,usage="read-write"：允许读写(对并发支持较好)
　　3）,usage="nonstrict-read-write":允许读写，但是在并发事务情况下会产生脏数据
　　4）,usage="transactional" :允许读写，并且支持全事务（只能在ApplicationServer环境下有用）
ehcache的配置:
<defaultCache>：默认的cache，相当于公用cache；
<cache>：自定义的cache；
共同的配置：
1，maxElementsInMemory：该缓存池放在内存中最大的缓存对象个数；
2，eternal：是否永久有效，如果设置为true，内存中对象永不过期；
3，timeToIdleSeconds：缓存对象最大空闲时间，单位：秒；
4，timeToLiveSeconds：缓存对象最大生存时间，单位：秒；
5，overflowToDisk：当内存中对象超过最大值，是否临时保存到磁盘；
6，maxElementsOnDisk：能保存到磁盘上最大对象数量；
7，diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔，默认是120秒
8，memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。

默认策略是LRU（最近最少使用），可以设置为FIFO（先进先出）或是LFU（较少使用）
在默认的情况下,不同类型的对象都是放在defaultCache中的;
自定义二级缓存（把某一个对象放到某一个特定的二级缓存区域）
1，在hibernate.cfg.xml文件中的class-cache添加region； （添加二级缓存区域）
<class-cache usage="nonstrict-read-write" class="com._520it.hibernate.day4.query.Employee" region="EMPLOYEE"/>
2，在hibernate.cfg.xml文件中的hibernate.propertie属性上添加region_prefix （添加二级缓存前缀）
<property name="cache.region_prefix">hibernate</property>
3，在ehcache.xml中配置一个cache,名字为region_prefix.region （为自己的对象配置一个缓存区域 ：前缀.缓存区域）
<cache name="hibernate.EMPLOYEE"
maxElementsInMemory="10000"
eternal="true"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
overflowToDisk="true"
/>
二级缓存的操作
//得到二级缓存对象
Cache cache=sf.getCache();
//剔除一个实例
cache.evictEntity(User.class, 1L);
//剔除某种类型的所有实例
cache.evictEntityRegion(User.class);
//剔除所有二级缓存实例
cache.evictEntityRegions();

查询缓存:(使用非常少,因为可能带来非常大的负面性能影响)
1,默认情况下,hibernate没有打开查询缓存;
2,使用查询缓存:
　　1）,打开查询缓存:
　　2）,在查询的时候,使用Query对象的.setCacheable(true)方法;
3,查询缓存使用的条件:
　　1,两条查询的HQL和查询参数必须完全一致;

Hibernate中的事务管理
使用Hibernate的锁机制主要是用来避免第一类丢失更新和第二类丢失更新;
Hibernate使用悲观锁其实就是使用数据库锁：
如果数据库不支持设置的锁机制，hibernate会使用该数据库提供的合适的锁机制来完成，而不会报错。

，使用session.load(class,id,LockOptions);加悲观锁，相当于发送SELECT ... FOR UPDATE

，使用session.get(class,id,LockOptions);加悲观锁，相当于发送SELECT ... FOR UPDATE

，使用session.buildLockRequest(LockOptions).lock(entity);加悲观锁，相当于发送SELECT id FROM ... FOR UPDATE

，使用query.setLockOptions(LockOptions)；加悲观锁，相当于发送SELECT... FOR UPDATE

使用一个额外的版本控制字段来防止第二类丢失更新（乐观锁机制）；

1，给表添加一个额外的数字类型字段version；

2，在insert一个对象的时候初始化version值为0；

3，在select的时候，查询出对象的版本号；

4，在update的时候，

　　1），更新版本号，version = version+1；

　　2），在update的where条件中带上当前更新对象的版本号 where .. and version = ?

　　3），如果update返回影响条数>0，说明更新成功；

　　4），如果update返回影响条数=0，说明更新的对象已经被其他事务更新或者删除，抛出异常，回滚当前事务；

在hibernate中使用乐观锁，推荐使用version方式；

1，给对象添加一个int version字段，最好设置属性为private；

2，在mapping文件中添加<version>元素即可；

事务并发5类问题（如果数据库没有做任何并发处理的情况下）：

　　第一类丢失更新：两个事务更新相同数据，如果一个事务提交，另一个事务回滚，第一个事务的更新会被回滚

　　脏读：第二个事务查询到第一个事务未提交的更新数据，第二个事务根据该数据执行，但第一个事务回滚，第二个事务操作脏数据

　　虚读：一个事务查询到了另一个事务已经提交的新数据，导致多次查询数据不一致

　　不可重复读：一个事务查询到另一个事务已经修改的数据，导致多次查询数据不一致

　　第二类丢失更新：多个事务同时读取相同数据，并完成各自的事务提交，导致最后一个事务提交会覆盖前面所有事务对数据的改变

一般情况，数据库都会处理一些事务并发的问题，数据库提供了不同的事务隔离级别来处理不同的事务并发问题，事务隔离级别定义如下：

READ_UNCOMMITED：允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读（相当于没有做任何事务隔离）

READ_COMMITTED：允许在并发事务已经提交后读取。可防止脏读，但幻读和 不可重复读仍可发生（ORACLE默认级别）

REPEATABLE_READ：对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。（MYSQL默认级别）

SERIALIZABLE：完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。（ORACLE支持）

所以，数据库的隔离级别除了SERIALIZABLE，都不能处理第一类丢失更新和第二类丢失更新；

所以，数据库提供了锁机制来防止第一类丢失更新和第二类丢失更新；