SpringBoot集成Redis解决集群共享缓存问题

需求分析：


应用程序采用集成的方式部署在3台服务器上，每台服务器上应用请求同一台数据库服务器，应用程序中获取当前用户信息是从当前服务器上选取的，当前台发送求后需在后台修改当前用户的相关属性，然后查询当前属性下的一些数据信息

产生问题：


采用集成的方式部署，会导致当前修改请求发送到其中一台服务器上，该台服务器上的用户信息修改了，而其他服务器的用户信息并没有修改，当下一次的请求发送到的是另一个服务器，再查询数据时，查询到的数据并不是根据修改后属性下的数据信息

解决方法:


通过部署redis，将当前用户信息存储在Redis上，几台服务器共同连接一个Redis，获取当前用户信息时，从Redis中获取，因Redis是一个高性能的key-value数据库，避免了修改从传统的关系型数据库存取值，可以提高性能
SpringBoot中集成Redis
下面详细描述一下在SpringBoot中集成Redis的步骤，以及当中踩到的坑

下载Redis

中国官网：http://redis.cn/ <http://redis.cn/>
官网： https://redis.io/ <https://redis.io/>
github网址：https://github.com/antirez/redis <https://github.com/antirez/redis>
可以通过如下方式，下载相应版本


在Windows中安装Redis和启动

本人下载版本为Redis-x64-2.8.2402，存放路径D:\BaiduNetdiskDownload\Redis-x64-2.8.2402
在当前文件加下，打开cmd命令，输入命令：redis-server redis.windows.conf
遇到的问题：

解决办法：redis-server redis.windows.conf –maxmemory 200m
正确启动后界面：


SpringBoot项目中的pom.xml文件中引入依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>
spring-boot-starter-redis</artifactId> </dependency>
在application.properties加入redis配置
# Redis数据库索引（默认为0） spring.redis.database=0 # Redis服务器地址
#spring.redis.host=10.28.124.201 spring.redis.host=10.0.11.210 # Redis服务器连接端口
spring.redis.port=6379 # Redis服务器连接密码（默认为空） spring.redis.password= #
连接池最大连接数（使用负值表示没有限制） spring.redis.pool.max-active=8 # 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1 # 连接池中的最大空闲连接 spring.redis.pool.max-idle=8 #
连接池中的最小空闲连接 spring.redis.pool.min-idle=0 # 连接超时时间（毫秒） spring.redis.timeout=0
RedisConfig配置类，其中@EnableCaching开启注解 （特别注意，不然redis配置可能不生效）
import org.springframework.cache.CacheManager; 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.cache.RedisCacheManager;import
org.springframework.data.redis.connection.RedisConnectionFactory;import
org.springframework.data.redis.connection.jedis.JedisConnectionFactory;import
org.springframework.data.redis.core.RedisTemplate;import
org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
/** * 〈Redis配置〉 * @author * @create 2018/6/4 * @since 1.0.0 */ @Configuration
@EnableCaching//开启缓存 public class RedisConfig extends CachingConfigurerSupport{
@Bean public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
CacheManager cacheManager =new RedisCacheManager(redisTemplate); return
cacheManager; }@Bean public RedisTemplate<String, String> redisTemplate
(RedisConnectionFactory factory) { RedisTemplate<String, String> redisTemplate =
new RedisTemplate<String, String>();
redisTemplate.setConnectionFactory(factory);return redisTemplate; } }
编写RedisService服务，便于存取数据
import org.springframework.beans.factory.annotation.Autowired; import
org.springframework.data.redis.core.*;import
org.springframework.stereotype.Component;import java.io.Serializable; import
java.util.List;import java.util.Set; import java.util.concurrent.TimeUnit; /**
* 〈Redis操作类〉 * @author * @create 2018/6/5 * @since 1.0.0 */ @Component public
class RedisService { @Autowired private RedisTemplate redisTemplate; /** * 写入缓存
* @param key * @param value * @return */ public boolean set(final String key,
Object value) {boolean result = false; try { ValueOperations operations =
redisTemplate.opsForValue(); operations.set(key, value); result =true; } catch
(Exception e) { e.printStackTrace(); }return result; } /** * 写入缓存设置时效时间 * @param
key * @param value * @return */ public boolean set(final String key, Object
value, Long expireTime) {boolean result = false; try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value); redisTemplate.expire(key, expireTime,
TimeUnit.SECONDS); result =true; } catch (Exception e) { e.printStackTrace(); }
return result; } /** * 批量删除对应的value * @param keys */ public void remove(final
String... keys) {for (String key : keys) { remove(key); } } /** * 批量删除key *
@param pattern */ public void removePattern(final String pattern) {
Set<Serializable> keys = redisTemplate.keys(pattern);if (keys.size() > 0)
redisTemplate.delete(keys); }/** * 删除对应的value * @param key */ public void remove
(final String key) { if (exists(key)) { redisTemplate.delete(key); } } /** *
判断缓存中是否有对应的value * @param key * @return */ public boolean exists(final String
key) {return redisTemplate.hasKey(key); } /** * 读取缓存 * @param key * @return */
public Object get(final String key) { Object result = null;
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
result = operations.get(key);return result; } /** * 哈希 添加 * @param key * @param
hashKey * @param value */ public void hmSet(String key, Object hashKey, Object
value){ HashOperations<String, Object, Object> hash =
redisTemplate.opsForHash(); hash.put(key,hashKey,value); }/** * 哈希获取数据 * @param
key * @param hashKey * @return */ public Object hmGet(String key, Object
hashKey){ HashOperations<String, Object, Object> hash =
redisTemplate.opsForHash();return hash.get(key,hashKey); } /** * 列表添加 * @param
k * @param v */ public void lPush(String k,Object v){ ListOperations<String,
Object> list = redisTemplate.opsForList(); list.rightPush(k,v); }/** * 列表获取 *
@param k * @param l * @param l1 * @return */ public List<Object> lRange(String
k,long l, long l1){ ListOperations<String, Object> list =
redisTemplate.opsForList();return list.range(k,l,l1); } /** * 集合添加 * @param key
* @param value */ public void add(String key,Object value){
SetOperations<String, Object> set = redisTemplate.opsForSet();
set.add(key,value); }/** * 集合获取 * @param key * @return */ public Set<Object>
setMembers(String key){ SetOperations<String, Object> set =
redisTemplate.opsForSet();return set.members(key); } /** * 有序集合添加 * @param key *
@param value * @param scoure */ public void zAdd(String key,Object value,double
scoure){ ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
zset.add(key,value,scoure); }/** * 有序集合获取 * @param key * @param scoure * @param
scoure1 * @return */ public Set<Object> rangeByScore(String key,double scoure,
double scoure1){ ZSetOperations<String, Object> zset =
redisTemplate.opsForZSet();return zset.rangeByScore(key, scoure, scoure1); } }
使用实例
@RestController @RequestMapping public class LoginController { @Resource
RedisService redisService;@RequestMapping("login") @ResponseBody public Result
login(@RequestBody Map<String, Object> param, HttpServletResponse response,
HttpSession session) { String account = param.get("userName").toString();
redisService.remove("account");//若存在，则删除 redisService.set("account"，account);
//设置 redisService.get("account");//获取 return ResultTool.successData(account); }
}
关于redis的集成，本文主要参考的了《SpringBoot整合Redis <https://www.dalaoyang.cn/article/32>》

• « 上一篇：这4个Python实战项目，让你瞬间读懂Python！
• » 下一篇：ELK+FileBeat日志分析系统