需求分析：

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

产生问题：

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

解决方法:

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

下载Redis

中国官网：http://redis.cn/
官网： https://redis.io/
github网址：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》

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

需求分析：

产生问题：

解决方法:

下载Redis

在Windows中安装Redis和启动

SpringBoot项目中的pom.xml文件中引入依赖

在application.properties加入redis配置

RedisConfig配置类，其中@EnableCaching开启注解（特别注意，不然redis配置可能不生效）

编写RedisService服务，便于存取数据

使用实例

猜你喜欢

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

需求分析：

产生问题：

解决方法:

下载Redis

在Windows中安装Redis和启动

SpringBoot项目中的pom.xml文件中引入依赖

在application.properties加入redis配置

RedisConfig配置类，其中@EnableCaching开启注解 （特别注意，不然redis配置可能不生效）

编写RedisService服务，便于存取数据

使用实例

猜你喜欢

RedisConfig配置类，其中@EnableCaching开启注解（特别注意，不然redis配置可能不生效）