Hibernate入门10_二级缓存02_集合级别

一、测试项目目录

二、代码

public class Department {
    private Integer id;
    private String name;
    private Set<Employee> employees = new HashSet<>();
    //get/set...
}

Department.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-4-4 15:42:11 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.hibernate.entities.Department" table="DEPARTMENT">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <set name="employees" table="EMPLOYEES" inverse="true" lazy="true">
            <key>
                <column name="DEPT_ID" />
            </key>
            <one-to-many class="com.hibernate.entities.Employee" />
        </set>
    </class>
</hibernate-mapping>

public class Employee {
    private Integer id;
    private String name;
    private float salary;
    private String email;
    private Department dept;

    public Employee() {
    }

    public Employee( String email, float salary,Department dept) {
        super();
        this.salary = salary;
        this.email = email;
        this.dept = dept;
    }
    //get/set...
}

Employee.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-4-4 15:42:11 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.hibernate.entities.Employee" table="EMPLOYEES">
        <!-- <cache usage="read-write"/> -->

        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="salary" type="float">
            <column name="SALARY" />
        </property>
        <property name="email" type="java.lang.String">
            <column name="EMAIL" />
        </property>
        <many-to-one name="dept" class="com.hibernate.entities.Department" fetch="join">
            <column name="DEPT_ID" />
        </many-to-one>
    </class>

    <query name="salaryEmps"><![CDATA[FROM Employee e WHERE e.salary > :minSalart AND e.salary < :maxSalary]]></query>
</hibernate-mapping>

ehcache.xml,这个文件是二级缓存的配置文件

<ehcache>


    <!-- 磁盘的存储路径，当ehcache需要把数据写到硬盘上，把数据写在这个目录 -->
    <diskStore path="E:\\ehcache"/>


    <!-- 默认的缓存策略 -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
    <!-- 自定义具体的命名缓存策略，每个命名缓存代表着一个缓存区域 
        name-设置缓存的名字，取值为全类名或者集合的名字
        maxInMemory-设计基于内存的缓存中可存放的对象的最大数目
        eternal-设置对象是否为永久的，true：永不过期，此时将忽略timeToIdleSeconds和timeToLiveSeconds属性 ，默认为false
        timeToIdleSeconds-设置对象最长的空闲时间，单位为秒
        timeToLiveSeconds-设置对象的最长的生存时间，如果为0，表示对象可以无限期的留在缓存中
        overflowToDisk-缓存中的对象达到上限后，是否把溢出的对象写到硬盘缓存中,session关闭的时候缓存会被清除
    -->
    <cache name="com.hibernate.entities.Employee"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <cache name="com.hibernate.entities.Department.employees"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->


</ehcache>

hibernate.cfg.xml

<?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="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate01</property>

        <!-- hibernate的基本信息 -->
        <!-- hibernate使用的数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 执行操作时是否在控制台打印sql语句 -->
        <property name="show_sql">true</property>
        <!-- 是否对sql进行格式化 -->
        <property name="format_sql">true</property>
        <!-- 指定自动生成数据表的策略 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 设置hibernate的隔离级别 -->
        <property name="connection.isolation">2</property>
        <!-- 删除对象后，设置其OID为null -->
        <property name="use_identifier_rollback">true</property>

        <!-- 配置C3P0数据源 -->
        <property name="c3p0.max_size">100</property>
        <property name="c3p0.min_size">5</property>
        <property name="c3p0.acquire_increment">2</property>
        <property name="c3p0.idle_test_period">2000</property>
        <property name="c3p0.timeout">2000</property>
        <property name="c3p0.max_statements">10</property>

        <!-- 设置JDBC的statement读取数据库的时候每次从数据库中读取记录条数，这个值100合适，太大会损耗内存，小了速度慢 -->
        <property name="jdbc.fetch_size">100</property>
        <!-- 设置数据库进行批量删除，更新，插入的时候批次的大小，30比较合适 -->
        <property name="jdbc.batch_size">30</property>

        <!-- 使用二级缓存 -->
        <property name="cache.use_second_level_cache">true</property>
        <!-- 二级缓存的配置 -->
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
        <!-- 配置使用查询缓存 -->
        <property name="cache.use_query_cache">true</property>

        <!-- 指定关联的hbm.xml文件 -->
        <mapping resource="com/hibernate/entities/Department.hbm.xml"/>     
        <mapping resource="com/hibernate/entities/Employee.hbm.xml"/>   

        <!-- 配置使用二级缓存的类 需放在mapping下面,也可以在类对应的.hbm.xml文件中配置-->
        <class-cache usage="read-write" class="com.hibernate.entities.Department"/> 
        <class-cache usage="read-write" class="com.hibernate.entities.Employee"/>
        <collection-cache usage="read-write" collection="com.hibernate.entities.Department.employees"/>



    </session-factory>
