个人中心
gpt4 book ai didi

java若依框架集成redis缓存详解

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 28 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章java若依框架集成redis缓存详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、添加依赖

ruoyi-common\pom.xml模块添加整合依赖 。

?
1
2
3
4
5
6
7
8
9
10
<!-- springboot整合redis -->
< dependency >
     < groupId >org.springframework.boot</ groupId >
     < artifactId >spring-boot-starter-data-redis</ artifactId >
</ dependency >
<!-- 阿里JSON解析器 -->
< dependency >
     < groupId >com.alibaba</ groupId >
     < artifactId >fastjson</ artifactId >
</ dependency >

2、修改配置

ruoyi-admin目录下的application-druid.yml，添加redis配置 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 数据源配置
spring:
     # redis配置
     redis:
       database: 0
       host: 127.0 . 0.1
       port: 6379
       password:
       timeout: 6000ms           # 连接超时时长（毫秒）
       lettuce:
         pool:
           max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
           max-wait: -1ms    # 连接池最大阻塞等待时间（使用负值表示没有限制）
           max-idle: 10      # 连接池中的最大空闲连接
           min-idle: 5       # 连接池中的最小空闲连接

3、增加配置

ruoyi-framework目录下的config文件里，增加RedisConfig.java和FastJson2JsonRedisSerializer.java类 。

?
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
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
  * redis配置
  *
  * @author YangPC
  */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
     @Bean
     @SuppressWarnings (value = { "unchecked" , "rawtypes" })
     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
         RedisTemplate<Object, Object> template = new RedisTemplate<>();
         template.setConnectionFactory(connectionFactory);
         FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object. class );
         ObjectMapper mapper = new ObjectMapper();
         mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
         mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
         serializer.setObjectMapper(mapper);
         // 使用StringRedisSerializer来序列化和反序列化redis的key值
         template.setKeySerializer( new StringRedisSerializer());
         template.setValueSerializer(serializer);
         // Hash的key也采用StringRedisSerializer的序列化方式
         template.setHashKeySerializer( new StringRedisSerializer());
         template.setHashValueSerializer(serializer);
         template.afterPropertiesSet();
         return template;
     }
}
?
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
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;
import java.nio.charset.Charset;
/**
  * Redis使用FastJson序列化
  *
  * @author YangPC
  */
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{
     @SuppressWarnings ( "unused" )
     private ObjectMapper objectMapper = new ObjectMapper();
     public static final Charset DEFAULT_CHARSET = Charset.forName( "UTF-8" );
     private Class<T> clazz;
     static
     {
         ParserConfig.getGlobalInstance().setAutoTypeSupport( true );
     }
     public FastJson2JsonRedisSerializer(Class<T> clazz)
     {
         super ();
         this .clazz = clazz;
     }
     @Override
     public byte [] serialize(T t) throws SerializationException
     {
         if (t == null )
         {
             return new byte [ 0 ];
         }
         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
     }
     @Override
     public T deserialize( byte [] bytes) throws SerializationException
     {
         if (bytes == null || bytes.length <= 0 )
         {
             return null ;
         }
         String str = new String(bytes, DEFAULT_CHARSET);
         return JSON.parseObject(str, clazz);
     }
     public void setObjectMapper(ObjectMapper objectMapper)
     {
         Assert.notNull(objectMapper, "'objectMapper' must not be null" );
         this .objectMapper = objectMapper;
     }
     protected JavaType getJavaType(Class<?> clazz)
     {
         return TypeFactory.defaultInstance().constructType(clazz);
     }
}

4、增加工具类

ruoyi-common模块下utils里面新增RedisCache.java类，有利于提高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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
  * spring redis 工具类
  *
  * @author YangPC
  **/
