Java后台框架系列

文章15 |   阅读 7203 |   点赞0

来源：https://www.kancloud.cn/digest/javaframe

Redis+Spring缓存实例（windows环境，附实例源码及详解）

x33g5p2x  于2021-03-13 发布在 Spring  
字(12.1k)|赞(0)|评价(0)|浏览(464)

一、Redis了解

1.1、Redis介绍：

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis数据库完全在内存中，使用磁盘仅用于持久性。相比许多键值数据存储，Redis拥有一套较为丰富的数据类型。Redis可以将数据复制到任意数量的从服务器。

1.2、Redis优点：

（1）异常快速：Redis的速度非常快，每秒能执行约11万集合，每秒约81000+条记录。

（2）支持丰富的数据类型：Redis支持最大多数开发人员已经知道像列表，集合，有序集合，散列数据类型。这使得它非常容易解决各种各样的问题，因为我们知道哪些问题是可以处理通过它的数据类型更好。

（3）操作都是原子性：所有Redis操作是原子的，这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。

（4）多功能实用工具：Redis是一个多实用的工具，可以在多个用例如缓存，消息，队列使用(Redis原生支持发布/订阅)，任何短暂的数据，应用程序，如Web应用程序会话，网页命中计数等。

1.3、Redis缺点：

（1）单线程

（2）耗内存

二、64位windows下Redis安装

Redis官方是不支持windows的，但是Microsoft Open Tech group 在 GitHub上开发了一个Win64的版本，下载地址：https://github.com/MSOpenTech/redis/releases。注意只支持64位哈。

小宝鸽是下载了Redis-x64-3.0.500.msi进行安装。安装过程中全部采取默认即可。

安装完成之后可能已经帮你开启了Redis对应的服务，博主的就是如此。查看资源管理如下，说明已经开启：

图1

已经开启了对应服务的，我们让它保持，下面例子需要用到。如果没有开启的，我们命令开启，进入Redis的安装目录（博主的是C:\Program Files\Redis），然后如下命令开启：

  1. redis-server  redis.windows.conf

这里写图片描述

OK，下面我们进行实例。

三、详细实例

本工程采用的环境：eclipse + maven + spring + junit

3.1、添加相关依赖（spring+junit+redis依赖），pom.xml：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  2.   <modelVersion>4.0.0</modelVersion>
  3.   <groupId>com.luo</groupId>
  4.   <artifactId>redis_project</artifactId>
  5.   <version>0.0.1-SNAPSHOT</version>
  7.   <properties>
  8.         <!-- spring版本号 -->
  9.         <spring.version>3.2.8.RELEASE</spring.version>
  10.         <!-- junit版本号 -->
  11.         <junit.version>4.10</junit.version>
  12.   </properties>
  14.   <dependencies>
  15.         <!-- 添加Spring依赖 -->
  16.         <dependency>
  17.             <groupId>org.springframework</groupId>
  18.             <artifactId>spring-core</artifactId>
  19.             <version>${spring.version}</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.springframework</groupId>
  23.             <artifactId>spring-webmvc</artifactId>
  24.             <version>${spring.version}</version>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework</groupId>
  28.             <artifactId>spring-context</artifactId>
  29.             <version>${spring.version}</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework</groupId>
  33.             <artifactId>spring-context-support</artifactId>
  34.             <version>${spring.version}</version>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.springframework</groupId>
  38.             <artifactId>spring-aop</artifactId>
  39.             <version>${spring.version}</version>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework</groupId>
  43.             <artifactId>spring-aspects</artifactId>
  44.             <version>${spring.version}</version>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework</groupId>
  48.             <artifactId>spring-tx</artifactId>
  49.             <version>${spring.version}</version>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>org.springframework</groupId>
  53.             <artifactId>spring-jdbc</artifactId>
  54.             <version>${spring.version}</version>
  55.         </dependency>
  56.         <dependency>
  57.             <groupId>org.springframework</groupId>
  58.             <artifactId>spring-web</artifactId>
  59.             <version>${spring.version}</version>
  60.         </dependency>
  62.         <!--单元测试依赖 -->
  63.         <dependency>
  64.             <groupId>junit</groupId>
  65.             <artifactId>junit</artifactId>
  66.             <version>${junit.version}</version>
  67.             <scope>test</scope>
  68.         </dependency>
  70.         <!--spring单元测试依赖 -->
  71.         <dependency>
  72.             <groupId>org.springframework</groupId>
  73.             <artifactId>spring-test</artifactId>
  74.             <version>${spring.version}</version>
  75.             <scope>test</scope>
  76.         </dependency>
  78.         <!-- Redis 相关依赖  -->
  79.         <dependency>
  80.             <groupId>org.springframework.data</groupId>
  81.             <artifactId>spring-data-redis</artifactId>
  82.             <version>1.6.1.RELEASE</version>
  83.         </dependency>
  84.         <dependency>
  85.             <groupId>redis.clients</groupId>
  86.             <artifactId>jedis</artifactId>
  87.             <version>2.7.3</version>
  88.         </dependency>
  90.     </dependencies>
  91. </project>

