Redis整合Spring结合使用缓存实例

一、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,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; 
  } 
} 

(2)MethodCacheInterceptor
切面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,xxxSetRecordManagerTime); 
            } else { 
              redisUtil.set(tkey,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,"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。但是它确实是从缓存中去取的,这点我们从上面的断点可以看到。

以上就是本文的全部内容,希望对大家的学习有所帮助。

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐


本篇内容主要讲解“sqlalchemy的常用数据类型怎么使用”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“sqlalche...
今天小编给大家分享一下sqlServer实现分页查询的方式有哪些的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家
这篇文章主要介绍“sqlmap之osshell怎么使用”,在日常操作中,相信很多人在sqlmap之osshell怎么使用问题上存在疑惑,小编查阅了各式资料,整理出
本篇内容介绍了“SQL注入的知识点有哪些”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧...
1. mssql权限sa权限:数据库操作,文件管理,命令执行,注册表读取等system。是mssql的最高权限db权限:文件管理,数据库操作等 users-administratorspublic权限:数据库操作 guest-users2、sql server注入执行命令查
sql执行计划如何查看?在SPL庞大的数据中我们不知道如何查看实际数据库中发生了什么事情,有必要定期进行查询优化和索引否则会影响我们后期的SQL的查询速度。那么针对这样的问题我们必须要知道SQL执行的计划,在本文中winwin7小编给大家分享下SQL执
SQL Server 是Microsoft 公司推出的关系型数据库管理系统。具有使用方便可伸缩性好与相关软件集成程度高等优点应用非常广泛。不过在使用中,我们会遇到非常多的错误,面对这么庞大的数据库环境,当然会有精确的错误代码的对照季,下面小编分享的
SQL Server本地账户无法登陆出现错误提示:error:40-Could not open a connenction to SQL Server的问题很常见,对于初学者来说可能不知道如何解决,一起来看看下面的解决方案。解决步骤如下:1、这种情况需要开启 SQL Server service
微软推出的SQL2008是一款非常好用的数据库软件,它稳定、功能强大,为众多企业提供了最佳的数据库解决方案,那么我们如何在Windows中安装它呢,一些朋友对SQL Server 2008的安装过程还不是很熟悉,下面就一起来看看SQL Server 2008详细安装图解...
本页概要如果您使用的是 SQL Server 2005备份和还原Sp_detach_db 和 Sp_attach_db 存储过程关于排序规则的说明导入和导出数据(在 SQL Server 数据库之间复
DBCC CHECKIDENT 检查指定表的当前标识值,如有必要,还对标识值进行更正。 语法 DBCC CHECKIDENT ( &#39;table_name&#39; [ , { NORESEED
这里对 SQL Server 字符串函数进行分门别类地列出,便于查阅和记忆,相信大家都在其它方面有高深的编程基础,从字面上来说大家都知道这些函数的意义,就不对这些函数作过多的解释了,主要谈些经验,具体
查询及删除重复记录的方法 1、查找表(people)中多余的重复记录,重复记录是根据单个字段(peopleId)来判断select*frompeoplewherepeopleIdin(selectpe
微软发SQL Server 2008第二个CTP预览版from: http://news.csdn.net/n/20070807/107158.html8月7日消息,微软公司本周发布了SQL Serv
症状当您将数据库备份恢复到另一台服务器时,可能会遇到孤立用户的问题。SQL Server 联机丛书中的孤立用户疑难解答主题中没有讲述解决此问题的具体步骤。本文介绍了如何解决孤立用户问题。更多信息虽然术
当登录SQL Server 2005时可能碰到错误: &#39;No Process is on the Other End of the Pipe&#39;。解决方法:(1)Open up SQL
概要本文描述如何映射标准登录和集成登录来解决在运行 SQL Server 的服务器之间移动数据库时的权限问题。更多信息当您将数据库从一个运行 SQL Server 的服务器移到另一个运行 SQL Se
----------------------------------------问题:该用户与可信的SQL SERVER 连接无关联使用sa用户或自建用户使用“SQL SERVER 身份认证”连接数据
更新日期: 2007 年 5 月 20 日 使用下表可以确定各种版本的 Microsoft SQL Server 2005 支持哪些功能。有关 SQL Server 2005 Enterprise E
当从Excel导入数据到Sql Sever中,可能会出现以下问题:&#xD;&#xA;对于指定的缓冲区大小而言,源列的数据太大