9.Spring + Hibernate + ehcache（二级缓存

一.Spring环境中配置Hibernate 和 ehcache

导入Hibernatejar：

其中ehcache-1.2.3.jar就是配置ehcache缓存需要的jar文件。

修改beans.xml文件： 

<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <!-- 配置自动扫描bean 包含注解 -->
    <context:component-scan base-package="com.zyy.service"/>


    <!-- 配置AOP -->
    <aop:aspectj-autoproxy/>


    <!-- 配置资源文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="${dataSource}" destroy-method="close">
        <property name="driverClassName" value="${driverClassName}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="${initialSize}"/>
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="${maxActive}"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="${maxIdle}"/>
        <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="${minIdle}"/>
    </bean>


    <!-- 配置Hibernate二级缓存 -->
    <!--由Spring提供的LocalSessionFactoryBean管理Hibernate中SessionFactory中的session-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mappingResources">
            <list>
                <value>com/zyy/bean/Person.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQLDialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false

                <!-- 配置hibernate二级缓存 -->
                hibernate.cache.use_second_level_cache=true
                <!-- 不配置查询缓存 -->
                hibernate.cache.use_query_cache=false
                <!-- 配置缓存，这里配置的是EhCache缓存 -->
                hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider

            </value>
        </property>
    </bean>

    <!-- 配置事务 -->
    <!-- 这里使用Spring的bean和Spring对Hibernate支持的HibernateTransactionManager -->
    <!-- 属性注入的是Hibernate的二级缓存 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!-- 事务注解 -->
    <tx:annotation-driven transaction-manager="txManager"/>


</beans>

这里是将JDBC的数据源 传入给Spring对Hibernate支持的HibernateTransactionManager

 从而实现Spring中的Hibernate环境。

beans.xml需要的 jdbc.properties：

dataSource = org.apache.commons.dbcp.BasicDataSource

driverClassName = org.gjt.mm.mysql.Driver

url = jdbc:mysql://localhost:3306/ceshi_1?useUnicode=true&characterEncoding=UTF-8

username = root

password = root

initialSize = 1

maxActive = 500

maxIdle = 2

minIdle = 1

在类路径（src）下添加一个 ehcache.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
     diskStore指定缓存文件保存的路径
     defaultCache节点为缺省的缓存策略
     maxElementsInMemory 内存中最大允许存在的对象数量
     eternal 设置缓存中的对象是否永远不过期
     overflowToDisk 把溢出的对象存放到硬盘上
     timeToIdleSeconds 指定缓存对象空闲多长时间就过期,过期的对象会被清除掉
     timeToLiveSeconds 指定缓存对象总的存活时间
     diskPersistent 当jvm结束是是否持久化对象
     diskExpiryThreadIntervalSeconds 指定专门用于清除过期对象的监听线程的轮询时间
 -->
<ehcache>
    <diskStore path="D:\cache"/>
    <defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"
                  timeToIdleSeconds="120"
                  timeToLiveSeconds="180"
                  diskPersistent="false"
                  diskExpiryThreadIntervalSeconds="60"/>

    <!-- 设置缓存的区域（可以多个），指定哪个表需要缓存 -->
    <cache name="com.zyy.service.Person" maxElementsInMemory="100" eternal="false"
           overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/>
</ehcache>

这时候 beans.xml 和 ehcache.xml 都需要一个 Hibernate表 和 其的配置 ：

package com.zyy.bean;


public class Person {

    private Integer id;

    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zyy.bean">

    <class name="com.zyy.bean.Person">

    <!-- usage说明了缓存的策略，region指定缓存的区域名 -->
    <cache usage="read-write" region="com.zyy.service.Person"/>

        <id name="id">
            <generator class="native"/>
        </id>

        <property name="name"/>

    </class>

</hibernate-mapping>

由于导入的包中有log4j.jar，所以要在类路径（src）下添加一个 log4j.properties ：

log4j.rootLogger=WARN, Console

log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=(%r ms) [%t] %-5p: %c#%M %x: %m%n

log4j.logger.com.genuitec.eclipse.sqlexplorer=DEBUG
log4j.logger.org.apache=WARN
log4j.logger.org.hibernate=WARN

以上，环境搭建结束。

二.测试环境

package com.zyy.service;

import com.zyy.bean.Person;

import java.util.List;

/**
 * Created by CaMnter on 2014/8/20.
 */
public interface PersonService {

    /**
     * 保存对象
     *
     * @param peroson
     */
    public void save(Person peroson);

    /**
     * 更新对象
     *
     * @param peroson
     */
    public void update(Person peroson);

    /**
     * 删除单个对象
     *
     * @param personId
     */
    public void delete(Integer personId);

    /**
     * 取得单个对象
     *
     * @return
     */
    public Person getPerson(Integer personId);

