`
jsczxy2
  • 浏览: 1275304 次
  • 性别: Icon_minigender_1
  • 来自: 常州
文章分类
社区版块
存档分类
最新评论

spring中使用查询缓存

spring 
阅读更多

由于使用的是spring3所以一下配置都基于spring3.

 

先来看spring没有默认设置查询缓存的设置,spring的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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/aop 
 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
 http://www.springframework.org/schema/tx 
 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
 http://www.directwebremoting.org/schema/spring-dwr
 http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context-3.0.xsd" default-autowire="byName">
 
 	<context:property-placeholder location="classpath*:database.properties,classpath*:memcached.properties" />
 	
 	<!-- spring注释自动注入 -->
 	<context:annotation-config/>
 	
	<context:component-scan base-package="com.myweb" />
	
	<!--jbpm4.4工作流  -->
	<bean id="springHelper" class="org.jbpm.pvm.internal.processengine.SpringHelper"/>
	<bean id="processEngine" factory-bean="springHelper"  factory-method="createProcessEngine" />
	
	<!-- dataSourceproxy 配置代理管理事务 -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy"
		p:targetDataSource-ref="dynamicDataSource" />
	
	<!-- dataSource 多数据源支持 -->
	<bean id="dynamicDataSource" class="com.myweb.support.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<entry key="dataSource" value-ref="dataSourceJDBC" />
			</map>
		</property>
	</bean>
	
	<!-- c3p0数据源配置 -->
	<bean id="dataSourceJDBC" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close" p:driverClass="${jdbc.driverClass}" p:jdbcUrl="${jdbc.jdbcUrl}"
		p:user="${jdbc.user}" p:password="${jdbc.password}" p:initialPoolSize="${c3p0.initialPoolSize}"
		p:minPoolSize="${c3p0.minPoolSize}" p:maxPoolSize="${c3p0.maxPoolSize}"
		p:acquireIncrement="${c3p0.acquireIncrement}" p:maxIdleTime="${c3p0.maxIdleTime}"
		p:maxStatements="${c3p0.maxStatements}" lazy-init="true" />
	

	<!-- hibernate-spring 基本配置 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="hibernateProperties">
			<props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
				<prop key="hibernate.jdbc.fetch_size">50</prop>
				<prop key="hibernate.jdbc.batch_size">25</prop>
				<prop key="hibernate.cache.use_query_cache">true</prop>
				<prop key="hibernate.cache.use_second_level_cache">true</prop>
				<prop key="hibernate.max_fetch_depth">1</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.cache.provider_class">com.googlecode.hibernate.memcached.MemcachedCacheProvider</prop>
				<prop key="hibernate.memcached.servers">${memcached.object.servers}</prop>
				<prop key="hibernate.memcached.cacheTimeSeconds">86400</prop>
				<prop key="hibernate.memcached.clearSupported">false</prop>
				<prop key="hibernate.connection.release_mode">after_transaction</prop>
            </props>
		</property>
		<property name="mappingLocations">
			<list>
				<value>classpath*:com/myweb/modal/hibernate/*.hbm.xml</value>
				<value>classpath*:jbpm.repository.hbm.xml</value>
				<value>classpath*:jbpm.execution.hbm.xml</value>
				<value>classpath*:jbpm.history.hbm.xml</value>
				<value>classpath*:jbpm.task.hbm.xml</value>
				<value>classpath*:jbpm.identity.hbm.xml</value>
			</list>
		</property>
		<!-- 使用TransactionAwareDataSourceProxy管理事务与ibatis处于同一事务管理下 -->
		<property name="useTransactionAwareDataSource" value="true"></property>
	</bean>
	
	
	<!-- mybatis-spring 配置 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:mybatis-config.xml" />
		<property name="mapperLocations" value="classpath*:com/myweb/ibatis/mapper/*.xml"/>
	</bean>
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.myweb.dao.ibatis" />
	</bean>

		<!-- spring transaction 事务管理 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>


	<tx:advice id="txManager" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
			<tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:advisor id="txAdvisor" advice-ref="txManager" pointcut="execution(* com.myweb.*service..*(..))" order="0" />
	</aop:config>
	
	
	<!-- memcache-java -->
	<bean id="objectCache" class="com.myweb.service.ObjectCache">
		<property name="memCachedClient">
			<props>
				<prop key="memcached.servers">${memcached.object.servers}</prop>
				<prop key="memcached.weights">${memcached.object.weights}</prop>
				<prop key="memcached.failover">${memcached.failover}</prop>
				<prop key="memcached.initConn">${memcached.initConn}</prop>
				<prop key="memcached.minConn">${memcached.minConn}</prop>
				<prop key="memcached.maxConn">${memcached.maxConn}</prop>
				<prop key="memcached.maintSleep">${memcached.maintSleep}</prop>
				<prop key="memcached.nagle">${memcached.nagle}</prop>
				<prop key="memcached.socketTO">${memcached.socketTO}</prop>
				<prop key="memcached.aliveCheck">${memcached.aliveCheck}</prop>
			</props>
		</property>
	</bean>
</beans>

 

 主要的BaseHDao配置如下:

 

package com.myweb.dao.hibernate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

/**
 * @author jsczxy2
 *
 */
@Repository
public class BaseHDao extends HibernateDaoSupport {
	
	Log log = LogFactory.getLog(getClass());
	
	@Autowired
	private SessionFactory sessionFactory;

}

 

 

再来看spring默认设置查询缓存，其实差异就在hibernateTemplate和hibernateTemplate里的cacheQueries设置为true!

 

<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/aop 
 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
 http://www.springframework.org/schema/tx 
 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
 http://www.directwebremoting.org/schema/spring-dwr
 http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context-3.0.xsd" default-autowire="byName">
 
 	<context:property-placeholder location="classpath*:database.properties,classpath*:memcached.properties" />
 	
 	<!-- spring注释自动注入 -->
 	<context:annotation-config/>
 	
	<context:component-scan base-package="com.myweb" />
	
	<!--jbpm4.4工作流  -->
	<bean id="springHelper" class="org.jbpm.pvm.internal.processengine.SpringHelper"/>
	<bean id="processEngine" factory-bean="springHelper"  factory-method="createProcessEngine" />
	
	<!-- dataSourceproxy 配置代理管理事务 -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy"
		p:targetDataSource-ref="dynamicDataSource" />
	
	<!-- dataSource 多数据源支持 -->
	<bean id="dynamicDataSource" class="com.myweb.support.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<entry key="dataSource" value-ref="dataSourceJDBC" />
			</map>
		</property>
	</bean>
	
	<!-- c3p0数据源配置 -->
	<bean id="dataSourceJDBC" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close" p:driverClass="${jdbc.driverClass}" p:jdbcUrl="${jdbc.jdbcUrl}"
		p:user="${jdbc.user}" p:password="${jdbc.password}" p:initialPoolSize="${c3p0.initialPoolSize}"
		p:minPoolSize="${c3p0.minPoolSize}" p:maxPoolSize="${c3p0.maxPoolSize}"
		p:acquireIncrement="${c3p0.acquireIncrement}" p:maxIdleTime="${c3p0.maxIdleTime}"
		p:maxStatements="${c3p0.maxStatements}" lazy-init="true" />
	

	<!-- hibernate-spring 基本配置 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="hibernateProperties">
			<props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
				<prop key="hibernate.jdbc.fetch_size">50</prop>
				<prop key="hibernate.jdbc.batch_size">25</prop>
				<prop key="hibernate.cache.use_query_cache">true</prop>
				<prop key="hibernate.cache.use_second_level_cache">true</prop>
				<prop key="hibernate.max_fetch_depth">1</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.cache.provider_class">com.googlecode.hibernate.memcached.MemcachedCacheProvider</prop>
				<prop key="hibernate.memcached.servers">${memcached.object.servers}</prop>
				<prop key="hibernate.memcached.cacheTimeSeconds">86400</prop>
				<prop key="hibernate.memcached.clearSupported">false</prop>
				<prop key="hibernate.connection.release_mode">after_transaction</prop>
            </props>
		</property>
		<property name="mappingLocations">
			<list>
				<value>classpath*:com/myweb/modal/hibernate/*.hbm.xml</value>
				<value>classpath*:jbpm.repository.hbm.xml</value>
				<value>classpath*:jbpm.execution.hbm.xml</value>
				<value>classpath*:jbpm.history.hbm.xml</value>
				<value>classpath*:jbpm.task.hbm.xml</value>
				<value>classpath*:jbpm.identity.hbm.xml</value>
			</list>
		</property>
		<!-- 使用TransactionAwareDataSourceProxy管理事务与ibatis处于同一事务管理下 -->
		<property name="useTransactionAwareDataSource" value="true"></property>
	</bean>
	
	<!-- hibernateTemplate 并使用查询缓存设置-->
	<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
       <property name="sessionFactory"><ref bean="sessionFactory"/></property>
       <property name="cacheQueries" value="true"></property>
	</bean>
	
	<!-- mybatis-spring 配置 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:mybatis-config.xml" />
		<property name="mapperLocations" value="classpath*:com/myweb/ibatis/mapper/*.xml"/>
	</bean>
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.myweb.dao.ibatis" />
	</bean>

		<!-- spring transaction 事务管理 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>


	<tx:advice id="txManager" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
			<tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:advisor id="txAdvisor" advice-ref="txManager" pointcut="execution(* com.myweb.*service..*(..))" order="0" />
	</aop:config>
	
	
	<!-- memcache-java -->
	<bean id="objectCache" class="com.myweb.service.ObjectCache">
		<property name="memCachedClient">
			<props>
				<prop key="memcached.servers">${memcached.object.servers}</prop>
				<prop key="memcached.weights">${memcached.object.weights}</prop>
				<prop key="memcached.failover">${memcached.failover}</prop>
				<prop key="memcached.initConn">${memcached.initConn}</prop>
				<prop key="memcached.minConn">${memcached.minConn}</prop>
				<prop key="memcached.maxConn">${memcached.maxConn}</prop>
				<prop key="memcached.maintSleep">${memcached.maintSleep}</prop>
				<prop key="memcached.nagle">${memcached.nagle}</prop>
				<prop key="memcached.socketTO">${memcached.socketTO}</prop>
				<prop key="memcached.aliveCheck">${memcached.aliveCheck}</prop>
			</props>
		</property>
	</bean>
</beans>

 package com.myweb.dao.hibernate;

 

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

/**
 * @author jsczxy2
 *
 */
@Repository
public class BaseHDao extends HibernateDaoSupport {
	
	Log log = LogFactory.getLog(getClass());
	
	@Autowired
	private HibernateTemplate hibernateTemplate;

}

 这样可以看出使用spring的HibernateTemplate 来设置cacheQueries为true就是设置spring默认打开查询缓存。查询缓存会缓存查询语句的结果，其生命周期是到相关映射实体对象有变动为止，一旦有变动则会重新查询后缓存。

分享到：
| 关于数组转换List后remove失败的问题
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring简单的缓存

    当方法被调用时，其结果会被存储在指定的缓存中，下次调用时，如果缓存中有该结果，将直接返回，不再执行方法体。 - `@CacheEvict`：用于清除缓存中的数据。可以在方法执行前后，或者根据方法的返回值或异常情况...

    spring-cache（通过key值更新缓存）

    在Spring框架中，缓存是提高应用程序性能的重要手段。Spring Cache是一个抽象层，它允许开发者在不关注具体缓存实现的情况下，轻松地在应用程序中添加缓存功能。本篇文章将详细探讨如何通过key值更新Spring Cache中...

    Spring 缓存

    在上面的代码中，使用 `@Cacheable` 注解对 `getAllStudents()` 方法进行缓存，该方法将从缓存中检索数据，而不是从数据库中查询数据。 方法二：封装 Guava 缓存 封装 Guava 缓存是使用 Guava 包中的缓存机制，...

    spring AOP实现查询缓存

    本代码通过使用spring aop+ehcache的技术，实现了方法级别的查询缓存，主要原理是 方法的完整路径+方法参数值，作为key，放入cache中，下次访问时先判断cache中是否有该key.

    spring二级缓存

    例如，查询同一条数据两次，第二次应直接从缓存中获取，不再进行数据库查询。 在提供的文件中，"Hibernate+ehcache二级缓存配置 - 王贵伟 - JavaEye技术网站.htm"和"spring中配置二级缓存.htm"可能详细介绍了这些...

    使用maven简单搭建Spring mvc + redis缓存

    在这个过程中，我们添加了必要的依赖，配置了Spring MVC和Redis，最后编写了Controller来展示如何使用Redis进行缓存操作。在实际项目中，你可能还需要考虑异常处理、安全性、性能优化等更多细节。通过这种方式，你...

    基于Spring的Web缓存

    在介绍Spring缓存的项目中，可以在这里详细说明如何配置和使用缓存，以及如何测试缓存效果。 总的来说，基于Spring的Web缓存涉及到Spring框架的缓存抽象、注解驱动的缓存逻辑、Maven依赖管理和实际缓存实现的选择与...

    springboot 使用spring cache缓存 和 缓存数据落地到redis

    **@Cacheable**：此注解用于查询方法，当方法被调用时，如果缓存中有对应的键（key），则直接从缓存中获取结果，避免重复计算。如果没有，会执行方法并将结果存入缓存。\n\n2. **@CachePut**：这个注解用于更新方法...

    spring自动加载缓存

    当方法被调用时，Spring会检查缓存中是否存在对应的结果，如果存在则直接返回，无需再次执行方法；如果不存在，执行方法并将结果存入缓存。 2. **@CacheEvict**：此注解用于清除缓存。当某个操作完成后，可能需要...

    SpringCloud Finchley Gateway 缓存请求Body和Form表单的实现

    在Spring Cloud Finchley版本中，由于其基于WebFlux的响应式架构，我们需要特别注意如何正确地实现这种缓存。 首先，我们需要创建一个`GatewayContext`类来存储请求中的缓存数据。这个类包含了缓存的Body、FormData...

    springboot 使用spring cache缓存 和 使用fastjson配置redis系列化

    同时，为了处理缓存中的对象序列化问题，我们使用Fastjson替换默认的JDK序列化。这通常涉及到创建一个自定义的`CacheManager`，并配置Fastjson的序列化策略。代码示例如下： ```java @Configuration @EnableCaching...

    SpringBoot项目 MybatisPlus使用 Redis缓存.zip

    本项目中，我们看到“SpringBoot项目 MybatisPlus使用 Redis缓存.zip”主要涉及了SpringBoot、MybatisPlus和Redis三个核心组件，它们在实际开发中扮演着重要角色。 首先，SpringBoot是Spring框架的一种简化版，它...

    Spring基于注解的缓存配置--web应用实例

    如果缓存中没有，执行方法并把结果存入缓存，以便后续请求可以直接使用。 3. **@CacheEvict注解** 当需要清除特定缓存时，可以使用@CacheEvict。它可以标记在方法上，以在方法执行后清除指定缓存。此外，可以通过`...

    spring缓存机制-入门实例

    本篇文章将深入探讨Spring缓存机制的基础知识，并通过一个入门实例来阐述其工作原理和使用方法。 Spring缓存抽象是自Spring 3.1版本引入的，它提供了一个统一的API，支持多种缓存解决方案，如EhCache、Guava Cache...

    Ehcache 整合Spring 使用页面、对象缓存

    // 获取缓存中的对象数量 int size = sample.getSize(); // 获取缓存对象占用内存的大小 int memorySize = sample.getMemoryStoreSize(); // 获取缓存读取的命中次数 int hitCount = sample.getStatistics()....

    Spring+EhCache缓存实例

    在Spring中使用EhCache，首先需要在项目中引入EhCache的依赖，并在`pom.xml`或`build.gradle`中添加相应的依赖项。接着，在Spring的配置文件（如`applicationContext.xml`）中声明EhCache的配置： ```xml ...

    springMybatis+redis三级缓存框架

    如果一级缓存中未找到所需数据，系统会查询二级缓存（Redis）。如果二级缓存中也没有，那么数据将从数据库中获取，并同时存入一级和二级缓存，形成三级缓存机制。 集成Spring和MyBatis可以利用Spring的依赖注入和...

    使用spring aop对web 应用数据进行memcached缓存

    在实际应用中，`student-web`可能是一个包含学生管理功能的Web应用，使用Spring AOP和Memcached可以高效地缓存学生的查询结果，提高响应速度，减轻数据库压力。通过不断优化和调整缓存策略，可以进一步提升系统性能...

    09. Spring Boot缓存技术

    上述代码表示，当调用`getUserById`方法时，如果缓存中存在对应`id`的用户数据，就直接从缓存中获取，否则执行方法体内的逻辑并将结果存入缓存。 对于更复杂的缓存策略，可以自定义`KeyGenerator`和`CacheResolver`...

Magicbox
Global site tag (gtag.js) - Google Analytics