`

JPA二级缓存通过Ehcache的实现

 
阅读更多
一级缓存是Session级别的缓存,在Session关闭时,一级缓存就会失效。

第二级缓存是一个可插拔的的缓存插件,它是由SessionFactory负责管理。由于SessionFactory对象的生命周期和应用程序的整个过程对应,因此第二级缓存是进程范围或者集群范围的缓存。这个缓存中存放的对象的松散数据。第二级对象有可能出现并发问题,因此需要采用适当的并发访问策略,该策略为被缓存的数据提供了事务隔离级别。缓存适配器用于把具体的缓存实现软件与Hibernate集成。第二级缓存是可选的,可以在每个类或每个集合的粒度上配置第二级缓存,如EhCache 、JBossCache、OsCache等。


二级缓存应用场景如下:

1)很少被修改的数据

2)不是很重要的数据,允许出现偶尔并发的数据

3)不会被并发访问的数据

4)参考数据

配置Ehcache:

1. persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="project" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <properties>
             <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/project?autoReconnect=true&amp;useUnicode=true&amp;characterEncoding=UTF-8" />
            <property name="hibernate.connection.username" value="root" />
            <property name="hibernate.connection.password" value="password" />
            <property name="hibernate.c3p0.max_size" value="200" />
            <property name="hibernate.c3p0.min_size" value="2" />
            <property name="hibernate.c3p0.max_statements" value="100" />
            <property name="hibernate.c3p0.acquire_increment" value="1" />
            <property name="hibernate.c3p0.validate" value="true" />
            <property name="hibernate.c3p0.testConnectionOnCheckout" value="true" />  
             <property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory" />
            <property name="hibernate.cache.provider_configuration" value="/ehcache.xml" />           
            <property name="hibernate.generate_statistics" value="true" /> 
            <property name="hibernate.cache.use_second_level_cache" value="true" />
            <property name="hibernate.cache.use_query_cache" value="true" />
            <property name="hibernate.show_sql" value="true" />
        </properties>
    </persistence-unit>
</persistence>

2. ehcache.xml和properties文件一起放在resource目录下(src/main/resources)

<!-- 
        name:cache唯一标识  
        eternal:缓存是否永久有效  
        maxElementsInMemory:内存中最大缓存对象数 
        overflowToDisk(true,false):缓存对象达到最大数后,将缓存写到硬盘中 
        diskPersistent:硬盘持久化 
        timeToIdleSeconds:缓存清除时间  
        timeToLiveSeconds:缓存存活时间 
        memoryStoreEvictionPolicy:缓存清空策略 
        1.FIFO:first in first out 先讲先出 
        2.LFU: Less Frequently Used 一直以来最少被使用的 
        3.LRU:Least Recently Used  最近最少使用的 
--> 
<?xml version="1.0" encoding="UTF-8" ?>
<ehcache xmlns:xsi="w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="false" monitoring="autodetect" dynamicConfig="true">
    <diskStore path="C:/Temp/ehcache/"/>
   
    <defaultCache maxElementsInMemory="100" eternal="false"
           timeToIdleSeconds="1200" timeToLiveSeconds="1200" overflowToDisk="true" clearOnFlush="true">
    </defaultCache>
   
    <cache name="org.test.persistent.entity.Scenario"
           maxElementsInMemory="100"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="3600"
           overflowToDisk="true">
    </cache>
    <cache name="org.test.persistent.entity.ProjectTree"
           maxElementsInMemory="100"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="3600"
           overflowToDisk="true">
    </cache>
    <cache name="org.hibernate.cache.spi.UpdateTimestampsCache"
        maxElementsInMemory="100"
        timeToIdleSeconds="1800"
        timeToLiveSeconds="3600"
        eternal="false"
        overflowToDisk="true">
    </cache>
</ehcache>

3. 实体类:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.SequenceGenerator;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import javax.persistence.Cacheable;

@Entity
@Table(name = "scenario", schema = "projecttable")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE, region="org.test.persistent.entity.Scenario")
public class Scenario implements Serializable
{
。。。。
}


4. 数据查询

public List<Scenario> searchScenariobyParent(Integer parentId)
    {
        EntityManager em = ProjectDBFactory.getInstance().getEntityManager();
        try {
            TypedQuery<Scenario> query = em.createQuery(
                    "from Scenario as s where s.obsolete!=1 and s.parentId=? order by s.name, s.scenarioStatusId",
                    Scenario.class);
            query.setParameter(1, parentId);
            query.setHint("org.hibernate.cacheable", true);
            if (query instanceof org.hibernate.ejb.QueryImpl) {
                ((org.hibernate.ejb.QueryImpl)query).getHibernateQuery().setCacheable(true);
            }
            List<Scenario> scenarios = query.getResultList();     
           
            EntityManagerImpl empImpl = (EntityManagerImpl)em;
            System.out.println(empImpl.getSession().getStatistics());
                   System.out.println(empImpl.getSession().getSessionFactory().getStatistics());

            return scenarios;
        } finally {
            em.close();
        }
    }

5. pom.xml

<!-- jpa begin -->
<properties>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <javawebapi.version>7.0</javawebapi.version>
        <hibernate.version>4.2.3.Final</hibernate.version>
        <mysql-connector-java.version>5.1.25</mysql-connector-java.version>
        <junit.version>4.11</junit.version>
        <log4j.version>1.2.16</log4j.version>
        <slf4j.version>1.4.3</slf4j.version>
        <project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
        <parameters.section>development</parameters.section>
        <timestamp>${maven.build.timestamp}</timestamp>
        <maven.build.timestamp.format>dd MMMM yyyy HH:mm z</maven.build.timestamp.format>
     </properties>
<dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.10.1</version>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector-java.version}</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.3.162</version>
        </dependency>
        <dependency>
            <groupId>javax.transaction</groupId>
            <artifactId>jta</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.1</version>
        </dependency>
        <!-- jpa end -->
        <!-- Logging begin -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
        </dependency>
        <!-- Logging end -->

6. 缓存方式:

缓存 CacheConcurrencyStrategy 方式有五种缓存方式:
1) CacheConcurrencyStrategy.NONE,不适用,默认
2) CacheConcurrencyStrategy.READ_ONLY ,只读模式,在此模式下,如果对数据进行更新操作,会有异常;
3) CacheConcurrencyStrategy.READ_WRITE ,读写模式在更新缓存的时候会把缓存里面的数据换成一个锁,其它事务如果去取相应的缓存数据,发现被锁了,直接就去数据库查询;
4) CacheConcurrencyStrategy.NONSTRICT_READ_WRITE ,不严格的读写模式则不会的缓存数据加锁;
5) CacheConcurrencyStrategy.TRANSACTIONAL ,事务模式指缓存支持事务,当事务回滚时,缓存也能回滚,只支持 JTA 环境。


参考:
http://blog.csdn.net/zwan0518/article/details/8672245
http://www.360doc.com/content/13/0411/15/2569758_277586886.shtml
http://tuhaitao.iteye.com/blog/568653
http://blog.csdn.net/tjcyjd/article/details/10922577
http://www.yoodb.com/article/display/1071
http://www.oschina.net/question/54100_31552?fromerr=F8GYw9oa
http://acupof.blogspot.jp/2008/01/background-hibernate-comes-with-three.html#!/2008/01/background-hibernate-comes-with-three.html
http://cxl2012.iteye.com/blog/1944489
http://wenku.baidu.com/view/86fb9f2f0066f5335a812126.html
http://www.xlgps.com/article/401738.html
http://www.ehcache.org/generated/2.9.0/pdf/Integrations.pdf  Ehcache集成各种环境
分享到:
评论

相关推荐

    spring + ehcache + redis两级缓存

    当我们谈论“Spring + Ehcache + Redis”两级缓存时,我们实际上是在讨论如何在Java环境中利用Spring框架来集成Ehcache作为本地缓存,并利用Redis作为分布式二级缓存,构建一个高效且可扩展的缓存解决方案。...

    springboot+jpa(hibernate配置redis为二级缓存) springboot2.1.4

    在本文中,我们将深入探讨如何在Spring Boot 2.1.4.RELEASE项目中结合JPA(Java Persistence API)和Hibernate实现Redis作为二级缓存。首先,我们需要理解这些技术的基本概念。 Spring Boot 是一个用于简化Spring...

    springmvc4+spring4+hibernate5.1.3+二级缓存ehcache+fastjson配置

    在本配置中,Hibernate版本为5.1.3,支持JPA规范,提供了二级缓存功能,提高了数据访问性能。 4. **二级缓存(Ehcache)**: Ehcache是Hibernate的一个可选二级缓存插件,用于存储数据库查询结果,减少对数据库的...

    spring-boot-starter-data-jpa 的二级缓存

    总之,Spring Boot通过starter-data-jpa模块和Hibernate、Ehcache整合,为我们提供了一个强大的工具集,可以有效地实现二级缓存机制,优化应用性能,减少数据库压力。开发者需要掌握这些知识点,以确保在实际的项目...

    JPA-5 使用二级缓存

    1. **选择缓存提供商**:JPA本身并不提供二级缓存实现,而是依赖于供应商,如Hibernate、EclipseLink等。以Hibernate为例,我们可以选择Hibernate的内置缓存,如Infinispan或 Ehcache。 2. **配置缓存**:在...

    Hibernate二级缓存+分页功能

    Hibernate二级缓存通过插件实现,其中Ehcache是最常用的二级缓存实现。 二级缓存的配置主要包括以下步骤: 1. 引入Ehcache依赖。 2. 配置hibernate.cfg.xml,启用二级缓存并指定Ehcache配置文件。 3. 在实体类上...

    Spring Boot的EhCache缓存使用.docx

    在Spring Boot应用中,缓存是提升性能的关键技术之一。默认情况下,Spring Boot的`@EnableCaching`注解...同时,EhCache还支持与其他缓存相关的特性,如二级缓存、分布式缓存等,可以进一步提高系统的性能和可扩展性。

    Hibernate二级缓存的应用

    1. 添加二级缓存库,如本例中的`ehcache-core-2.4.3.jar`,这是Hibernate常用的一种二级缓存实现。 2. 在`pom.xml`或`build.gradle`中引入依赖。 3. 配置`hibernate.cfg.xml`,指定使用二级缓存插件,并设置缓存策略...

    Hibernate二级缓存实例.rar

    在Java世界中,Hibernate是一个...在实现二级缓存时,我们需要配置Hibernate的缓存提供者,如EhCache或Infinispan。以EhCache为例,我们需要在hibernate.cfg.xml配置文件中添加对应的provider和cache配置: ```xml ...

    基于Spring+JPA+Velocity+Ehcache的商城系统源码.zip

    通过JPA,可以轻松实现数据的增删改查操作,同时支持事务管理和懒加载等特性。 **Hibernate作为JPA实现**: 虽然JPA是标准接口,但在实际项目中,通常会选用一个具体的JPA实现,如Hibernate。Hibernate是流行的ORM...

    详解spring boot集成ehcache 2.x 用于hibernate二级缓存

    "Spring Boot 集成 Ehcache 2.x 用于 Hibernate 二级缓存" 本篇文章主要介绍了如何在 Spring Boot 中集成 Ehcache 2.x 作为 Hibernate 的二级缓存,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。 Ehcache ...

    ehcache

    在 Hibernate 中,Ehcache 可以作为二级缓存提供服务,将查询结果存储在缓存中,避免重复查询数据库。只需在 Hibernate 配置文件中指定 Ehcache 作为二级缓存提供者即可。 ## 5. Ehcache 的分布式缓存 Ehcache ...

    ehcache官方教程

    1. **二级缓存**:介绍了如何将 Ehcache 作为 Hibernate 的二级缓存使用。 2. **配置集成**:提供了 Hibernate 和 Ehcache 集成的具体步骤和配置示例。 #### 十七、Web 缓存(Web Caching) 探讨了如何在 Web 应用...

    Hibernate4 + Ehcache 例子

    3. **集成Ehcache与Hibernate**:在Hibernate中配置Ehcache作为二级缓存,可以将频繁查询的数据保存在内存中,避免重复的数据库调用。这涉及到修改Hibernate配置文件(如`hibernate.cfg.xml`),添加Ehcache的相关...

    maven整合ssh框架、ehcache搭建、可直接运行导入运行

    5. **集成Ehcache**:在Hibernate的配置中,设置二级缓存为Ehcache。Ehcache可以在数据库查询后将结果缓存起来,下次相同的查询就可以直接从内存中获取,避免了数据库的重复访问。Ehcache.xml中需要配置缓存的大小、...

    Spring boot hibernate ehcache maven 整合源码

    在Spring Boot应用中,它可以作为二级缓存,提高数据读取速度。通过在`pom.xml`中引入Ehcache的依赖,并在配置文件中进行相应设置,我们可以指定哪些数据需要被缓存,以及缓存策略。Ehcache的使用降低了数据库的负载...

    spring hibernate cache

    Spring Cache 是 Spring 为整个应用提供的缓存抽象层,它支持多种缓存实现,包括 EhCache 和 Hibernate 的二级缓存。通过在方法上添加 @Cacheable、@CacheEvict 等注解,可以在方法调用前后自动完成缓存的存取和清理...

    Spring3.2_Hibernate4.2_JPA2全注解实例

    Ehcache 是一个广泛使用的Java缓存解决方案,它可以作为Hibernate的二级缓存,提高数据读取效率。二级缓存允许频繁访问的数据在内存中被缓存,减少了对数据库的直接访问,从而提升了应用程序的性能。 最后,"jpaweb...

    Spring Data JPA

    - **缓存机制**:可以与二级缓存提供商(如Hibernate的EHCache或Infinispan)结合,提高数据读取性能。 - **多数据源支持**:Spring Data JPA可以配置多个数据源,实现数据的分库分表。 **5. 学习资源** - 黑马...

    Spring 整合 Hibernate 时启用二级缓存实例详解

    2. **EhCache**:EhCache是Hibernate推荐的二级缓存提供者之一,它是一个用Java实现的简单、快速、轻量级的缓存工具。 接下来,文档按照步骤详解了二级缓存的配置方法: - **引入依赖包**:首先需要在项目中引入...

Global site tag (gtag.js) - Google Analytics