/*** 此时会发出一条sql，将30个学生全部查询出来*/List<Student> ls = (List<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();){Student stu = (Student)stus.next();System.out.println(stu.getName());}

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?

　　　　　　　/*** 如果使用iterator方法返回列表，对于hibernate而言，它仅仅只是发出取id列表的sql* 在查询相应的具体的某个学生信息时，会发出相应的SQL去取学生信息* 这就是典型的N+1问题* 存在iterator的原因是，有可能会在一个session中查询两次数据，如果使用list每一次都会把所有的对象查询上来* 而是要iterator仅仅只会查询id，此时所有的对象已经存储在一级缓存(session的缓存)中，可以直接获取*/Iterator<Student> stus = (Iterator<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).iterate();for(;stus.hasNext();){Student stu = (Student)stus.next();System.out.println(stu.getName());}

Hibernate: select student0_.id as col_0_0_ from t_student student0_ limit ?
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
沈凡
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
王志名
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
叶敦
.........

　　　　　　　/*** 此时会发出一条sql，将所有学生全部查询出来，并放到session的一级缓存当中* 当再次查询学生信息时，会首先去缓存中看是否存在，如果不存在，再去数据库中查询* 这就是hibernate的一级缓存(session缓存)*/List<Student> stus = (List<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).list();Student stu = (Student)session.load(Student.class, 1);

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?

　　　　　try{session = HibernateUtil.openSession();/*** 此时会发出一条sql，将所有学生全部查询出来，并放到session的一级缓存当中* 当再次查询学生信息时，会首先去缓存中看是否存在，如果不存在，再去数据库中查询* 这就是hibernate的一级缓存(session缓存)*/List<Student> stus = (List<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).list();Student stu = (Student)session.load(Student.class, 1);System.out.println(stu.getName() + "-----------");}catch (Exception e){e.printStackTrace();}finally{HibernateUtil.close(session);}/*** 当session关闭以后，session的一级缓存也就没有了，这时就又会去数据库中查询*/session = HibernateUtil.openSession();Student stu = (Student)session.load(Student.class, 1);System.out.println(stu.getName() + "-----------");

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?

　　　　 <!-- 开启二级缓存 --><property name="hibernate.cache.use_second_level_cache">true</property><!-- 二级缓存的提供类 在hibernate4.0版本以后我们都是配置这个属性来指定二级缓存的提供类--><property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property><!-- 二级缓存配置文件的位置 --><property name="hibernate.cache.provider_configuration_file_resource_path">ehcache.xml</property>

<!--这个类在4.0版本以后已经不建议被使用了-->
<property name="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvider</property>

<ehcache><!-- Sets the path to the directory where cache .data files are created.If the path is a Java System Property it is replaced byits value in the running VM.The following properties are translated:user.home - User's home directoryuser.dir - User's current working directoryjava.io.tmpdir - Default temp file path -->
　　
　　<!--指定二级缓存存放在磁盘上的位置--><diskStore path="user.dir"/>　　<!--我们可以给每个实体类指定一个对应的缓存，如果没有匹配到该类，则使用这个默认的缓存配置--><defaultCachemaxElementsInMemory="10000"　　//在内存中存放的最大对象数eternal="false"　　　　　　　　　//是否永久保存缓存，设置成falsetimeToIdleSeconds="120"　　　　timeToLiveSeconds="120"　　　　overflowToDisk="true"　　　　　//如果对象数量超过内存中最大的数，是否将其保存到磁盘中，设置成true/>
　　<!--

　　　　1、timeToLiveSeconds的定义是：以创建时间为基准开始计算的超时时长；
2、timeToIdleSeconds的定义是：在创建时间和最近访问时间中取出离现在最近的时间作为基准计算的超时时长；
3、如果仅设置了timeToLiveSeconds，则该对象的超时时间=创建时间+timeToLiveSeconds，假设为A；
4、如果没设置timeToLiveSeconds，则该对象的超时时间=max(创建时间，最近访问时间)+timeToIdleSeconds，假设为B；
5、如果两者都设置了，则取出A、B最少的值，即min(A,B)，表示只要有一个超时成立即算超时。

　　-->
<!--可以给每个实体类指定一个配置文件，通过name属性指定，要使用类的全名--><cache name="com.xiaoluo.bean.Student"maxElementsInMemory="10000"eternal="false"timeToIdleSeconds="300"timeToLiveSeconds="600"overflowToDisk="true"/><cache name="sampleCache2"maxElementsInMemory="1000"eternal="true"timeToIdleSeconds="0"timeToLiveSeconds="0"overflowToDisk="false"/> --></ehcache>

