AI 助理
备案控制台
开发者社区 数据库 文章 正文

spring整合redis缓存

2017-11-14 1100
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
系统运维管理，不限时长
简介：

如果对spring cache不了解,这边有一篇文章详细的介绍了
http://jinnianshilongnian.iteye.com/blog/2001040
改项目基于maven构建
相关依赖

Xml代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
< dependency >  
     < groupId >org.springframework.data</ groupId >  
     < artifactId >spring-data-redis</ artifactId >  
     < version >1.3.4.RELEASE</ version >  
</ dependency >  
   
< dependency >  
     < groupId >redis.clients</ groupId >  
     < artifactId >jedis</ artifactId >  
     < version >2.5.2</ version >  
</ dependency >  
   
< dependency >  
     < groupId >org.springframework</ groupId >  
     < artifactId >spring-jdbc</ artifactId >  
     < version >3.2.13.RELEASE</ version >  
</ dependency >  
   
<!-- 日志记录依赖包，很多都依赖此包，像log4j,json-lib等等 -->  
< dependency >  
     < groupId >commons-logging</ groupId >  
     < artifactId >commons-logging-api</ artifactId >  
     < version >1.1</ version >  
</ dependency >  
   
<!-- junit 测试包 -->  
< dependency >  
     < groupId >junit</ groupId >  
     < artifactId >junit</ artifactId >  
     < version >4.11</ version >  
     < scope >test</ scope >  
</ dependency >  
   
< dependency >  
     < groupId >org.springframework</ groupId >  
     < artifactId >spring-test</ artifactId >  
     < version >3.2.13.RELEASE</ version >  
     < scope >test</ scope >  
</ dependency >

Spring相关配置
Xml代码  收藏代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<? 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:context = "http://www.springframework.org/schema/context"  
     xmlns:cache = "http://www.springframework.org/schema/cache"  xmlns:p = "http://www.springframework.org/schema/p"  
     xmlns:c = "http://www.springframework.org/schema/c"  
     xsi:schemaLocation="  
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd  
         http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd  
         http://www.springframework.org/schema/cache   
         http://www.springframework.org/schema/cache/spring-cache-3.2.xsd"  
     default-lazy-init = "true" >  
   
     < context:property-placeholder  location = "classpath:redis.properties"  />  
       
     <!-- 自动扫描包 -->  
     < context:component-scan  base-package = "com.layou"  />  
   
   
     <!-- 启用缓存注解功能，这个是必须的，否则注解不会生效，另外，该注解一定要声明在spring主配置文件中才会生效 -->  
     < cache:annotation-driven  cache-manager = "cacheManager"  />  
   
     <!-- spring自己的换管理器，这里定义了两个缓存位置名称 ，既注解中的value -->  
     < bean  id = "cacheManager"  class = "org.springframework.cache.support.SimpleCacheManager" >  
         < property  name = "caches" >  
             < set >  
                 < bean  class = "com.layou.RedisCache" >  
                     < property  name = "redisTemplate"  ref = "redisTemplate"  />  
                     < property  name = "name"  value = "default"  />  
                 </ bean >  
             </ set >  
         </ property >  
     </ bean >  
   
     <!-- redis 相关配置 -->  
     < bean  id = "poolConfig"  class = "redis.clients.jedis.JedisPoolConfig" >  
         < property  name = "maxIdle"  value = "${redis.pool.maxIdle}"  />  
         < property  name = "maxTotal"  value = "${redis.pool.maxActive}"  />  
         < property  name = "maxWaitMillis"  value = "${redis.pool.maxWait}"  />  
         < property  name = "testOnBorrow"  value = "${redis.pool.testOnBorrow}"  />  
     </ bean >  
   
     < bean  id = "connectionFactory"  
         class = "org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >  
         < property  name = "hostName"  value = "${redis.host}"  />  
         < property  name = "port"  value = "${redis.port}"  />  
         < property  name = "password"  value = "${redis.password}"  />  
         < property  name = "timeout"  value = "${redis.timeout}"  />  
         < property  name = "usePool"  value = "true"  />  
         < property  name = "poolConfig"  ref = "poolConfig"  />  
     </ bean >  
   
     < bean  id = "redisTemplate"  class = "org.springframework.data.redis.core.RedisTemplate" >  
         < property  name = "connectionFactory"  ref = "connectionFactory"  />  
     </ bean >  
</ beans >

redis相关配置
Java代码  收藏代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#redis.host=localhost  
redis.host=192.168.71.145  
redis.port=6379  
redis.password=  
#客户端超时时间单位是毫秒  
redis.timeout=100000  
   
#最大连接数  
redis.pool.maxActive=500    
#最大能够保持idel状态的对象数    
redis.pool.maxIdle=200    
#最大建立连接等待时间    
redis.pool.maxWait=2000    
#当调用borrow Object方法时，是否进行有效性检查    
redis.pool.testOnBorrow=true

