博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
spring整合redis缓存
阅读量:5990 次
发布时间:2019-06-20

本文共 10445 字,大约阅读时间需要 34 分钟。

如果对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
,如需转载请自行联系原作者

你可能感兴趣的文章
深入TCP/IP协议---网络层详解(1)
查看>>
浏览器闪烁页面标题进行提醒(转载)
查看>>
徒手生撸教你如何解锁React-Native史诗级成就“Hello World”
查看>>
click事件的累加及解决方式
查看>>
「docker实战篇」python的docker爬虫技术-fiddler抓包工具(三)
查看>>
【今日头条】【抖音&火山】算法实习生
查看>>
java流的中间操作源码解析
查看>>
Android开发 - 掌握ConstraintLayout(二)介绍
查看>>
EOS开发完全解析(一):Ubuntu上搭建EOS开发环境
查看>>
安全研究人员:可绕过Gatekeeper安全机制macOS漏洞
查看>>
Facebook 与 150 家企业共享用户数据,且未告知用户
查看>>
百度iOS面试
查看>>
Python基础教程:Day15-图像和办公文档处理
查看>>
Bytom设计结构解读
查看>>
比原链合约入门教程
查看>>
条码插件TBarCode Office系列教程三(Excel Add-In篇)
查看>>
微软随用随付供Azure成本管理服务
查看>>
数据库管理系统Microsoft SQL Server 2019(预览版)发布!
查看>>
Android 音视频录制硬编码实现
查看>>
从裂变到成为产品的增长黑客,我们又破了纪录:4天增长1万用户
查看>>