3.2、spring配置文件application.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:aop="http://www.springframework.org/schema/aop"
  6.     xsi:schemaLocation="  
  7.            http://www.springframework.org/schema/beans  
  8.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  9.            http://www.springframework.org/schema/aop  
  10.            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  11.            http://www.springframework.org/schema/context  
  12.            http://www.springframework.org/schema/context/spring-context-3.0.xsd">
  14.     <!-- 自动扫描注解的bean -->
  15.     <context:component-scan base-package="com.luo.service" />
  17.     <!-- 引入properties配置文件 -->  
  18.     <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  19.         <property name="locations">
  20.             <list>
  21.                <value>classpath:properties/*.properties</value>
  22.                 <!--要是有多个配置文件，只需在这里继续添加即可 -->
  23.             </list>
  24.         </property>
  25.     </bean>
  27.     <!-- jedis 配置 -->
  28.     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
  29.           <property name="maxIdle" value="${redis.maxIdle}" />
  30.           <property name="maxWaitMillis" value="${redis.maxWait}" />
  31.           <property name="testOnBorrow" value="${redis.testOnBorrow}" />
  32.     </bean >
  34.     <!-- redis服务器中心 -->
  35.     <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
  36.           <property name="poolConfig" ref="poolConfig" />
  37.           <property name="port" value="${redis.port}" />
  38.           <property name="hostName" value="${redis.host}" />
  39.           <!-- <property name="password" value="${redis.password}" /> -->
  40.           <property name="timeout" value="${redis.timeout}" ></property>
  41.     </bean >
  42.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
  43.           <property name="connectionFactory" ref="connectionFactory" />
  44.           <property name="keySerializer" >
  45.               <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
  46.           </property>
  47.           <property name="valueSerializer" >
  48.               <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
  49.           </property>
  50.     </bean >
  52.     <!-- cache配置 -->
  53.     <bean id="methodCacheInterceptor" class="com.luo.redis.cache.MethodCacheInterceptor" >
  54.           <property name="redisTemplate" ref="redisTemplate" />
  55.     </bean >
  57.     <!-- aop配置切点跟通知 -->
  58.     <bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  59.         <property name="advice" ref="methodCacheInterceptor"/>
  60.         <property name="pattern" value=".*ServiceImpl.*getTimestamp"/>
  61.     </bean>
  62.     <bean id="redisTestService" class="com.luo.service.impl.RedisTestServiceImpl">
  63.     </bean>
  64.     <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
  66. </beans>

3.3、Redis配置参数，redis.properties：

  1. #redis中心
  2. #绑定的主机地址
  3. redis.host=127.0.0.1 
  4. #指定Redis监听端口，默认端口为6379
  5. redis.port=6379 
  6. #授权密码（本例子没有使用）
  7. redis.password=123456  
  8. #最大空闲数：空闲链接数大于maxIdle时，将进行回收
  9. redis.maxIdle=100  
  10. #最大连接数：能够同时建立的“最大链接个数”
  11. redis.maxActive=300  
  12. #最大等待时间：单位ms
  13. redis.maxWait=1000   
  14. #使用连接时，检测连接是否成功 
  15. redis.testOnBorrow=true 
  16. #当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
  17. redis.timeout=10000

3.4、添加接口及对应实现RedisTestService.java和RedisTestServiceImpl.java：

  1. package com.luo.service;
  3. public interface RedisTestService {
  4.     public String getTimestamp(String param);
  5. }
  1. package com.luo.service.impl;
  3. import org.springframework.stereotype.Service;
  4. import com.luo.service.RedisTestService;
  6. @Service
  7. public class RedisTestServiceImpl implements RedisTestService {
  9.     public String getTimestamp(String param) {
  10.         Long timestamp = System.currentTimeMillis();
  11.         return timestamp.toString();
  12.     }
  14. }

3.5、本例采用spring aop切面方式进行缓存，配置已在上面spring配置文件中，对应实现为MethodCacheInterceptor.java：

  1. package com.luo.redis.cache;
  3. import java.io.Serializable;
  4. import java.util.concurrent.TimeUnit;
  5. import org.aopalliance.intercept.MethodInterceptor;
  6. import org.aopalliance.intercept.MethodInvocation;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.core.ValueOperations;
  10. public class MethodCacheInterceptor implements MethodInterceptor {
  12.     private RedisTemplate<Serializable, Object> redisTemplate;
  13.     private Long defaultCacheExpireTime = 10l; // 缓存默认的过期时间,这里设置了10秒
  15.     public Object invoke(MethodInvocation invocation) throws Throwable {
  16.         Object value = null;
  18.         String targetName = invocation.getThis().getClass().getName();
  19.         String methodName = invocation.getMethod().getName();
  21.         Object[] arguments = invocation.getArguments();
  22.         String key = getCacheKey(targetName, methodName, arguments);
  24.         try {
  25.             // 判断是否有缓存
  26.             if (exists(key)) {
  27.                 return getCache(key);
  28.             }
  29.             // 写入缓存
  30.             value = invocation.proceed();
  31.             if (value != null) {
  32.                 final String tkey = key;
  33.                 final Object tvalue = value;
  34.                 new Thread(new Runnable() {
  35.                     public void run() {
  36.                         setCache(tkey, tvalue, defaultCacheExpireTime);
  37.                     }
  38.                 }).start();
  39.             }
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.             if (value == null) {
  43.                 return invocation.proceed();
  44.             }
  45.         }
  46.         return value;
  47.     }
  49.     /**
  50.      * 创建缓存key
  51.      *
  52.      * @param targetName
  53.      * @param methodName
  54.      * @param arguments
  55.      */
  56.     private String getCacheKey(String targetName, String methodName,
  57.             Object[] arguments) {
  58.         StringBuffer sbu = new StringBuffer();
  59.         sbu.append(targetName).append("_").append(methodName);
  60.         if ((arguments != null) && (arguments.length != 0)) {
  61.             for (int i = 0; i < arguments.length; i++) {
  62.                 sbu.append("_").append(arguments[i]);
  63.             }
  64.         }
  65.         return sbu.toString();
  66.     }
  68.     /**
  69.      * 判断缓存中是否有对应的value
  70.      * 
  71.      * @param key
  72.      * @return
  73.      */
  74.     public boolean exists(final String key) {
  75.         return redisTemplate.hasKey(key);
  76.     }
  78.     /**
  79.      * 读取缓存
  80.      * 
  81.      * @param key
  82.      * @return
  83.      */
  84.     public Object getCache(final String key) {
  85.         Object result = null;
  86.         ValueOperations<Serializable, Object> operations = redisTemplate
  87.                 .opsForValue();
  88.         result = operations.get(key);
  89.         return result;
  90.     }
  92.     /**
  93.      * 写入缓存
  94.      * 
  95.      * @param key
  96.      * @param value
  97.      * @return
  98.      */
  99.     public boolean setCache(final String key, Object value, Long expireTime) {
  100.         boolean result = false;
  101.         try {
  102.             ValueOperations<Serializable, Object> operations = redisTemplate
  103.                     .opsForValue();
  104.             operations.set(key, value);
  105.             redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
  106.             result = true;
  107.         } catch (Exception e) {
  108.             e.printStackTrace();
  109.         }
  110.         return result;
  111.     }
  113.     public void setRedisTemplate(
  114.             RedisTemplate<Serializable, Object> redisTemplate) {
  115.         this.redisTemplate = redisTemplate;
  116.     }
  117. }