首先,通过自己实现Cache接口来实现对redis的相关操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package  com.layou;  
   
import  java.io.ByteArrayInputStream;  
import  java.io.ByteArrayOutputStream;  
import  java.io.IOException;  
import  java.io.ObjectInputStream;  
import  java.io.ObjectOutputStream;  
   
import  org.springframework.cache.Cache;  
import  org.springframework.cache.support.SimpleValueWrapper;  
import  org.springframework.dao.DataAccessException;  
import  org.springframework.data.redis.connection.RedisConnection;  
import  org.springframework.data.redis.core.RedisCallback;  
import  org.springframework.data.redis.core.RedisTemplate;  
   
public  class  RedisCache  implements  Cache {  
   
     private  RedisTemplate<String, Object> redisTemplate;  
     private  String name;  
   
     public  RedisTemplate<String, Object> getRedisTemplate() {  
         return  redisTemplate;  
     }  
   
     public  void  setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
         this .redisTemplate = redisTemplate;  
     }  
   
     public  void  setName(String name) {  
         this .name = name;  
     }  
   
     @Override  
     public  String getName() {  
         return  this .name;  
     }  
   
     @Override  
     public  Object getNativeCache() {  
         return  this .redisTemplate;  
     }  
   
     @Override  
     public  ValueWrapper get(Object key) {  
         final  String keyf = (String) key;  
         Object object =  null ;  
         object = redisTemplate.execute( new  RedisCallback<Object>() {  
             public  Object doInRedis(RedisConnection connection)  throws  DataAccessException {  
   
                 byte [] key = keyf.getBytes();  
                 byte [] value = connection.get(key);  
                 if  (value ==  null ) {  
                     return  null ;  
                 }  
                 return  toObject(value);  
   
             }  
         });  
         return  (object !=  null  ?  new  SimpleValueWrapper(object) :  null );  
     }  
   
     @Override  
     public  void  put(Object key, Object value) {  
         final  String keyf = (String) key;  
         final  Object valuef = value;  
         final  long  liveTime =  86400 ;  
   
         redisTemplate.execute( new  RedisCallback<Long>() {  
             public  Long doInRedis(RedisConnection connection)  throws  DataAccessException {  
                 byte [] keyb = keyf.getBytes();  
                 byte [] valueb = toByteArray(valuef);  
                 connection.set(keyb, valueb);  
                 if  (liveTime >  0 ) {  
                     connection.expire(keyb, liveTime);  
                 }  
                 return  1L;  
             }  
         });  
     }  
   
     @Override  
     public  void  evict(Object key) {  
         final  String keyf = (String) key;  
         redisTemplate.execute( new  RedisCallback<Long>() {  
             public  Long doInRedis(RedisConnection connection)  throws  DataAccessException {  
                 return  connection.del(keyf.getBytes());  
             }  
         });  
     }  
   
     @Override  
     public  void  clear() {  
         redisTemplate.execute( new  RedisCallback<String>() {  
             public  String doInRedis(RedisConnection connection)  throws  DataAccessException {  
                 connection.flushDb();  
                 return  "ok" ;  
             }  
         });  
     }  
   
     /** 
      * 描述 : <Object转byte[]>. <br> 
      * <p> 
      * <使用方法说明> 
      * </p> 
      *  
      * @param obj 
      * @return 
      */  
     private  byte [] toByteArray(Object obj) {  
         byte [] bytes =  null ;  
         ByteArrayOutputStream bos =  new  ByteArrayOutputStream();  
         try  {  
             ObjectOutputStream oos =  new  ObjectOutputStream(bos);  
             oos.writeObject(obj);  
             oos.flush();  
             bytes = bos.toByteArray();  
             oos.close();  
             bos.close();  
         }  catch  (IOException ex) {  
             ex.printStackTrace();  
         }  
         return  bytes;  
     }  
   
     /** 
      * 描述 : <byte[]转Object>. <br> 
      * <p> 
      * <使用方法说明> 
      * </p> 
      *  
      * @param bytes 
      * @return 
      */  
     private  Object toObject( byte [] bytes) {  
         Object obj =  null ;  
         try  {  
             ByteArrayInputStream bis =  new  ByteArrayInputStream(bytes);  
             ObjectInputStream ois =  new  ObjectInputStream(bis);  
             obj = ois.readObject();  
             ois.close();  
             bis.close();  
         }  catch  (IOException ex) {  
             ex.printStackTrace();  
         }  catch  (ClassNotFoundException ex) {  
             ex.printStackTrace();  
         }  
         return  obj;  
     }  
}

