Hibernate之二级缓存

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6     <session-factory>
 7         <!-- 配置连接数据库的基本信息 -->
 8         <property name="connection.username">scott</property>
 9         <property name="connection.password">tiger</property>
10         <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
11         <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
12     
13         <!-- 配置hibernate基本信息 -->
14         <!-- hibernate所使用的数据库方言 -->
15         <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
16         
17         <!-- 执行操作时是否在控制台打印sql -->
18         <property name="show_sql">true</property>
19         
20         <!-- 是否对SQL进行格式化 -->        
21         <property name="format_sql">true</property>
22         
23         <!-- 指定自动生成数据表的策略 -->
24         <property name="hbm2ddl.auto">update</property>
25         
26         <!-- 设置Hibernate 的事务的隔离级别 -->
27         <property name="connection.isolation">2</property>
28         
29         <!-- 删除对象后，使其OID置为null -->
30         <property name="hibernate.use_identifier_rollback">true</property>
31         
32         <!-- 配置C3P0数据源 -->
33         <!-- 
34         <property name="hibernate.c3p0.max_size">10</property>
35         <property name="hibernate.c3p0.min_size">5</property>
36         <property name="c3p0.acquire_increment">2</property>
37          
38         <property name="c3p0.idle_test_period">2000</property>
39         <property name="c3p0.timeout">2000</property>
40         
41         <property name="c3p0.max_statements">10</property>
42          -->
43          
44         <!-- 设定JDBC的Statement 读取数据的时候每次从数据库中取出的数据条数 -->
45         <property name="hibernate.jdbc.fetch_size">100</property>
46          
47         <!-- 设定对数据库进行批量删除、批量更新和批量插入的时候的批次的大小 -->
48         <property name="hibernate.jdbc.batch_size">30</property>
49         
50         <!-- 启用二级缓存 -->
51         <property name="cache.use_second_level_cache">true</property>
52         
53         <!-- 配置使用的二级缓存的产品 -->
54         <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
55         
56         <!-- 配置启用查询缓存 -->
57         <property name="cache.use_query_cache">true</property>
58         
59         <!-- 指定关联的.hbm.xml 文件 -->
60         <mapping resource="com/yl/hibernate/entities/Department.hbm.xml"/>
61         <mapping resource="com/yl/hibernate/entities/Employee.hbm.xml"/>
62         
63         <class-cache usage="read-write" class="com.yl.hibernate.entities.Employee"/>
64         
65         <class-cache usage="read-only" class="com.yl.hibernate.entities.Department"/>
66         <collection-cache usage="read-only" collection="com.yl.hibernate.entities.Department.emps"/>
67 
68     </session-factory>
69 </hibernate-configuration>

<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User‘s home directory
         user.dir - User‘s current working directory
         java.io.tmpdir - Default temp file path -->
    <!-- 
        指定一个目录，当EHCache 把数据写到硬盘上时，将把数据写到这个目录下
     -->
    <!-- <diskStore path="java.io.tmpdir"/> -->
    <diskStore path="D:\\tmpdir"/>


    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->
    <!-- 
        设置缓存的默认数据过期策略
     -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

    <!--Predefined caches.  Add your cache configuration settings here.
        If you do not have a configuration for your cache a WARNING will be issued when the
        CacheManager starts

        The following attributes are required for defaultCache:

        name              - Sets the name of the cache. This is used to identify the cache. It must be unique.
        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->

    <!-- Sample cache named sampleCache1
        This cache contains a maximum in memory of 10000 elements, and will expire
        an element if it is idle for more than 5 minutes and lives for more than
        10 minutes.

        If there are more than 10000 elements it will overflow to the
        disk cache, which in this configuration will go to wherever java.io.tmp is
        defined on your system. On a standard Linux system this will be /tmp"
        -->
    <!-- 
        设定具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域
        缓存区域(region):一个具有名称的缓存块，可以给每一个缓存块设置不同的缓存策略。
        如果没有设置任何的缓存区域，则所有被缓存的对象，都将使用默认的缓存策略。即:<defaultCache.../>
        
        Hibernate在不同的缓存区域保存不同的类/集合
            对于类而言，区域的名称是类名。如：com.yl.domain.Customer
            对于集合而言，区域的名称是类名加属性名。如：com.yl.domain.Customer.orders
     -->
     <!-- 
         name:设置缓存的名字，它的取值为类的全限定名或类的集合的名字
        maxInMemory:设置基于内存的缓存中可存放的对象最大数目
        eternal:设置对象是否为永久的，true表示永不过期，此时将忽略timeToIdleSeconds和timeToLiveSeconds属性；默认值是false
        timeToIdleSeconds:设置对象空闲最长时间，以秒为单位，超过这个时间，对象过期，当对象过期时，EHCache会把它从缓存中清除。如果此值为0，表示对象可以无限期地处于空闲状态
        timeToLiveSeconds:设置对象生存最长时间，超过这个时间，对象过期。如果此值为0，表示对象可以无限期地存在于缓存中。该属性值必须大于或等于timeToIdleSeconds属性值
        overflowToDisk:设置基于内在的缓存中的对象数目达到上线后，是否把溢出的对象写到基于硬盘的缓存中
      -->
    <cache name="com.yl.hibernate.entities.Employee"
        maxElementsInMemory="1"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <!-- Sample cache named sampleCache2
        This cache contains 1000 elements. Elements will always be held in memory.
        They are not expired. -->
    <cache name="com.yl.hibernate.entities.Department.emps"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->

    <!-- Place configuration for your caches following -->

