我正在使用Spring Data JPA和Hibernate处理应用程序,我正在尝试使用ehcache启用二级缓存。我将我的应用程序分成了两个项目:
CoreDataFacade的配置如下:
的pom.xml
<dependencies>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.7.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.6.Final</version>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<version>2.4.7</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<version>4.3.6.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.3.6.Final</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.33</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>com.mysema.querydsl</groupId>
<artifactId>querydsl-apt</artifactId>
<version>3.6.0</version>
</dependency>
<dependency>
<groupId>com.mysema.querydsl</groupId>
<artifactId>querydsl-jpa</artifactId>
<version>3.6.0</version>
</dependency>
应用context.xml中
<jpa:repositories
base-package="com.coredata.services.impl.sql.mysql.repositories" />
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close" p:driverClass="com.mysql.jdbc.Driver"
p:jdbcUrl="jdbc:mysql://localhost/FOO" p:user="****" p:password="****"
p:acquireIncrement="5" p:minPoolSize="10" p:maxPoolSize="100"
p:maxIdleTime="1200" p:unreturnedConnectionTimeout="120" />
<bean id="jpaVendorAdapter"
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
p:database="MYSQL" p:showSql="true" p:generateDdl="true" />
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
p:dataSource-ref="dataSource" p:jpaVendorAdapter-ref="jpaVendorAdapter"
p:packagesToScan="com.coredata.services.impl.sql.mysql.model">
<property name="jpaProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.cache.use_query_cache">true</prop>
<prop key="hibernate.cache.use_second_level_cache">true</prop>
<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
<prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory
</prop>
<prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop>
<prop key="hibernate.generate_statistics">true</prop>
</props>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager" />
实体缓存注释
@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY, region="cache_states")
@Table(name="states")
public class State implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="id_state")
private int idState;
...
ehcache.xml中
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
<defaultCache maxElementsInMemory="10000" eternal="false"
timeToIdleSeconds="120" timeToLiveSeconds="120"
overflowToDisk="false" diskPersistent="false" />
<cache name="cache_states" maxElementsInMemory="300" eternal="false"
timeToIdleSeconds="5000" timeToLiveSeconds="5000" overflowToDisk="false">
</cache>
</ehcache>
QueryComponent的配置导入上面的配置并排除JPA:
@Configuration
@PropertySource("classpath:/component.properties")
@ImportResource({ "classpath:/application-context.xml"})
@EnableAutoConfiguration(exclude = { JpaRepositoriesAutoConfiguration.class })
public class Application {
public void run(String... args) { }
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
当ComponentQuery启动时,一切正常。当我执行查询以查找数据库中的所有状态时,hibernate统计信息如下:
Hibernate: select count(state0_.id_state) as col_0_0_ from states state0_
Hibernate: select state0_.id_state as id_stat1_5_, state0_.name_state as name_e2_5_ from states state0_ limit ?
[2015-08-31 18:52:21.402] boot - 1946 INFO [SimpleAsyncTaskExecutor-1] --- StatisticalLoggingSessionEventListener: Session Metrics {
32992 nanoseconds spent acquiring 1 JDBC connections;
0 nanoseconds spent releasing 0 JDBC connections;
238285 nanoseconds spent preparing 2 JDBC statements;
935976 nanoseconds spent executing 2 JDBC statements;
0 nanoseconds spent executing 0 JDBC batches;
269717 nanoseconds spent performing 4 L2C puts;
0 nanoseconds spent performing 0 L2C hits;
0 nanoseconds spent performing 0 L2C misses;
0 nanoseconds spent executing 0 flushes (flushing a total of 0 entities and 0 collections);
68790 nanoseconds spent executing 2 partial-flushes (flushing a total of 0 entities and 0 collections)
}
当我重复相同的查询时,我得到了这个统计数据:
Hibernate: select count(state0_.id_state) as col_0_0_ from states state0_
Hibernate: select state0_.id_state as id_stat1_5_, state0_.name_state as name_e2_5_ from states state0_ limit ?
[2015-08-31 19:26:48.479] boot - 1946 INFO [SimpleAsyncTaskExecutor-1] --- StatisticalLoggingSessionEventListener: Session Metrics {
314930 nanoseconds spent acquiring 1 JDBC connections;
0 nanoseconds spent releasing 0 JDBC connections;
356832 nanoseconds spent preparing 2 JDBC statements;
681615 nanoseconds spent executing 2 JDBC statements;
0 nanoseconds spent executing 0 JDBC batches;
209324 nanoseconds spent performing 4 L2C puts;
0 nanoseconds spent performing 0 L2C hits;
0 nanoseconds spent performing 0 L2C misses;
0 nanoseconds spent executing 0 flushes (flushing a total of 0 entities and 0 collections);
12368 nanoseconds spent executing 2 partial-flushes (flushing a total of 0 entities and 0 collections)
}
似乎每个查询都在缓存中放置结果(数据库中有4个状态):
269717 nanoseconds spent performing 4 L2C puts;
209324 nanoseconds spent performing 4 L2C puts;
我希望第二个查询从缓存中检索数据,但统计命中和未命中为零:
0 nanoseconds spent performing 0 L2C hits;
0 nanoseconds spent performing 0 L2C misses;
我的问题是:当我执行第二次查询时,为什么L2C命中和L2C未命中为零?
更新
这就是我运行查询的方式
Reposiory
我正在使用带有弹簧数据jpa的QueryDSL。我按照这个tutorial使用QueryDslPredicateExecutor
集成了我的JpaRepositorypublic interface StateRepository extends JpaRepository<State, Integer>, QueryDslPredicateExecutor<State> {
}
服务
在我的服务中,我使用queryDLS谓词和PathBuilder执行我的查询,如这个伟大的article所示,这样,我可以通过任何字段找到状态或任何其他实体。例如,“StateName = Texas”,“StatePopulation = 26448193”。
@Autowired
StateRepository repo;
public List<State> getStatesByFields(String options, Integer page, Integer pageSize,String order) {
PredicateBuilder predicateBuilder = new PredicateBuilder().onEntity("State")
Pattern pattern = Pattern.compile(OPERATION_PATTERN);
Matcher matcher = pattern.matcher(options + ",");
while (matcher.find()) {
predicateBuilder.with(matcher.group(1), matcher.group(2), matcher.group(3));
}
PageRequest pag = new PageRequest(page, page_size)
BooleanExpression predicate = predicateBuilder.build();
//findAll is provided by QueryDslPredicateExecutor interface
Page<State> result = repo.findAll(predicate, pag);
}
查询像魅力一样运行,但数据似乎没有缓存。
答案 0 :(得分:6)
实体缓存仅在使用其id检索实体时才有效。 load(),get()。如果您使用查询它不起作用。
要启用缓存查询,您必须使用查询缓存。 e.g。
List blogs = sess.createQuery("from Blog blog where blog.blogger = :blogger")
.setEntity("blogger", blogger)
.setMaxResults(15)
.setCacheable(true)
.setCacheRegion("frontpages")
.list();
或使用jpa
query.setHint(“org.hibernate.cacheable”, true);
我不确定如何使用QueryDslPredicateExecutor
实现此功能,但希望这有助于理解hibernate 2nd lvl cache
L2C命中和L2C未命中等于零意味着hibernate永远不会从缓存中搜索数据,因为您使用查询检索记录而不启用查询缓存
L2C不是零,因为如果你通过id检索实体,hibernate会缓存稍后要使用的记录(这与缓存查询结果不同)
答案 1 :(得分:2)
您的缓存区域配置有拼写错误。在实体类中,您的配置(@Cache(usage = CacheConcurrencyStrategy.READ_ONLY, region =“cache_states”))指向的区域与ehcache.xml中定义的区域不同(cache name = “cache_estados”强>)
答案 2 :(得分:1)
试试这个
@CacheConfig(cacheNames = "com.abc.domain.State")
public interface StateRepository extends CrudRepository<State, Integer>, QueryDslPredicateExecutor<State> {
@QueryHints(value = {
@QueryHint(name = "org.hibernate.cacheable", value = "true"),
@QueryHint(name = "org.hibernate.cacheMode", value = "NORMAL"),
@QueryHint(name = "org.hibernate.cacheRegion", value = "CacheRegion")
})
Page<State> findAll(Predicate predicate, Pageable pageable);
}
它对我有用。
答案 3 :(得分:0)
这就是我们的情况。实际上,使用了Spring JPA和QueryDSL。另一方面,QueryDSL不会阻止也不会与缓存有任何关系。希望这个答案有所帮助。
以下是您需要解决的代码配置。
实体经理配置bean
@Configuration
@EnableJpaRepositories(
basePackages = { "com.abc.examples.persistence.repository" },
entityManagerFactoryRef = "entityManagerFactory",
transactionManagerRef = "transactionManager"
)
@ComponentScan("com.abc.examples.persistence")
public class PersistenceConfig {
/*Code omitted. Beans configured for other items like testDataSource, transactionManager*/
@Bean(name = "entityManagerFactory")
public LocalContainerEntityManagerFactoryBean localContainerEntityManagerFactoryBean(
@Qualifier("testDataSource") DataSource dataSource,
@Value("${hibernate.show_sql}") String hibernateShowSql,
@Value("${hibernate.generate_statistics}") String hibernateShowStats
) {
LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
factoryBean.setDataSource(dataSource);
factoryBean.setPackagesToScan("com.abc.examples.persistence.entity");
factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
factoryBean.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
Properties hibernateProperties = new Properties();
hibernateProperties.setProperty("hibernate.cache.provider_class", "org.hibernate.cache.SingletonEhCacheProvider");
hibernateProperties.setProperty("hibernate.cache.region.factory_class", "org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory");
hibernateProperties.setProperty("hibernate.cache.use_second_level_cache", "true");
hibernateProperties.setProperty("hibernate.cache.use_query_cache", "true");
factoryBean.setJpaProperties(hibernateProperties);
return factoryBean;
}
}
在上面的配置中要查找的重要的事情是
factoryBean.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
...
...
hibernateProperties.setProperty("hibernate.cache.provider_class", "org.hibernate.cache.SingletonEhCacheProvider");
hibernateProperties.setProperty("hibernate.cache.region.factory_class", "org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory");
hibernateProperties.setProperty("hibernate.cache.use_second_level_cache", "true");
hibernateProperties.setProperty("hibernate.cache.use_query_cache", "true");
缓存管理器配置bean(我们使用EhCache)
@Configuration
@EnableCaching
public class CacheConfig {
@Bean(name = "cacheManager")
public EhCacheCacheManager ehCacheCacheManager() {
return new EhCacheCacheManager(ehCache());
}
@Bean
public CacheManager ehCache() {
CacheManager cacheManager = CacheManager.create();
Cache sampleEntityCache = new Cache(
new CacheConfiguration("com.abc.examples.entity.SampleEntity", 500)
.memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LRU)
.eternal(false)
.timeToLiveSeconds(60 * 60 * 24)
.timeToIdleSeconds(60 * 60 * 24)
.persistence(new PersistenceConfiguration().strategy(PersistenceConfiguration.Strategy.NONE))
);
cacheManager.addCache(sampleEntityCache);
return cacheManager;
}
}
实体类
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
@Cache(usage= CacheConcurrencyStrategy.READ_ONLY,
region="com.abc.examples.entity.SampleEntity") //This name should match with the name used in the CacheConfiguration above.
public class SampleEntity{
@Id
...
...
..
}