关键词:
林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka
摘要:本文介绍了如何在Spring中配置redis,并通过Spring中AOP的思想,将缓存的方法切入到有需要进入缓存的类或方法前面。
一、Redis介绍
什么是Redis?
redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的。在此基础上,redis支持各种不同方式的排序。与memcached一样,为了保证效率,数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件,并且在此基础上实现了master-slave(主从)同步。
它有什么特点?
(1)Redis数据库完全在内存中,使用磁盘仅用于持久性。
(2)相比许多键值数据存储,Redis拥有一套较为丰富的数据类型。
(3)Redis可以将数据复制到任意数量的从服务器。
Redis 优势?
(1)异常快速:Redis的速度非常快,每秒能执行约11万集合,每秒约81000+条记录。
(2)支持丰富的数据类型:Redis支持最大多数开发人员已经知道像列表,集合,有序集合,散列数据类型。这使得它非常容易解决各种各样的问题,因为我们知道哪些问题是可以处理通过它的数据类型更好。
(3)操作都是原子性:所有Redis操作是原子的,这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。
(4)多功能实用工具:Redis是一个多实用的工具,可以在多个用例如缓存,消息,队列使用(Redis原生支持发布/订阅),任何短暂的数据,应用程序,如Web应用程序会话,网页命中计数等。
Redis 缺点?
(1)单线程
(2)耗内存
二、使用实例
本文使用maven+eclipse+sping
1、引入jar包
- <!--Redis start -->
- <dependency>
- <groupId>org.springframework.data</groupId>
- <artifactId>spring-data-redis</artifactId>
- <version>1.6.1.RELEASE</version>
- </dependency>
- <dependency>
- <groupId>redis.clients</groupId>
- <artifactId>jedis</artifactId>
- <version>2.7.3</version>
- </dependency>
- <!--Redis end -->
2、配置bean
在application.xml加入如下配置
- <!-- jedis 配置 -->
- <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
- <property name="maxIdle" value="${redis.maxIdle}" />
- <property name="maxWaitMillis" value="${redis.maxWait}" />
- <property name="testOnBorrow" value="${redis.testOnBorrow}" />
- </bean >
- <!-- redis服务器中心 -->
- <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
- <property name="poolConfig" ref="poolConfig" />
- <property name="port" value="${redis.port}" />
- <property name="hostName" value="${redis.host}" />
- <property name="password" value="${redis.password}" />
- <property name="timeout" value="${redis.timeout}" ></property>
- </bean >
- <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
- <property name="connectionFactory" ref="connectionFactory" />
- <property name="keySerializer" >
- <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
- </property>
- <property name="valueSerializer" >
- <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
- </property>
- </bean >
- <!-- cache配置 -->
- <bean id="methodCacheInterceptor" class="com.mucfc.msm.common.MethodCacheInterceptor" >
- <property name="redisUtil" ref="redisUtil" />
- </bean >
- <bean id="redisUtil" class="com.mucfc.msm.common.RedisUtil" >
- <property name="redisTemplate" ref="redisTemplate" />
- </bean >
其中配置文件redis一些配置数据redis.properties如下:
- #redis中心
- redis.host=10.75.202.11
- redis.port=6379
- redis.password=123456
- redis.maxIdle=100
- redis.maxActive=300
- redis.maxWait=1000
- redis.testOnBorrow=true
- redis.timeout=100000
- # 不需要加入缓存的类
- targetNames=xxxRecordManager,xxxSetRecordManager,xxxStatisticsIdentificationManager
- # 不需要缓存的方法
- methodNames=
- #设置缓存失效时间
- com.service.impl.xxxRecordManager= 60
- com.service.impl.xxxSetRecordManager= 60
- defaultCacheExpireTime=3600
- fep.local.cache.capacity =10000
要扫这些properties文件,在application.xml加入如下配置
- <!-- 引入properties配置文件 -->
- <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
- <property name="locations">
- <list>
- <value>classpath:properties/*.properties</value>
- <!--要是有多个配置文件,只需在这里继续添加即可 -->
- </list>
- </property>
- </bean>
3、一些工具类
(1)RedisUtil
上面的bean中,RedisUtil是用来缓存和去除数据的实例
- package com.mucfc.msm.common;
- import java.io.Serializable;
- import java.util.Set;
- import java.util.concurrent.TimeUnit;
- import org.apache.log4j.Logger;
- import org.springframework.data.redis.core.RedisTemplate;
- import org.springframework.data.redis.core.ValueOperations;
- /**
- * redis cache 工具类
- *
- */
- public final class RedisUtil {
- private Logger logger = Logger.getLogger(RedisUtil.class);
- private RedisTemplate<Serializable, Object> redisTemplate;
- /**
- * 批量删除对应的value
- *
- * @param keys
- */
- public void remove(final String... keys) {
- for (String key : keys) {
- remove(key);
- }
- }
- /**
- * 批量删除key
- *
- * @param pattern
- */
- public void removePattern(final String pattern) {
- Set<Serializable> keys = redisTemplate.keys(pattern);
- if (keys.size() > 0)
- redisTemplate.delete(keys);
- }
- /**
- * 删除对应的value
- *
- * @param key
- */
- public void remove(final String key) {
- if (exists(key)) {
- redisTemplate.delete(key);
- }
- }
- /**
- * 判断缓存中是否有对应的value
- *
- * @param key
- * @return
- */
- public boolean exists(final String key) {
- return redisTemplate.hasKey(key);
- }
- /**
- * 读取缓存
- *
- * @param key
- * @return
- */
- public Object get(final String key) {
- Object result = null;
- ValueOperations<Serializable, Object> operations = redisTemplate
- .opsForValue();
- result = operations.get(key);
- return result;
- }
- /**
- * 写入缓存
- *
- * @param key
- * @param value
- * @return
- */
- public boolean set(final String key, Object value) {
- boolean result = false;
- try {
- ValueOperations<Serializable, Object> operations = redisTemplate
- .opsForValue();
- operations.set(key, value);
- result = true;
- } catch (Exception e) {
- e.printStackTrace();
- }
- return result;
- }
- /**
- * 写入缓存
- *
- * @param key
- * @param value
- * @return
- */
- public boolean set(final String key, Object value, Long expireTime) {
- boolean result = false;
- try {
- ValueOperations<Serializable, Object> operations = redisTemplate
- .opsForValue();
- operations.set(key, value);
- redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
- result = true;
- } catch (Exception e) {
- e.printStackTrace();
- }
- return result;
- }
- public void setRedisTemplate(
- RedisTemplate<Serializable, Object> redisTemplate) {
- this.redisTemplate = redisTemplate;
- }
- }
切面MethodCacheInterceptor,这是用来给不同的方法来加入判断如果缓存存在数据,从缓存取数据。否则第一次从数据库取,并将结果保存到缓存 中去。
- package com.mucfc.msm.common;
- import java.io.File;
- import java.io.FileInputStream;
- import java.io.InputStream;
- import java.util.ArrayList;
- import java.util.List;
- import java.util.Properties;
- import org.aopalliance.intercept.MethodInterceptor;
- import org.aopalliance.intercept.MethodInvocation;
- import org.apache.log4j.Logger;
- public class MethodCacheInterceptor implements MethodInterceptor {
- private Logger logger = Logger.getLogger(MethodCacheInterceptor.class);
- private RedisUtil redisUtil;
- private List<String> targetNamesList; // 不加入缓存的service名称
- private List<String> methodNamesList; // 不加入缓存的方法名称
- private Long defaultCacheExpireTime; // 缓存默认的过期时间
- private Long xxxRecordManagerTime; //
- private Long xxxSetRecordManagerTime; //
- /**
- * 初始化读取不需要加入缓存的类名和方法名称
- */
- public MethodCacheInterceptor() {
- try {
- File f = new File("D:\lunaJee-workspace\msm\msm_core\src\main\java\com\mucfc\msm\common\cacheConf.properties");
- //配置文件位置直接被写死,有需要自己修改下
- InputStream in = new FileInputStream(f);
- // InputStream in = getClass().getClassLoader().getResourceAsStream(
- // "D:\lunaJee-workspace\msm\msm_core\src\main\java\com\mucfc\msm\common\cacheConf.properties");
- Properties p = new Properties();
- p.load(in);
- // 分割字符串
- String[] targetNames = p.getProperty("targetNames").split(",");
- String[] methodNames = p.getProperty("methodNames").split(",");
- // 加载过期时间设置
- defaultCacheExpireTime = Long.valueOf(p.getProperty("defaultCacheExpireTime"));
- xxxRecordManagerTime = Long.valueOf(p.getProperty("com.service.impl.xxxRecordManager"));
- xxxSetRecordManagerTime = Long.valueOf(p.getProperty("com.service.impl.xxxSetRecordManager"));
- // 创建list
- targetNamesList = new ArrayList<String>(targetNames.length);
- methodNamesList = new ArrayList<String>(methodNames.length);
- Integer maxLen = targetNames.length > methodNames.length ? targetNames.length
- : methodNames.length;
- // 将不需要缓存的类名和方法名添加到list中
- for (int i = 0; i < maxLen; i++) {
- if (i < targetNames.length) {
- targetNamesList.add(targetNames[i]);
- }
- if (i < methodNames.length) {
- methodNamesList.add(methodNames[i]);
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- @Override
- public Object invoke(MethodInvocation invocation) throws Throwable {
- Object value = null;
- String targetName = invocation.getThis().getClass().getName();
- String methodName = invocation.getMethod().getName();
- // 不需要缓存的内容
- //if (!isAddCache(StringUtil.subStrForLastDot(targetName), methodName)) {
- if (!isAddCache(targetName, methodName)) {
- // 执行方法返回结果
- return invocation.proceed();
- }
- Object[] arguments = invocation.getArguments();
- String key = getCacheKey(targetName, methodName, arguments);
- System.out.println(key);
- try {
- // 判断是否有缓存
- if (redisUtil.exists(key)) {
- return redisUtil.get(key);
- }
- // 写入缓存
- value = invocation.proceed();
- if (value != null) {
- final String tkey = key;
- final Object tvalue = value;
- new Thread(new Runnable() {
- @Override
- public void run() {
- if (tkey.startsWith("com.service.impl.xxxRecordManager")) {
- redisUtil.set(tkey, tvalue, xxxRecordManagerTime);
- } else if (tkey.startsWith("com.service.impl.xxxSetRecordManager")) {
- redisUtil.set(tkey, tvalue, xxxSetRecordManagerTime);
- } else {
- redisUtil.set(tkey, tvalue, defaultCacheExpireTime);
- }
- }
- }).start();
- }
- } catch (Exception e) {
- e.printStackTrace();
- if (value == null) {
- return invocation.proceed();
- }
- }
- return value;
- }
- /**
- * 是否加入缓存
- *
- * @return
- */
- private boolean isAddCache(String targetName, String methodName) {
- boolean flag = true;
- if (targetNamesList.contains(targetName)
- || methodNamesList.contains(methodName)) {
- flag = false;
- }
- return flag;
- }
- /**
- * 创建缓存key
- *
- * @param targetName
- * @param methodName
- * @param arguments
- */
- private String getCacheKey(String targetName, String methodName,
- Object[] arguments) {
- StringBuffer sbu = new StringBuffer();
- sbu.append(targetName).append("_").append(methodName);
- if ((arguments != null) && (arguments.length != 0)) {
- for (int i = 0; i < arguments.length; i++) {
- sbu.append("_").append(arguments[i]);
- }
- }
- return sbu.toString();
- }
- public void setRedisUtil(RedisUtil redisUtil) {
- this.redisUtil = redisUtil;
- }
- }
4、配置需要缓存的类或方法
在application.xml加入如下配置,有多个类或方法可以配置多个
- <!-- 需要加入缓存的类或方法 -->
- <bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" >
- <property name="advice" >
- <ref local="methodCacheInterceptor" />
- </property>
- <property name="patterns" >
- <list>
- <!-- 确定正则表达式列表 -->
- <value>com.mucfc.msm.service.impl...*ServiceImpl.*</value >
- </list>
- </property>
- </bean >
5、执行结果:
写了一个简单的单元测试如下:
- @Test
- public void getSettUnitBySettUnitIdTest() {
- String systemId = "CES";
- String merchantId = "133";
- SettUnit configSettUnit = settUnitService.getSettUnitBySettUnitId(systemId, merchantId, "ESP");
- SettUnit configSettUnit1 = settUnitService.getSettUnitBySettUnitId(systemId, merchantId, "ESP");
- boolean flag= (configSettUnit == configSettUnit1);
- System.out.println(configSettUnit);
- logger.info("查找结果" + configSettUnit.getBusinessType());
- // localSecondFIFOCache.put("configSettUnit", configSettUnit.getBusinessType());
- // String string = localSecondFIFOCache.get("configSettUnit");
- logger.info("查找结果" + string);
- }
MethodCacheInterceptor这个类中打了断点,然后每次查询前都会先进入这个方法
依次运行,发现没有缓存,所以会直接去查数据库
打印了出来的SQL语句:
第二次执行:
因为第一次执行时,已经写入缓存了。所以第二次直接从缓存中取数据
3、取两次的结果进行地址的对比:
发现两个不是同一个对象,没错,是对的。如果是使用ehcache的话,那么二者的内存地址会是一样的。那是因为redis和ehcache使用的缓存机制是不一样的。ehcache是基于本地电脑的内存使用缓存,所以使用缓存取数据时直接在本地电脑上取。转换成java对象就会是同一个内存地址,而redis它是在装有redis服务的电脑上(一般是另一台电脑),所以取数据时经过传输到本地,会对应到不同的内存地址,所以用==来比较会返回false。但是它确实是从缓存中去取的,这点我们从上面的断点可以看到。
http://blog.csdn.net/evankaka/article/details/50396325
spring整合redis做数据缓存(windows环境)
当我们一个项目的数据量很大的时候,就需要做一些缓存机制来减轻数据库的压力,提升应用程序的性能,对于java项目来说,最常用的缓存组件有Redis、Ehcache和Memcached。Ehcache是用java开发的缓存组件,和java结合良好,直接在jvm... 查看详情
spring整合redis客户端及缓存接口设计
一、写在前面缓存作为系统性能优化的一大杀手锏,几乎在每个系统或多或少的用到缓存。有的使用本地内存作为缓存,有的使用本地硬盘作为缓存,有的使用缓存服务器。但是无论使用哪种缓存,接口中的方法... 查看详情
spring整合hibernate时启用二级缓存实例详解
写在前面: 1.本例使用Hibernate3+Spring3; 2.本例的查询使用了HibernateTemplate;1.导入ehcache-x.x.x.jar包;2.在applicationContext.xml文件中找到sessionFactory相应的配置信息并在设置hibernateProperties中添加如下代码:?123456<!--配置使... 查看详情
spring整合redis简单使用
1.简单介绍redis是基于C语言开发。redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sortedset--有序集合)和hash(哈希类型)。redis是一个缓存数据库(片面的... 查看详情
guava和spring整合使用(这里只用到了缓存)
最近做的项目需要使用缓存,最初考虑redis,但是实际不需要功能那么强大,只需要缓存即可,redis还需要安装等,项目也比较赶,就用guava 1importcom.google.common.cache.CacheBuilder;2importcom.google.common.cache.CacheBuilderSpec;34importorg.springframewo... 查看详情
spring优雅整合redis缓存
“小明,多系统的session共享,怎么处理?”“Redis缓存啊!”“小明,我想实现一个简单的消息队列?”“Redis缓存啊!”“小明,分布式锁这玩意有什么方案?”“Redis缓存啊!”“... 查看详情
springboot整合springseesion实现redis缓存
...据库,我们可以通过配置或者注解的方式将SpringBoot和Redis整合。而在分布式系统中又会涉及到session共享的问题,多个服务同时部署时session需要共享,SpringSession可以帮助我们实现这一功能。将SpringSession集成到SpringBoot框架中并使... 查看详情
springboot整合redis缓存
使用springBoot添加redis缓存需要在POM文件里引入<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency><dependency 查看详情
springboot整合spring@cache和redis(代码片段)
转载请注明出处:https://www.cnblogs.com/wenjunwei/p/10779450.htmlspring基于注解的缓存对于缓存声明,spring的缓存提供了一组java注解:@Cacheable:触发缓存写入。@CacheEvict:触发缓存清除。@CachePut:更新缓存(不会影响到方法的运行)。@Caching:重新... 查看详情
springboot整合redis,一篇解决缓存的所有问题(代码片段)
前言上一篇博文,我们重点介绍了SpringBoot如何整合Mybatis,JPA等技术,访问我们的关系型数据库,这篇博文我们介绍SpringBoot如何整合Redis来访问非关系型数据库,带你深入了解Redis的自动原理,并结合具体... 查看详情
springboot整合redis,一篇解决缓存的所有问题(代码片段)
前言上一篇博文,我们重点介绍了SpringBoot如何整合Mybatis,JPA等技术,访问我们的关系型数据库,这篇博文我们介绍SpringBoot如何整合Redis来访问非关系型数据库,带你深入了解Redis的自动原理,并结合具体... 查看详情
32springboot——缓存之整合redis
springboot缓存默认使用ConcurrentMapCacheManager 将数据保存在下面的Map中1、docker中开启Redis 2、添加Redis相关依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-st 查看详情
精通springboot--整合redis实现缓存
今天我们来讲讲怎么在springboot中整合redis实现对数据库查询结果的缓存。首先第一步要做的就是在pom.xml文件添加spring-boot-starter-data-redis。要整合缓存,必不可少的就是我们要继承一个父类CachingConfigurerSupport。我们先看看这个类... 查看详情
sping整合redis,以及做mybatis的第三方缓存
一、spring整合redisRedis作为一个时下非常流行的NOSQL语言,不学一下有点过意不去。背景:学习Redis用到的框架是maven+spring+mybatis(框架如何搭建这边就不叙述了)首先在pom里面添加当前所需要的jar包,有下面几个:………………... 查看详情
redis入门很简单之五jedis和spring的整合
Redis入门很简单之五【Jedis和Spring的整合】博客分类: NoSQL/Redis/MongoDBredisnosql缓存jedisspring 在上一篇文章中,简单介绍了Jedis的连接池使用方式。如果和Spring进行整合的话,我们将获得更好的简洁性、灵活性,显然是一种... 查看详情
springboot整合redis做简单缓存(代码片段)
一、引入依赖<!--引入redis依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!--使用fastjson做序列化和反序列化--><dependency><groupId>com.al... 查看详情
spring+ehcache缓存实例(详细讲解+源码下载)(转)
一、ehcahe的介绍EhCache是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,JavaEE和轻量级容器。它具有内存和磁盘存储,缓存加载... 查看详情
springboot整合redis实现缓存
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId><version>1.5.2.RELEASE</version></dependency& 查看详情