</ehcache>

  1 package com.yl.hibernate.test;
  2 
  3 
  4 import java.util.ArrayList;
  5 import java.util.Arrays;
  6 import java.util.Iterator;
  7 import java.util.LinkedHashSet;
  8 import java.util.List;
  9 import java.util.Set;
 10 
 11 import oracle.net.aso.e;
 12 
 13 import org.hibernate.Criteria;
 14 import org.hibernate.Query;
 15 import org.hibernate.Session;
 16 import org.hibernate.SessionFactory;
 17 import org.hibernate.Transaction;
 18 import org.hibernate.cfg.Configuration;
 19 import org.hibernate.criterion.Conjunction;
 20 import org.hibernate.criterion.Disjunction;
 21 import org.hibernate.criterion.MatchMode;
 22 import org.hibernate.criterion.Order;
 23 import org.hibernate.criterion.Projection;
 24 import org.hibernate.criterion.Projections;
 25 import org.hibernate.criterion.Restrictions;
 26 import org.hibernate.service.ServiceRegistry;
 27 import org.hibernate.service.ServiceRegistryBuilder;
 28 import org.junit.After;
 29 import org.junit.Before;
 30 import org.junit.Test;
 31 
 32 import com.yl.hibernate.entities.Department;
 33 import com.yl.hibernate.entities.Employee;
 34 
 35 public class HibernateTest {
 36 
 37     private SessionFactory sessionFactory;
 38     private Session session;
 39     private Transaction transaction;
 40     
 41     @Before
 42     public void init() {
 43         Configuration configuration = new Configuration().configure();
 44         ServiceRegistry serviceRegistry = 
 45                 new ServiceRegistryBuilder().applySettings(configuration.getProperties())
 46                                             .buildServiceRegistry();
 47 
 48         sessionFactory = configuration.buildSessionFactory(serviceRegistry);
 49         
 50         session = sessionFactory.openSession();
 51 
 52         transaction = session.beginTransaction();
 53     }
 54     @After
 55     public void destory() {
 56         transaction.commit();
 57         
 58         session.close();
 59         
 60         sessionFactory.close();
 61     }
 62 
 63     
 64     @Test
 65     public void testHibernateSecondLevelCache() {
 66         Employee employee = (Employee) session.get(Employee.class, 7369);
 67         System.out.println(employee.getName());
 68         
 69         transaction.commit();
 70         session.close();
 71         
 72         session = sessionFactory.openSession();
 73         transaction = session.beginTransaction();
 74         
 75         Employee employee2 = (Employee) session.get(Employee.class, 7369);
 76         System.out.println(employee2.getName());
 77         
 78     }
 79     
 80     @Test
 81     public void testCollectionSecondLevelCache() {
 82         Department dept = (Department) session.get(Department.class, 20);
 83         System.out.println(dept.getName());
 84         System.out.println(dept.getEmps().size());
 85         
 86         transaction.commit();
 87         session.close();
 88         
 89         session = sessionFactory.openSession();
 90         transaction = session.beginTransaction();
 91         
 92         Department dept2 = (Department) session.get(Department.class, 20);
 93         System.out.println(dept2.getName());
 94         System.out.println(dept2.getEmps().size());
 95     }
 96     
 97     /**
 98      * 查询缓存依赖于二级缓存
 99      */
100     @Test
101     public void TestQueryCache() {
102         Query query = session.createQuery("FROM Employee");
103         query.setCacheable(true);
104         
105         List<Employee> emps = query.list();
106         System.out.println(emps.size());
107         
108         emps = query.list();
109         System.out.println(emps.size());
110         
111         Criteria criteria = session.createCriteria(Employee.class);
112         criteria.setCacheable(true);
113     }
114     
115     @Test
116     public void testUpdateTimestampCache() {
117         Query query = session.createQuery("FROM Employee");
118         query.setCacheable(true);
119         
120         List<Employee> emps = query.list();
121         System.out.println(emps.size());
122         
123         Employee employee = (Employee) session.get(Employee.class, 7839);
124         employee.setSalary(15000F);
125         
126         emps = query.list();
127         System.out.println(emps.size());
128     }
129     
130     @Test
131     public void testQueryIterate() {
132         Department dept = (Department) session.get(Department.class, 20);
133         System.out.println(dept.getName());
134         System.out.println(dept.getEmps().size());
135         
136         Query query = session.createQuery("FROM Employee e WHERE e.dept.id = 20");
137         /*List<Employee> emps = query.list();
138         System.out.println(emps.size());*/
139         
140         Iterator<Employee> empIt = query.iterate();
141         while (empIt.hasNext()) {
142             System.out.println(empIt.next().getName());
143         }
144         
145     }
146     
147     
148     
149 }