springboot集成redis 通俗易懂

雨点打透心脏的1/2处 2021-05-16 20:36 631阅读 0赞

1.下载redis以及redis可视化工具的安装包

链接（[https://download.csdn.net/download/qq\_27081015/12005531][https_download.csdn.net_download_qq_27081015_12005531]）

默认安装就可以了

2.导入redis在springboot的相关依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.6.0</version>
    </dependency>

3. 在yaml文件中添加配置

spring:
      redis:
        database: 0
    #    cluster:  
    #      nodes:
    #        - 127.0.0.1:6379 如果是redis集群 则新加  格式为 - host：port
        #    jedis:
        lettuce:
          pool:
            # 连接池中的最大空闲连接 默认8
            max-idle: 8
            # 连接池中的最小空闲连接 默认0
            min-idle: 0
            # 连接池最大连接数 默认8 ，负数表示没有限制
            max-active: 8
            # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认-1
            max-wait: -1
        timeout: 30000
        host: 127.0.0.1  #如果是集群则注释掉当前host与port
        port: 6379

4 .添加redis工具类（也可不添加 直接使用）@Autowired private StringRedisTemplate redisTemplate;

package com.hanhuide.hhde.utils;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.util.HashMap;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @program: maven
     * @description: redis工具类
     * @author: 韩惠德
     * @create: 2019-11-29 14:23
     * @version: 1.0
     **/
    @Component
    public class RedisUtil {
    
        @Value("${jwt.token.expirationSeconds}")
        private int expirationSeconds;
    
        /*常量，各种实现方式都行，这里读取application.yml*/
        @Value("${jwt.token.validTime}")
        private int validTime;
    
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        /**
         * 查询key,支持模糊查询
         *
         * @param key 传过来时key的前后端已经加入了*，或者根据具体处理
         */
        public Set<String> keys(String key) {
            return redisTemplate.keys(key);
        }
    
        /**
         * 字符串获取值
         *
         * @param key
         */
        public Object get(String key) {
            return redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 字符串存入值
         * 默认过期时间为2小时
         *
         * @param key
         */
        public void set(String key, String value) {
            redisTemplate.opsForValue().set(key, value, 7200, TimeUnit.SECONDS);
        }
    
        /**
         * 字符串存入值
         *
         * @param expire 过期时间（毫秒计）
         * @param key
         */
        public void set(String key, String value, Integer expire) {
            redisTemplate.opsForValue().set(key, value, expire, TimeUnit.SECONDS);
        }
    
        /**
         * 删出key
         * 这里跟下边deleteKey（）最底层实现都是一样的，应该可以通用
         *
         * @param key
         */
        public void delete(String key) {
            redisTemplate.opsForValue().getOperations().delete(key);
        }
    
        /**
         * 添加单个
         * 默认过期时间为两小时
         *
         * @param key    key
         * @param filed  filed
         * @param domain 对象
         */
        public void hset(String key, String filed, Object domain) {
            redisTemplate.opsForHash().put(key, filed, domain);
        }
    
        /**
         * 添加单个
         *
         * @param key    key
         * @param filed  filed
         * @param domain 对象
         * @param expire 过期时间（毫秒计）
         */
        public void hset(String key, String filed, Object domain, Integer expire) {
            redisTemplate.opsForHash().put(key, filed, domain);
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    
        /**
         * 添加HashMap
         *
         * @param key key
         * @param hm  要存入的hash表
         */
        public void hset(String key, HashMap<String, Object> hm) {
            redisTemplate.opsForHash().putAll(key, hm);
        }
    
        /**
         * 如果key存在就不覆盖
         *
         * @param key
         * @param filed
         * @param domain
         */
        public void hsetAbsent(String key, String filed, Object domain) {
            redisTemplate.opsForHash().putIfAbsent(key, filed, domain);
        }
    
        /**
         * 查询key和field所确定的值
         *
         * @param key   查询的key
         * @param field 查询的field
         * @return HV
         */
        public Object hget(String key, String field) {
            return redisTemplate.opsForHash().get(key, field);
        }
    
        /**
         * 查询该key下所有值
         *
         * @param key 查询的key
         * @return Map<HK, HV>
         */
        public Object hget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * 删除key下所有值
         *
         * @param key 查询的key
         */
        public void deleteKey(String key) {
            redisTemplate.opsForHash().getOperations().delete(key);
        }
    
        /**
         * 判断key和field下是否有值
         *
         * @param key   判断的key
         * @param field 判断的field
         */
        public Boolean hasKey(String key, String field) {
            return redisTemplate.opsForHash().hasKey(key, field);
        }
    
        /**
         * 判断key下是否有值
         *
         * @param key 判断的key
         */
        public Boolean hasKey(String key) {
            return redisTemplate.opsForHash().getOperations().hasKey(key);
        }
    
        /**
         * 判断此token是否在黑名单中
         *
         * @param token
         * @return
         */
        public Boolean isBlackList(String token) {
            return hasKey("blacklist", token);
        }
    
        /**
         * 将token加入到redis黑名单中
         *
         * @param token
         */
        public void addBlackList(String token) {
            hset("blacklist", token, "true");
        }
    
    
        /**
         * 查询token下的刷新时间
         *
         * @param token 查询的key
         * @return HV
         */
        public Object getTokenValidTimeByToken(String token) {
            return redisTemplate.opsForHash().get(token, "tokenValidTime");
        }
    
        /**
         * 查询token下的刷新时间
         *
         * @param token 查询的key
         * @return HV
         */
        public Object getUsernameByToken(String token) {
            return redisTemplate.opsForHash().get(token, "username");
        }
    
        /**
         * 查询token下的刷新时间
         *
         * @param token 查询的key
         * @return HV
         */
        public Object getIPByToken(String token) {
            return redisTemplate.opsForHash().get(token, "ip");
        }
    
        /**
         * 查询token下的过期时间
         *
         * @param token 查询的key
         * @return HV
         */
        public Object getExpirationTimeByToken(String token) {
            return redisTemplate.opsForHash().get(token, "expirationTime");
        }
    
        public void setTokenRefresh(String token, String username, String ip) {
            //刷新时间
            Integer expire = validTime * 24 * 60 * 60 * 1000;
    
            hset(token, "tokenValidTime", DateUtil.getAddDayTime(validTime), expire);
            hset(token, "expirationTime", DateUtil.getAddDaySecond(expirationSeconds), expire);
            hset(token, "username", username, expire);
            hset(token, "ip", ip, expire);
        }
    }

5. 新建controller 测试redis是否连接成功

package com.hanhuide.hhde.controller;
    
    import com.hanhuide.hhde.utils.RedisUtil;
    import com.hanhuide.hhde.utils.ResultUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Map;
    
    /**
     * @program: maven
     * @description: 测试redis集群
     * @author: 韩惠德
     * @create: 2019-11-29 15:49
     * @version: 1.0
     **/
    @RestController
    @RequestMapping("redis")
    public class RedisController {
        @Autowired
        private RedisUtil redisUtil;
    
        @PostMapping("index")
        public Map<String, Object> ceshiRedis() {
            redisUtil.set("测试", "dlfdsjfldsjfldsjfldsjfldsjflsdjf");
            return ResultUtil.success();
        }
    }

6. 测试

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3MDgxMDE1_size_16_color_FFFFFF_t_70][]

7. 打开redis可视化工具

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3MDgxMDE1_size_16_color_FFFFFF_t_70 1][]

[https_download.csdn.net_download_qq_27081015_12005531]: https://download.csdn.net/download/qq_27081015/12005531
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3MDgxMDE1_size_16_color_FFFFFF_t_70]: /images/20210516/04fabf959fe04be4abdfcf0ef56a43ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3MDgxMDE1_size_16_color_FFFFFF_t_70 1]: /images/20210516/efe94444aa5e4647aa2be295557fe0cf.png