    /**
     * 取得全部对象
     *
     * @return
     */
    public List<Person> getPersons();


}

package com.zyy.service.impl;

import com.zyy.bean.Person;
import com.zyy.service.PersonService;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;




@Service("personService")
@Transactional
public class PersonServiceBean implements PersonService {

    /**
     * 这里的sessionFactory 配置的class
     *
     * 配置的class是org.springframework.orm.hibernate3.LocalSessionFactoryBean
     *
     * 由Spring提供的LocalSessionFactoryBean管理Hibernate中SessionFactory中的session
     */
    //将Autowired转换为按 名称匹配
    @Autowired
    @Qualifier("sessionFactory")
    private SessionFactory sessionFactory;

    public void save(Person peroson) {

        /**
         *  this.sessionFactory.getCurrentSession() 得到当前的session
         *
         *  persist()保存实体 和 save()一样
         */
        this.sessionFactory.getCurrentSession().persist(peroson);

    }

    public void update(Person peroson) {

        /**
         *  this.sessionFactory.getCurrentSession() 得到当前的session
         *
         *  merge() 和 update()方法一样
         */
        this.sessionFactory.getCurrentSession().merge(peroson);

    }

    public void delete(Integer personId) {

        /**
         *  this.sessionFactory.getCurrentSession() 得到当前的session
         *
         *  通过load(表.class, personId)方法 读取 Person
         *
         *  然后再用Person  执行delete(Object)方法
         */
        this.sessionFactory.getCurrentSession().delete(
                this.sessionFactory.getCurrentSession().load(Person.class, personId));
    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public Person getPerson(Integer personId) {

        /**
         *  this.sessionFactory.getCurrentSession() 得到当前的session
         *
         *  通过load(表.class, personId)方法 读取 Person
         *
         *  然后再用Person  执行get(Object)方法
         */
        return (Person) this.sessionFactory.getCurrentSession().get(Person.class, personId);

    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<Person> getPersons() {

        //from 类名   不是from 数据库里的表名
        //noinspection JpaQlInspection
        String hql = "from Person" ;

        /**
         * 这里比 Spring+JDBC 返回一组list数据方便多了
         */
        return this.sessionFactory.getCurrentSession().createQuery(hql).list();


    }
}

junit4.4测试类：

package test.com.zyy.service.impl;

import com.zyy.bean.Person;
import com.zyy.service.PersonService;
import org.junit.Test;
import org.junit.Before;
import org.junit.After;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * PersonServiceBean Tester.
 *
 * @author <Authors name>
 * @version 1.0
 */
public class PersonServiceBeanTest {


    private PersonService personService;

    @Before
    public void before() throws Exception {


        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");

        this.personService = (PersonService) applicationContext.getBean("personService");


    }

    @After
    public void after() throws Exception {
    }

    /**
     * Method: save(Person peroson)
     */
    @Test
    public void testSave() throws Exception {

        this.personService.save(new Person("CaMnter_SSH_save"));

        for (int i = 0; i < 15; i++) {

            this.personService.save(new Person("CaMnter_SSH_save_" + i));

        }


    }

    /**
     * Method: update(Person peroson)
     */
    @Test
    public void testUpdate() throws Exception {

        Person person = new Person("CaMnter_SSH_update");

        person.setId(4);

        this.personService.update(person);

    }

    /**
     * Method: delete(Integer personId)
     */
    @Test
    public void testDelete() throws Exception {

        this.personService.delete(6);

    }

    /**
     * Method: getPerson(Integer personId)
     */
    @Test
    public void testGetPerson() throws Exception {

        Person person = this.personService.getPerson(7);

        System.out.println("id: " + person.getId() + "    name: " + person.getName());

    }

    /**
     * Method: getPersons()
     */
    @Test
    public void testGetPersons() throws Exception {

        for (Person person : this.personService.getPersons()) {
            System.out.println("id: " + person.getId() + "    name: " + person.getName());
        }


    }

    @Test
    public void testCache() {

        Person person = this.personService.getPerson(7);

        System.out.println("id: " + person.getId() + "    name: " + person.getName());

        try {
            Thread.sleep(1000 * 7);

            System.out.println("请关闭Mysql数据库");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("第二次获取");

        person = this.personService.getPerson(7);

        System.out.println("id: " + person.getId() + "    name: " + person.getName());


    }


} 

这里，我就附上一个测试取得全部person的的结果：

注意：测试cache的时候，点击执行testCach()单元方法后，会立刻看到一条数据输出，然

后睡眠了七秒，再读取。如果在睡眠的七秒内，关闭了数据库，后还能再读取，证明cache配置

成功；如果有异常则配置失败。

可以发现D:/cache文件夹下有内容：