使用junit进行测试

  1. package com.layou;  

  2.   

  3. import org.junit.Before;  

  4. import org.junit.Test;  

  5. import org.springframework.beans.factory.annotation.Autowired;  

  6. import org.springframework.cache.CacheManager;  

  7. import org.springframework.test.context.ContextConfiguration;  

  8. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  

  9.   

  10. @ContextConfiguration(locations = {"classpath:applicationContext-cache-redis.xml"})  

  11. public class RedisTest extends AbstractJUnit4SpringContextTests {  

  12.     private RedisCache cache;  

  13.     @Autowired  

  14.     private CacheManager manager;  

  15.       

  16.     @Before  

  17.     public void before() {  

  18.         cache = (RedisCache) manager.getCache("default");  

  19.     }  

  20.       

  21.     @Test  

  22.     public void testAdd() throws Exception {  

  23.         cache.put("test", 1);  

  24.     }  

  25.       

  26.     @Test  

  27.     public void testGet() throws Exception {  

  28.         System.out.println(cache.get("test").get());  

  29.     }  

  30.       

  31.     @Test  

  32.     public void testEvict() throws Exception {  

  33.         cache.evict("test");  

  34.     }  

  35.       

  36.     @Test  

  37.     public void testClear() throws Exception {  

  38.         cache.clear();  

  39.     }  

  40. }

在实际项目中,多是通过Spring的注解完成相关操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package  com.layou;  
   
import  org.springframework.cache.annotation.CacheEvict;  
import  org.springframework.cache.annotation.Cacheable;  
import  org.springframework.stereotype.Service;  
   
@Service  
public  class  RedisAnnotation {  
       
     /** 
      * 第一次查询会到数据库中差寻,第二次就会从缓存中取 
      * #id代表使用参数id 
      * 一定要放在spring容器中管理，不然拦截不到 
      * @param id 
      * @return 
      */  
     @Cacheable (key= "'name' + #id" , value= "default" )  
     public  String getNameById( int  id) {  
         //TODO 进行数据库查询并返回查询数据库内容  
         System.out.println( "查询数据库" );  
         return  ""  + id;  
     }  
       
     /** 
      * 从缓存中删除 
      * @param id 
      */  
     @CacheEvict (key= "'name' + #id" , value= "default" )  
     public  void  deleteById( int  id) {  
         System.out.println( "数据库删除" );  
     }  
}

使用junit进行相关测试










1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package  com.layou;  
   
import  org.junit.Test;  
import  org.springframework.beans.factory.annotation.Autowired;  
import  org.springframework.test.context.ContextConfiguration;  
import  org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
   
@ContextConfiguration (locations = { "classpath:applicationContext-cache-redis.xml" })  
public  class  RedisAnnotationTest  extends  AbstractJUnit4SpringContextTests {  
     @Autowired  
     private  RedisAnnotation redis;  
       
     @Test  
     public  void  testQuery() {  
         //第二次查询的时候就会从缓存中取  
         System.out.println(redis.getNameById( 1 ));  
     }  
       
     @Test  
     public  void  testDelete() {  
         redis.deleteById( 1 );  
     }  
}   











本文转自yunlielai51CTO博客，原文链接：http://blog.51cto.com/4925054/1741066 ，如需转载请自行联系原作者