3.6、单元测试相关类：

  1. package com.luo.baseTest;
  3. import org.junit.runner.RunWith;  
  4. import org.springframework.test.context.ContextConfiguration;  
  5. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
  6. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  8. //指定bean注入的配置文件  
  9. @ContextConfiguration(locations = { "classpath:application.xml" })  
  10. //使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner  
  11. @RunWith(SpringJUnit4ClassRunner.class)  
  12. public class SpringTestCase extends AbstractJUnit4SpringContextTests {
  14. }
  1. package com.luo.service;
  3. import org.junit.Test;
  4. import org.springframework.beans.factory.annotation.Autowired;
  6. import com.luo.baseTest.SpringTestCase;
  8. public class RedisTestServiceTest extends SpringTestCase {
  10.     @Autowired  
  11.     private RedisTestService redisTestService;
  13.     @Test  
  14.     public void getTimestampTest() throws InterruptedException{  
  15.         System.out.println("第一次调用：" + redisTestService.getTimestamp("param"));
  16.         Thread.sleep(2000);
  17.         System.out.println("2秒之后调用：" + redisTestService.getTimestamp("param"));
  18.         Thread.sleep(11000);
  19.         System.out.println("再过11秒之后调用：" + redisTestService.getTimestamp("param"));
  20.     } 
  21. }

3.7、运行结果：

这里写图片描述

四、源码下载

http://download.csdn.net/detail/u013142781/9403316

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com