hibernate的缓存机制

private Session session;
	private Transaction transaction;
	
	@Before
	public void init(){
		session = HibernateUtils.openSession();
		transaction = session.beginTransaction();
	}
	
	@Test
	public void testGet(){
		User user = (User) session.get(User.class, 1);//发sql,把对象放入到一级缓存中
		User user2 = (User) session.get(User.class, 1);//从一级缓存中直接取,不发sql
		//hibernate提供一个统计机制。获取缓存中实体的个数
		int count = session.getStatistics().getEntityCount();
		System.out.println(count);//1,所以get方法把对象放入到缓存
		transaction.commit();
		session.close();
	}
	
	
	@Test
	public void testSave(){
		User user = new User();
		user.setAge(250);
		user.setName("heh");
		session.save(user);
		int count = session.getStatistics().getEntityCount();
		System.out.println(count);//1,所以save方法把对象放入到缓存
		transaction.commit();
		session.close();
	}
	
	@Test
	public void testEvict(){
		User user = (User) session.get(User.class, 1);
		session.evict(user);
		int count = session.getStatistics().getEntityCount();
		System.out.println(count);//0,evit方法把get放入到缓存中的对象,清空了
		transaction.commit();
		session.close();
	}
	
	@Test
	public void testUpdate(){
		User user = (User) session.get(User.class, 1);
		session.evict(user);
		/**
		 * 此处注意,evict方法之后,执行update会发送sql,即使对象不做任何修改
		 * 此处,可以加深session.flush(),进行的对照副本的操作的理解
		 * 注释掉evict,就不会发送update语句
		 */
		session.update(user);
		int count = session.getStatistics().getEntityCount();
		
		System.out.println(count);//1,update方法把对象放入到缓存
		transaction.commit();
		session.close();
	}
	
 
	@Test
	public void testClear(){
		User user = (User) session.get(User.class, 1);
		session.clear();
		int count = session.getStatistics().getEntityCount();
		System.out.println(count);//0,清空所有
		transaction.commit();
		session.close();
	}

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 
<session-factory>
 
	<property name="hibernate.dialect"><![CDATA[org.hibernate.dialect.MySQLDialect]]></property>
	<property name="hibernate.connection.driver_class"><![CDATA[com.mysql.jdbc.Driver]]></property>
	<property name="hibernate.connection.url"><![CDATA[jdbc:mysql:///hibernate1]]></property>
	<property name="hibernate.connection.username"><![CDATA[root]]></property>
	<property name="hibernate.connection.password"><![CDATA[qiaolezi]]></property>
 
	<property name="hibernate.c3p0.max_size">20</property>
	<property name="hibernate.c3p0.min_size">10</property>
	<property name="hibernate.c3p0.max_statements">10</property>
	<property name="hibernate.c3p0.acquire_increment">5</property>
	<property name="hibernate.c3p0.timeout">3000</property>
	
	<!-- 二级缓存供应商 -->
	<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
	<!-- 开启二级缓存 -->
	<property name="cache.use_second_level_cache">true</property>
	<!-- 开启二级缓存的统计机制 -->
	<property name="generate_statistics">true</property>
	
	<property name="hbm2ddl.auto">update</property>
	<property name="show_sql">true</property>
	<property name="current_session_context_class">thread</property>
	<property name="format_sql">true</property>
	
	
	<mapping resource="cn/cil/domain/Classes.hbm.xml" />
	<mapping resource="cn/cil/domain/Student.hbm.xml" />
 
</session-factory>
</hibernate-configuration>

public class Classes implements Serializable{
 
	private Long cid;
	private String name;
	private Set<Student> students;
}

<class name="Classes" table="CLASSES">
		<cache usage="read-write"/><!-- 只读 -->
		<id name="cid">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		<set name="students" cascade="save-update" inverse="true">
			<cache usage="read-only"/><!-- 设置集合的二级缓存 -->
		<!-- key:外键,告诉hibernate通过cid来建立classes与student的关系 -->
			<key column="cid"></key>
			<one-to-many class="Student"/>
		</set>
	</class>

public class Student implements Serializable{
 
	private Long sid;
	private String name;
	private Classes classes;
}

<class name="Student" table="STUDENT">
		<id name="sid">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
	
		<many-to-one cascade="save-update" name="classes" column="cid" class="Classes">
		</many-to-one>
	</class>

public class SessionFactoryCacheTest {
 
	private Session session;
	private Transaction transaction;
	private SessionFactory sessionFactory;
	
	/**
	 * 测试get,在session关闭后,再次请求,不发出sql
	 * 该方法在取数据时,先从一级缓存中找,如果二级缓存开启了,接下来就会从二级缓存中,都没有,则查数据库
	 * 在DefaultLoadEventListener.class中可以清晰的看到
	 * 440行: 从一级缓存,459 行: 从二级缓存,477行: 从数据库
	 * 
	 * get可以把对象放入二级缓存,也可以从二级缓存中取数据
	 */
	@Test
	public void testGet(){
		
		sessionFactory = HibernateUtils.getSessionFactory();
		 session = HibernateUtils.openSession();
		Classes classes = (Classes) session.get(Classes.class, 1L);
		System.out.println(sessionFactory.getStatistics()
				.getEntityLoadCount());//1
		session.close();
		session = HibernateUtils.openSession();
	    classes = (Classes) session.get(Classes.class, 1L);//不发出sql
		session.close();
	}
	/**
	 * Hibernate提供了二级缓存的统计机制
	 * save不能把对象存入二级缓存
	 */
	@Test
	public void testSave(){
		sessionFactory = HibernateUtils.getSessionFactory();
		session = HibernateUtils.openSession();
		transaction = session.beginTransaction();
		Classes classes = new Classes();
		classes.setName("a");
		session.save(classes);
		System.out.println(sessionFactory.getStatistics()
				.getEntityLoadCount());//0
		transaction.commit();
		session.close();
	}
	
	/**
	 * session.update不操作二级缓存
	 */
	@Test
	public void testUpdate(){
		sessionFactory = HibernateUtils.getSessionFactory();
		session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		Classes classes = new Classes();
		classes.setCid(3L);
		classes.setName("afds");
		session.update(classes);
		System.out.println(sessionFactory.getStatistics()
				.getEntityInsertCount());//0
		transaction.commit();//会报错,但是不影响,设置为<cache usage="read-write">,如果集合也设置了二级缓存,那集合也要设置为同样
		session.close();
	}
	
	/**
	 * HQL中的list,可以把对象放入到二级缓存,但是不能从二级缓存取数据
	 */
	@Test
	public void testQueryList(){
		sessionFactory = HibernateUtils.getSessionFactory();
		session = sessionFactory.openSession();
		
		session.createQuery("from Classes").list();
		System.out.println(sessionFactory.getStatistics()
				.getEntityLoadCount());//不是0
		session.close();
		session = sessionFactory.openSession();
		session.createQuery("from Classes").list();//发出sql,因为getEntityLoadCount不为0,所以list()可以把对象放入二级缓存,但是不能从二级缓存中取对象
		session.close();
	}
	
	/**
	 *  iterator,可以从二级缓存中取数据
	 *  iterate方法的查询策略:
	 *  	先查找该表中所有的id值
	 *  	再根据id值从二级缓存中查找对象,如果有,则利用二级缓存,
	 *  						     如果没有,则根据id查询所有属性的值
	 */
	
	@Test
	public void testQueryIterate(){
		sessionFactory = HibernateUtils.getSessionFactory();
		session = sessionFactory.openSession();
		session.createQuery("from Classes").list();
		
		System.out.println(sessionFactory.getStatistics()
				.getEntityLoadCount());//不是0
		session.close();
		session = sessionFactory.openSession();
		Iterator<Classes> iterator = session.createQuery("from Classes").iterate();
		while (iterator.hasNext()) {
			Classes classes = (Classes) iterator.next();
			System.out.println(classes.getName());
		}
		
		session.close();
	}
	
	/**
	 * 集合的二级缓存,需要在hbm.xml文件中进行相应的设置
	 * 集合有一级缓存也有二级缓存
	 */
	@Test
	public void testCollection(){
		sessionFactory = HibernateUtils.getSessionFactory();
		session = sessionFactory.openSession();
		
		Classes classes = (Classes) session.get(Classes.class, 1L);
		Set<Student> students = classes.getStudents();
		for(Student student : students){
			System.out.println(student.getName());
		}
		System.out.println(sessionFactory.getStatistics()
				.getCollectionLoadCount());//1
		session.close();
	}
	
	
	/**
	 * 二级缓存 到 磁盘
	 */
	@Test
	public void testCacheDisk(){
		sessionFactory = HibernateUtils.getSessionFactory();
		session = sessionFactory.openSession();
		
		session.createQuery("from Classes").list();
		try {
			Thread.sleep(2000L);//停一会,否则写不进去数据
		} catch (Exception e) {
			
			e.printStackTrace();
		}
		session.close();
	}
}

public class QueryCacheTest {
 
	private Session session;
	private Transaction transaction;
	private SessionFactory sessionFactory;
	
	@Test
	public void testList1(){
		
		session = HibernateUtils.openSession();
 
		Query query = session.createQuery("from Classes");
		query.setCacheable(true);//query要使用查询缓存
		query.list();//把数据放入查询缓存
		session.close();
		
		session = HibernateUtils.openSession();
		query = session.createQuery("from Classes");
		query.setCacheable(true);
		query.list();//不发出sql
		session.close();
	} 
	
	
	/**
	 * "select name from Classes" 查name
	 * 		查询出来的数据能够放入到查询缓存中
	 *      但是不能放入到二级缓存中，因为不是对象
	 */
	@Test
	public void testList_2(){
		session = HibernateUtils.openSession();
		Query query = session.createQuery("select name from Classes");
		query.setCacheable(true);
		query.list();
		System.out.println(HibernateUtils.getSessionFactory()
				.getStatistics().getEntityLoadCount());//0,因为name就是一个数据,不是对象,所以不能放到二级缓存中
		session.close();
		
		session = HibernateUtils.openSession();
		query = session.createQuery("select name from Classes");
		query.setCacheable(true);
		query.list();
		session.close();
	}
	
	/**
	 * 如果两个hql一样，则可以利用查询缓存,
	 * 如果不一样，哪怕有一点不一样，就不能够利用了。
	 */
	@Test
	public void testList_3(){
		session = HibernateUtils.openSession();
		Query query = session.createQuery("select name from Classes");
		query.setCacheable(true);
		query.list();
		session.close();
		
		session = HibernateUtils.openSession();
		query = session.createQuery("select name from Classes where cid=1");
		query.setCacheable(true);
		query.list();//发出sql语句,按理说第二条hql可以从第一条中取,但是查询缓存不行,其命中率特别低
		session.close();
	}
	
	
	
	/**
	 * 先把一些数据放入到查询缓存中，修改一些数据，看生命周期
	 */
	@Test
	public void testActiveTime(){
		/**
		 * 把name放入到了查询缓存中
		 */
		Session session = HibernateUtils.openSession();
		Query query = session.createQuery("select name from Classes");
		query.setCacheable(true);
		query.list();
		session.close();
		
		/**
		 * 修改name属性的值
		 *   修改了查询缓存的时间戳缓存，从而知道了该数据已经被修改了,查询缓存中的数据就被清空了
		 */
		session = HibernateUtils.openSession();
		transaction = session.beginTransaction();
		Classes classes = (Classes)session.get(Classes.class, 1L);
		classes.setName("123213456");
		transaction.commit();
		session.close();
		
		/**
		 * 再次查询name属性的值,查询缓存中name属性的值清空了
		 */
		session = HibernateUtils.openSession();
		query = session.createQuery("select name from Classes");
		query.setCacheable(true);
		query.list();//发出sql
		session.close();
	}
}