<hibernate-mapping package="com.xiaoluo.bean"><class name="Student" table="t_student"><!-- 二级缓存一般设置为只读的 --><cache usage="read-only"/><id name="id" type="int" column="id"><generator class="native"/></id><property name="name" column="name" type="string"></property><property name="sex" column="sex" type="string"></property><many-to-one name="room" column="rid" fetch="join"></many-to-one></class>
</hibernate-mapping>

@Entity
@Table(name="t_student")
@Cache(usage=CacheConcurrencyStrategy.READ_ONLY)　　//　　表示开启二级缓存，并使用read-only策略
public class Student
{private int id;private String name;private String sex;private Classroom room;.......
}

public class TestSecondCache
{@Testpublic void testCache1(){Session session = null;try{session = HibernateUtil.openSession();Student stu = (Student) session.load(Student.class, 1);System.out.println(stu.getName() + "-----------");}catch (Exception e){e.printStackTrace();}finally{HibernateUtil.close(session);}try{/*** 即使当session关闭以后，因为配置了二级缓存，而二级缓存是sessionFactory级别的，所以会从缓存中取出该数据* 只会发出一条sql语句*/session = HibernateUtil.openSession();Student stu = (Student) session.load(Student.class, 1);System.out.println(stu.getName() + "-----------");/*** 因为设置了二级缓存为read-only，所以不能对其进行修改*/session.beginTransaction();stu.setName("aaa");session.getTransaction().commit();}catch (Exception e){e.printStackTrace();session.getTransaction().rollback();}finally{HibernateUtil.close(session);}}

Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
aaa-----------
aaa-----------

　　@Testpublic void testCache2(){Session session = null;try{session = HibernateUtil.openSession();/*** 注意：二级缓存中缓存的仅仅是对象，而下面这里只保存了姓名和性别两个字段，所以 不会被加载到二级缓存里面*/List<Object[]> ls = (List<Object[]>) session.createQuery("select stu.name, stu.sex from Student stu").setFirstResult(0).setMaxResults(30).list();}catch (Exception e){e.printStackTrace();}finally{HibernateUtil.close(session);}try{/*** 由于二级缓存缓存的是对象，所以此时会发出两条sql*/session = HibernateUtil.openSession();Student stu = (Student) session.load(Student.class, 1);System.out.println(stu);}catch (Exception e){e.printStackTrace();}}

Hibernate: select student0_.name as col_0_0_, student0_.sex as col_1_0_ from t_student student0_ limit ?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?

　　@Testpublic void testCache3(){Session session = null;try{session = HibernateUtil.openSession();/*** 将查询出来的Student对象缓存到二级缓存中去*/List<Student> stus = (List<Student>) session.createQuery("select stu from Student stu").list();}catch (Exception e){e.printStackTrace();}finally{HibernateUtil.close(session);}try{/*** 由于学生的对象已经缓存在二级缓存中了，此时再使用iterate来获取对象的时候，首先会通过一条* 取id的语句，然后在获取对象时去二级缓存中，如果发现就不会再发SQL，这样也就解决了N+1问题 * 而且内存占用也不多*/session = HibernateUtil.openSession();Iterator<Student> iterator = session.createQuery("from Student").iterate();for (; iterator.hasNext();){Student stu = (Student) iterator.next();System.out.println(stu.getName());}}catch (Exception e){e.printStackTrace();}}

　　@Testpublic void testCache4(){Session session = null;try{session = HibernateUtil.openSession();List<Student> ls = session.createQuery("from Student").setFirstResult(0).setMaxResults(50).list();}catch (Exception e){e.printStackTrace();}finally{HibernateUtil.close(session);}try{/*** 使用List会发出两条一模一样的sql，此时如果希望不发sql就需要使用查询缓存*/session = HibernateUtil.openSession();List<Student> ls = session.createQuery("from Student").setFirstResult(0).setMaxResults(50).list();Iterator<Student> stu = ls.iterator();for(;stu.hasNext();){Student student = stu.next();System.out.println(student.getName());}}catch (Exception e){e.printStackTrace();}finally{HibernateUtil.close(session);}}

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?

　　　　　<!-- 开启查询缓存 --><property name="hibernate.cache.use_query_cache">true</property>

List<Student> ls = session.createQuery("from Student where name like ?").setCacheable(true)　　//开启查询缓存，查询缓存也是SessionFactory级别的缓存.setParameter(0, "%王%").setFirstResult(0).setMaxResults(50).list();

　　@Testpublic void test2() {Session session = null;try {/*** 此时会发出一条sql取出所有的学生信息*/session = HibernateUtil.openSession();List<Student> ls = session.createQuery("from Student").setCacheable(true)  //开启查询缓存,查询缓存也是sessionFactory级别的缓存.setFirstResult(0).setMaxResults(50).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();) {Student stu = stus.next();System.out.println(stu.getName());}} catch (Exception e) {e.printStackTrace();} finally {HibernateUtil.close(session);}try {/*** 此时会发出一条sql取出所有的学生信息*/session = HibernateUtil.openSession();List<Student> ls = session.createQuery("from Student").setCacheable(true)  //开启查询缓存,查询缓存也是sessionFactory级别的缓存.setFirstResult(0).setMaxResults(50).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();) {Student stu = stus.next();System.out.println(stu.getName());}} catch (Exception e) {e.printStackTrace();} finally {HibernateUtil.close(session);}}

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ limit ?

　　@Testpublic void test3() {Session session = null;try {/*** 此时会发出一条sql取出所有的学生信息*/session = HibernateUtil.openSession();List<Student> ls = session.createQuery("from Student where name like ?").setCacheable(true)//开启查询缓存，查询缓存也是SessionFactory级别的缓存.setParameter(0, "%王%").setFirstResult(0).setMaxResults(50).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();) {Student stu = stus.next();System.out.println(stu.getName());}} catch (Exception e) {e.printStackTrace();} finally {HibernateUtil.close(session);}session = null;try {/*** 此时会发出一条sql取出所有的学生信息*/session = HibernateUtil.openSession();/*** 只有当HQL完全相同的时候，连参数都要相同，查询缓存才有效*/
//            List<Student> ls = session.createQuery("from Student where name like ?")
//                    .setCacheable(true)//开启查询缓存，查询缓存也是SessionFactory级别的缓存
//                    .setParameter(0, "%王%")
//                    .setFirstResult(0).setMaxResults(50).list();List<Student> ls = session.createQuery("from Student where name like ?").setCacheable(true)//开启查询缓存，查询缓存也是SessionFactory级别的缓存.setParameter(0, "%张%").setFirstResult(0).setMaxResults(50).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();) {Student stu = stus.next();System.out.println(stu.getName());}} catch (Exception e) {e.printStackTrace();} finally {HibernateUtil.close(session);}}

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ where student0_.name like ? limit ?Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ where student0_.name like ? limit ?

　　　　　<!-- 二级缓存一般设置为只读的 --><!--　　<cache usage="read-only"/>　　-->

　　@Testpublic void test4() {Session session = null;try {/*** 查询缓存缓存的不是对象而是id*/session = HibernateUtil.openSession();List<Student> ls = session.createQuery("from Student where name like ?").setCacheable(true)//开启查询缓存，查询缓存也是SessionFactory级别的缓存.setParameter(0, "%王%").setFirstResult(0).setMaxResults(50).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();) {Student stu = stus.next();System.out.println(stu.getName());}} catch (Exception e) {e.printStackTrace();} finally {HibernateUtil.close(session);}session = null;try {/*** 查询缓存缓存的是id，此时由于在缓存中已经存在了这样的一组学生数据，但是仅仅只是缓存了* id，所以此处会发出大量的sql语句根据id取对象，这也是发现N+1问题的第二个原因* 所以如果使用查询缓存必须开启二级缓存*/session = HibernateUtil.openSession();List<Student> ls = session.createQuery("from Student where name like ?").setCacheable(true)//开启查询缓存，查询缓存也是SessionFactory级别的缓存.setParameter(0, "%王%").setFirstResult(0).setMaxResults(50).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();) {Student stu = stus.next();System.out.println(stu.getName());}} catch (Exception e) {e.printStackTrace();} finally {HibernateUtil.close(session);}}

Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.sex as sex2_, student0_.rid as rid2_ from t_student student0_ where student0_.name like ? limit ?Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?
Hibernate: select student0_.id as id2_2_, student0_.name as name2_2_, student0_.sex as sex2_2_, student0_.rid as rid2_2_, classroom1_.id as id1_0_, classroom1_.name as name1_0_, classroom1_.sid as sid1_0_, special2_.id as id0_1_, special2_.name as name0_1_, special2_.type as type0_1_ from t_student student0_ left outer join t_classroom classroom1_ on student0_.rid=classroom1_.id left outer join t_special special2_ on classroom1_.sid=special2_.id where student0_.id=?.........................