文章标签：
云数据库 Tair（兼容 Redis）
系统运维管理
Spring
Java
缓存
NoSQL
Redis
关键词：
spring云数据库 Tair（兼容 Redis）
Spring redis
云数据库 Tair（兼容 Redis）缓存
redis缓存
Spring缓存
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
技术小美
目录
相关文章
喵帕斯先生
|
4天前
|
缓存 NoSQL Redis
Redis 缓存使用的实践
《Redis缓存最佳实践指南》涵盖缓存更新策略、缓存击穿防护、大key处理和性能优化。包括Cache Aside Pattern、Write Through、分布式锁、大key拆分和批量操作等技术，帮助你在项目中高效使用Redis缓存。
喵帕斯先生
49 22
Ly001122
|
3天前
|
缓存 NoSQL 中间件
redis高并发缓存中间件总结！
本文档详细介绍了高并发缓存中间件Redis的原理、高级操作及其在电商架构中的应用。通过阿里云的角度，分析了Redis与架构的关系，并展示了无Redis和使用Redis缓存的架构图。文档还涵盖了Redis的基本特性、应用场景、安装部署步骤、配置文件详解、启动和关闭方法、systemctl管理脚本的生成以及日志警告处理等内容。适合初学者和有一定经验的技术人员参考学习。
Ly001122
42 7
mao29955
|
7天前
|
存储 缓存 监控
利用 Redis 缓存特性避免缓存穿透的策略与方法
【10月更文挑战第23天】通过以上对利用 Redis 缓存特性避免缓存穿透的详细阐述，我们对这一策略有了更深入的理解。在实际应用中，我们需要根据具体情况灵活运用这些方法，并结合其他技术手段，共同保障系统的稳定和高效运行。同时，要不断关注 Redis 缓存特性的发展和变化，及时调整策略，以应对不断出现的新挑战。
mao29955
34 10
刘大猫.
|
4天前
|
存储 缓存 Java
Spring缓存注解【@Cacheable、@CachePut、@CacheEvict、@Caching、@CacheConfig】使用及注意事项
Spring缓存注解【@Cacheable、@CachePut、@CacheEvict、@Caching、@CacheConfig】使用及注意事项
刘大猫.
28 2
mao29955
|
7天前
|
缓存 监控 NoSQL
Redis 缓存穿透的检测方法与分析
【10月更文挑战第23天】通过以上对 Redis 缓存穿透检测方法的深入探讨，我们对如何及时发现和处理这一问题有了更全面的认识。在实际应用中，我们需要综合运用多种检测手段，并结合业务场景和实际情况进行分析，以确保能够准确、及时地检测到缓存穿透现象，并采取有效的措施加以解决。同时，要不断优化和改进检测方法，提高检测的准确性和效率，为系统的稳定运行提供有力保障。
mao29955
33 5
mao29955
|
7天前
|
缓存 监控 NoSQL
Redis 缓存穿透及其应对策略
【10月更文挑战第23天】通过以上对 Redis 缓存穿透的详细阐述，我们对这一问题有了更深入的理解。在实际应用中，我们需要根据具体情况综合运用多种方法来解决缓存穿透问题，以保障系统的稳定运行和高效性能。同时，要不断关注技术的发展和变化，及时调整策略，以应对不断出现的新挑战。
mao29955
27 4
磊哥聊Java
|
9天前
|
缓存 NoSQL Java
有Redis为什么还要本地缓存？谈谈你对本地缓存的理解？
有Redis为什么还要本地缓存？谈谈你对本地缓存的理解？
磊哥聊Java
22 0
有Redis为什么还要本地缓存？谈谈你对本地缓存的理解？
东方睿赢
|
16天前
|
缓存 NoSQL Java
Spring Boot与Redis：整合与实战
【10月更文挑战第15天】本文介绍了如何在Spring Boot项目中整合Redis，通过一个电商商品推荐系统的案例，详细展示了从添加依赖、配置连接信息到创建配置类的具体步骤。实战部分演示了如何利用Redis缓存提高系统响应速度，减少数据库访问压力，从而提升用户体验。
东方睿赢
43 2
刘大猫.
|
2天前
|
JavaScript NoSQL Java
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
刘大猫.
19 0
bruce刘晓伟-18435
|
1月前
|
存储 缓存 NoSQL
数据的存储--Redis缓存存储（一）
数据的存储--Redis缓存存储（一）
bruce刘晓伟-18435
67 1

热门文章

最新文章

  • 1
    Windows 下安装和配置 Redis (图文教程)
  • 2
    基于Linux环境安装Redis 6.2.7（超详细）
  • 3
    tomcat session 共享 redis
  • 4
    [Redis]Redis安装与启动(Linux CentOS)
  • 5
    用 Redis 实现延迟队列，我研究了两种方案，发现并不简单 下
  • 6
    为什么redis是单线程的以及为什么这么快？
  • 7
    java Redis工具类
  • 8
    fpm 打包redis3.0.7
  • 9
    php-redis扩展模块安装记录
  • 10
    解决Redis容器使用redis.conf启动失败(1)
  • 1
    MySQL 查询优化：提速查询效率的13大秘籍（索引设计、查询优化、缓存策略、子查询优化以及定期表分析和优化）（中）
    931
  • 2
    【分布式技术专题】「缓存解决方案」一文带领你好好认识一下企业级别的缓存技术解决方案的运作原理和开发实战（多级缓存设计分析）
    148
  • 3
    【深入浅出Spring原理及实战】「缓存Cache开发系列」带你深入分析Spring所提供的缓存Cache功能的开发实战指南（一）
    431
  • 4
    手撸的 SpringBoot缓存系统，性能杠杠的
    51
  • 5
    【C/C++ 性能优化】提高C++程序的缓存命中率以优化性能
    906
  • 6
    HTML5 应用程序缓存
    48
  • 7
    LAMP+Varnish缓存详解（二）——单网站缓存
    37
  • 8
    LAMP+Varnish缓存详解（一）——Varnish简介
    64
  • 9
    缓存淘汰策略
    73
  • 10
    LAMP架构调优（五）——网页缓存设置
    38

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 如何通过数据库Redis内网访问
  • Tair for Redis数据闪回：任意时间点数据恢复
  • 如何开通Redis的专属集群
  • 从零搭建Spring Boot的Hello World
  • 基于Redis实现在线游戏积分排行榜
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月