spring整合redis缓存

最新推荐文章于 2022-08-02 09:05:47 发布
置顶 最新推荐文章于 2022-08-02 09:05:47 发布
阅读量256 收藏 1
点赞数

如果对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 );  
     }  
}
李文
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Spring体系中使用redis.spring集成redis缓存
01-07
在Spring体系中使用redis.zip spring集成redis缓存
Spring与Redis的整合&&Redis注解式缓存以及Redis雪崩等问题的解决
qq_63492318的博客
10-28 1403
Spring整合Redis步骤、redis注解缓存的三种使用、redis击穿、穿透、雪崩现象以及其解决方案。。。
【SpringBoot整合缓存】-----spring-boot-starter-cache篇
Learning_xzj的博客
06-28 7169
缓存在企业级应用主要作用是信息处理，当需要读取数据时，由于受限于数据库的访问效率，导致整体系统性能偏低。 ​ 应用程序直接与数据库打交道，访问效率低​ 为了改善上述现象，开发者通常会在应用程序与数据库之间建立一种临时的数据存储机制，该区域中的数据在内存中保存，读写速度较快，可以有效解决数据库访问效率低下的问题。这一块临时存储数据的区域就是缓存。使用缓存后，应用程序与缓存打交道，缓存与数据库打交道，数据访问效率提高。​ 缓存是什么？缓存是一种介于数据永久存储
SpringBoot整合Redis缓存
m0_67402774的博客
08-02 1374
Redis是一个高性能的Key-Value开源数据库，是一个非关系型的数据库，是为了解决高并发、高扩展，大数据存储等一系列的问题而产生的数据库解决方案。但它不能替代关系型数据库，只能作为特定环境下的扩充。...
Redis 缓存 + Spring 的集成示例
热门推荐
Defonds 的专栏
09-24 18万+
《整合 spring 4(包括mvc、context、orm) + mybatis 3 示例》一文简要介绍了最新版本的 Spring MVC、IOC、MyBatis ORM 三者的整合以及声明式事务处理。现在我们需要把缓存也整合进来，缓存我们选用的是 Redis，本文将在该文示例基础上介绍 Redis 缓存 + Spring 的集成。关于 Redis 服务器的搭建请参考博客《Redhat5.8 环
Spring集成Redis进行数据缓存
02-22
SpringMVC集成Redis进行缓存管理，SpringMVC基于接口编程的实例，从代码中学习Spring是怎么集成缓存。
spring整合redis实现数据缓存的实例代码
08-26
主要介绍了spring整合redis实现数据缓存,需要的朋友可以参考下
集成Spring Redis缓存的实现
08-26
今天小编就为大家分享一篇关于集成Spring Redis缓存的实现，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
SpringCloud整合Redis
06-19
SpringCloud整合Redis缓存；版本：SpringCloud ：Dalston.SR4；SpringBoot：1.5.14.RELEASE；Redis:3.2.0;Maven :3.5.3.代码下载下来即可用
Spring整合Redis用作缓存-注解方式
03-02
博客http://blog.csdn.net/poorcoder_/article/details/59541710的代码。主要描述spring通过注解整合redis用作缓存的实例。
spring整合redis做缓存用注解实现的完整例子
11-26
spring整合redis做缓存用注解实现的完整例子,带jar包，可以直接运行
spring整合redis缓存配置
zl386119974的专栏
02-17 1767
2.conf-base-redis-local.properties配置 #redis\u7684\u670d\u52a1\u5668\u5730\u5740 redis.host=127.0.0.1 #redis\u7684\u670d\u52a1\u7aef\u53e3 redis.port=6379 #\u5bc6\u7801 redis.pass=test123 #\u94f
spring结合redis如何实现数据的缓存
yanchenbin88的专栏
11-10 1795
spring结合redis如何实现数据的缓存 1. 实现目标 　　通过redis缓存数据字典表的数据。（目的不是加快查询的速度，而是减少数据库的负担）　　 2. 所需jar包 　 　　注意：jdies和commons-pool两个jar的版本是有对应关系的，注意引入jar包是要配对使用，否则将会报错。因为commons-pooljar的目录根据版本的变化，目录结构
Spring整合Redis缓存
lw7551的博客
03-08 436
通常而言目前的数据库分类有几种，包括 SQL/NSQL,，关系数据库，键值数据库等等 等，分类的标准也不以，Redis本质上也是一种键值数据库的，但它在保持键值数据库简单快捷特点的同时，又吸收了部分关系数据库的优点。从而使它的位置处于关系数据库和键值数 据库之间。Redis不仅能保存Strings类型的数据，还能保存Lists类型（有序）和Sets类型（无序）的数据，而且还能完成排序（SORT
Spring集成Redis实现缓存实践
pengl的专栏
09-06 1万+
在我们所编写的应用中，很多请求总是会一遍遍地去获取一些相同的数据，因为这些数据是无状态的，所以当请求任务完成后，就会立马丢掉所获取的数据，在这些数据中，有些是需要时间去数据库获取，或者远程接口调用获取，或执行复杂运算得到。如果这部分数据变化不那么频繁，或者压根不会变化，那我们何必要每次都去加载呢。 在web应用中，缓存是一门必备的技能，只要有需要优化的地方，我们首先会想到
Spring cache+ redis与redis 的比较
谭倩倩
01-20 8707
1. 缓存级别不同     Spring cache是代码级的缓存，他一般是使用一个ConcurrentMap。也就是说实际上还是是使用JVM的内存来缓存对象的，     那么肯定会造成大量的内存消耗。但是使用方便。     Redis 作为一个缓存服务器，是内存级的缓存。它是使用单纯的内存来进行缓存。 2. sprirng cache的好处     那么Sp
杭州电子科技大学数据结构(题目).pdf
最新发布
04-26
杭州电子科技大学，期末考试资料，计算机专业期末考试试卷，试卷及答案，数据结构。
spring boot添加redis缓存
09-03
Spring Boot 可以通过集成Spring Data Redis来添加Redis缓存。Spring Data Redis是Spring提供的一个用于操作Redis的开源库。要添加Redis缓存，可以按照以下几个步骤进行操作。 第一步，添加依赖： 在pom.xml文件中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值