@SuppressWarnings (value = { "unchecked" , "rawtypes" })
@Component
public class RedisCache {
     @Autowired
     public RedisTemplate redisTemplate;
     /**
      * 缓存基本的对象，Integer、String、实体类等
      *
      * @param key   缓存的键值
      * @param value 缓存的值
      */
     public <T> void setCacheObject( final String key, final T value) {
         redisTemplate.opsForValue().set(key, value);
     }
     /**
      * 缓存基本的对象，Integer、String、实体类等
      *
      * @param key      缓存的键值
      * @param value    缓存的值
      * @param timeout  时间
      * @param timeUnit 时间颗粒度
      */
     public <T> void setCacheObject( final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
     }
     /**
      * 设置有效时间
      *
      * @param key     Redis键
      * @param timeout 超时时间
      * @return true=设置成功；false=设置失败
      */
     public boolean expire( final String key, final long timeout) {
         return expire(key, timeout, TimeUnit.SECONDS);
     }
     /**
      * 设置有效时间
      *
      * @param key     Redis键
      * @param timeout 超时时间
      * @param unit    时间单位
      * @return true=设置成功；false=设置失败
      */
     public boolean expire( final String key, final long timeout, final TimeUnit unit) {
         return redisTemplate.expire(key, timeout, unit);
     }
     /**
      * 获得缓存的基本对象。
      *
      * @param key 缓存键值
      * @return 缓存键值对应的数据
      */
     public <T> T getCacheObject( final String key) {
         ValueOperations<String, T> operation = redisTemplate.opsForValue();
         return operation.get(key);
     }
     /**
      * 删除单个对象
      *
      * @param key
      */
     public boolean deleteObject( final String key) {
         return redisTemplate.delete(key);
     }
     /**
      * 删除集合对象
      *
      * @param collection 多个对象
      * @return
      */
     public long deleteObject( final Collection collection) {
         return redisTemplate.delete(collection);
     }
     /**
      * 缓存List数据
      *
      * @param key      缓存的键值
      * @param dataList 待缓存的List数据
      * @return 缓存的对象
      */
     public <T> long setCacheList( final String key, final List<T> dataList) {
         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
         return count == null ? 0 : count;
     }
     /**
      * 获得缓存的list对象
      *
      * @param key 缓存的键值
      * @return 缓存键值对应的数据
      */
     public <T> List<T> getCacheList( final String key) {
         return redisTemplate.opsForList().range(key, 0 , - 1 );
     }
     /**
      * 缓存Set
      *
      * @param key     缓存键值
      * @param dataSet 缓存的数据
      * @return 缓存数据的对象
      */
     public <T> BoundSetOperations<String, T> setCacheSet( final String key, final Set<T> dataSet) {
         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
         Iterator<T> it = dataSet.iterator();
         while (it.hasNext()) {
             setOperation.add(it.next());
         }
         return setOperation;
     }
     /**
      * 获得缓存的set
      *
      * @param key
      * @return
      */
     public <T> Set<T> getCacheSet( final String key) {
         return redisTemplate.opsForSet().members(key);
     }
     /**
      * 缓存Map
      *
      * @param key
      * @param dataMap
      */
     public <T> void setCacheMap( final String key, final Map<String, T> dataMap) {
         if (dataMap != null ) {
             redisTemplate.opsForHash().putAll(key, dataMap);
         }
     }
     /**
      * 获得缓存的Map
      *
      * @param key
      * @return
      */
     public <T> Map<String, T> getCacheMap( final String key) {
         return redisTemplate.opsForHash().entries(key);
     }
     /**
      * 往Hash中存入数据
      *
      * @param key   Redis键
      * @param hKey  Hash键
      * @param value 值
      */
     public <T> void setCacheMapValue( final String key, final String hKey, final T value) {
         redisTemplate.opsForHash().put(key, hKey, value);
     }
     /**
      * 获取Hash中的数据
      *
      * @param key  Redis键
      * @param hKey Hash键
      * @return Hash中的对象
      */
     public <T> T getCacheMapValue( final String key, final String hKey) {
         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
         return opsForHash.get(key, hKey);
     }
     /**
      * 获取多个Hash中的数据
      *
      * @param key   Redis键
      * @param hKeys Hash键集合
      * @return Hash对象集合
      */
     public <T> List<T> getMultiCacheMapValue( final String key, final Collection<Object> hKeys) {
         return redisTemplate.opsForHash().multiGet(key, hKeys);
     }
     /**
      * 获得缓存的基本对象列表
      *
      * @param pattern 字符串前缀
      * @return 对象列表
      */
     public Collection<String> keys( final String pattern) {
         return redisTemplate.keys(pattern);
     }
 
     /**
      * 判断Key是否存在
      *
      * @param key
      * @return
      */
     public boolean hasKey(String key) {
         return redisTemplate.hasKey(key);
     }
     /**
      * 清除缓存(自定义)
      */
     public void cleanCache() {
         List<String> keys = new ArrayList<>();
         redisTemplate.delete(keys);
     }
}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我的更多内容！ 。

原文链接：https://blog.csdn.net/qq_19309473/article/details/119923279 。

最后此篇关于java若依框架集成redis缓存详解的文章就讲到这里了,如果你想了解更多关于java若依框架集成redis缓存详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

28 4 0
文章推荐： System.Data.OleDb.OleDbException: 未指定的错误的完美解决方法
文章推荐： Django模型序列化返回自然主键值示例代码
文章推荐： pandas实现将dataframe满足某一条件的值选出
文章推荐： 微信删除的视频还能找回来吗 微信删除的视频怎么恢复
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com