</hibernate-configuration>

三、测试代码

package com.hibernate.test;

import static org.junit.Assert.*;

import java.nio.channels.SeekableByteChannel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Conjunction;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Restrictions;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.hibernate.entities.Department;
import com.hibernate.entities.Employee;

import javassist.expr.NewArray;

public class HibernateTest {
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;

    @Test
    public void testSave() {
        List<Department> departments = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            Department department = new Department();
            department.setName("DEPT_" + ("A" + i));
            departments.add(department);

            Employee employee1 = new Employee();
            employee1.setName("EMP1_" + ("a" + i));
            employee1.setEmail("EMAIL1_" + ("a" + i));
            employee1.setSalary(1000 + i);
            employee1.setDept(departments.get(i));

            Employee employee2 = new Employee();
            employee2.setName("EMP2_" + ("b" + i));
            employee2.setEmail("EMAIL2_" + ("b" + i));
            employee2.setSalary(2000 + i);
            employee2.setDept(departments.get(i));

            department.getEmployees().add(employee1);
            department.getEmployees().add(employee2);

            employee1.setDept(department);
            employee2.setDept(department);

            session.save(department);
            session.save(employee1);
            session.save(employee2);
        }

    }

    /***
     * 二级缓存-集合级别
     */
    @Test
    public void testCollectionSecondLevelCache(){
        Department department1 = (Department) session.get(Department.class, 27);
        System.out.println(department1);
        System.out.println(department1.getEmployees().size());

        transaction.commit();
        session.close();

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();

        Department department2 = (Department) session.get(Department.class, 27);
        System.out.println(department2);
        System.out.println(department2.getEmployees().size());

    } 

    /***
     * 查询缓存
     */
    @Test
    public void testQueryCache(){
        Query query = session.createQuery("FROM Employee");
        query.setCacheable(true);//设置使用查询缓存，需要配置文件实现声明才有效

        List<Employee> employees = query.list();
        System.out.println(employees.size());

        employees = query.list();
        System.out.println(employees.size());

    }

    /***
     * 更新时间戳缓存
     */
    @Test
    public void testUpdateTimeStampCache(){
        Query query = session.createQuery("FROM Employee");
        query.setCacheable(true);//设置使用查询缓存，需要配置文件实现声明才有效

        List<Employee> employees = query.list();
        System.out.println(employees.size());

        Employee employee = (Employee) session.get(Employee.class, 59);
        employee.setSalary(30000f);

        employees = query.list();
        System.out.println(employees.size());
    }

    /***
     * 使用了查询二级缓存后，使用Iterate查询能稍微提高性能，不建议使用
     */
    @Test
    public void testQueryIterater(){
        Department department1 = (Department) session.get(Department.class, 27);
        System.out.println(department1);
        System.out.println(department1.getEmployees().size());

        Query query = session.createQuery("FROM Employee e WHERE e.dept.id = 27");
//      List<Employee> employees = query.list();
//      System.out.println(employees.size());

        Iterator<Employee> emps = query.iterate();
        while (emps.hasNext()) {
            System.out.println(emps.next().getName());
        }
    }

    @Before
    public void init() {
        System.out.println("HibernateTest.init()");

        // 1.创建一个sessionFactory对象
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                .buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);

        // 2.创建一个session对象
        session = sessionFactory.openSession();

        // 3.开启事务
        transaction = session.beginTransaction();

    }

    @After
    public void destroy() {
        // 5.提交事务
        transaction.commit();
        // 6.关闭session
        session.close();
        // 7.关闭SessionFactory
        sessionFactory.close();

    }

}