springboot2.x集成redis進行緩存管理

首先需要聲明下，這個是我看了很多人的博客改的，有些是直接粘貼的idea中的，後來想記錄下，但是已經找不到我參考的那些博客在哪了，所有這裏就選擇了原創，其中有一大部分並非原創，若有侵權，請聯繫不公開該文章。

引入依賴的pom文件

需要引入commons-pool2作爲連接池管理，使用lettuce連接池

<!--集成redis-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
    </dependency>

yml中的配置

spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    password: 123456
    lettuce:
      pool:
        # 連接池中的最大空閒連接 默認8
        max-idle: 8
        # 連接池中的最小空閒連接 默認0
        min-idle: 0
        # 連接池最大連接數 默認8 ，負數表示沒有限制
        max-active: 8
        # 連接池最大阻塞等待時間（使用負值表示沒有限制） 默認-1
        max-wait: -1ms

添加redis的配置文件

package com.imserver.config.redis;

import java.time.Duration;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @description: redis配置文件
 * @author: monkey.G
 * @create: 2020-04-18 10:20
 **/
@Configuration
public class RedisConfig {

  @SuppressWarnings("rawtypes")
  @Bean
  public CacheManager cacheManager(LettuceConnectionFactory redisConnectionFactory) {
    RedisCacheConfiguration redisCacheConfiguration=RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofDays(3));
    return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
        .cacheDefaults(redisCacheConfiguration).build();
  }

  /**
   * springboot2.x 使用LettuceConnectionFactory 代替 RedisConnectionFactory
   * application.yml配置基本信息後,springboot2.x  RedisAutoConfiguration能夠自動裝配
   * LettuceConnectionFactory 和 RedisConnectionFactory 及其 RedisTemplate
   * @param redisConnectionFactory
   * @return
   */
  @Bean
  public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory){
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    redisTemplate.setConnectionFactory(redisConnectionFactory);
    return redisTemplate;
  }
}

通用redis工具類

package com.imserver.config.redis;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
/**
 * @description: redis的工具欄
 * @author: monkey.G
 * @create: 2020-04-18 10:40
 **/

@Component
public final class RedisUtilService {
  @Autowired
  private RedisTemplate<String, Object> redisTemplate;
  @Autowired
  private StringRedisTemplate stringRedisTemplate;
  // =============================common============================

  public void evitCache(String value,String keyPatten){
    Set<String> keys = this.keys(value+"::"+keyPatten);
    this.del(keys.toArray(new String[keys.size()]));
  }
  /**
   * 根據通配符查找key值
   * @param pattern
   * @return
   */
  public Set<String> keys(String pattern){
    try {
      return stringRedisTemplate.keys(pattern);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   * 指定緩存失效時間
   * @param key 鍵
   * @param time 時間(秒)
   * @return
   */
  public boolean expire(String key, long time) {
    try {
      if (time > 0) {
        redisTemplate.expire(key, time, TimeUnit.SECONDS);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 根據key 獲取過期時間
   * @param key 鍵 不能爲null
   * @return 時間(秒) 返回0代表爲永久有效
   */
  public long getExpire(String key) {
    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  }
  /**
   * 判斷key是否存在
   * @param key 鍵
   * @return true 存在 false不存在
   */
  public boolean hasKey(String key) {
    try {
      return redisTemplate.hasKey(key);
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 刪除緩存
   * @param key 可以傳一個值 或多個
   */
  @SuppressWarnings("unchecked")
  public void del(String... key) {
    if (key != null && key.length > 0) {
      if (key.length == 1) {
        redisTemplate.delete(key[0]);
      } else {
        redisTemplate.delete(CollectionUtils.arrayToList(key));
      }
    }
  }
  // ============================String=============================
  /**
   * 普通緩存獲取
   * @param key 鍵
   * @return 值
   */
  public Object get(String key) {
    return key == null ? null : redisTemplate.opsForValue().get(key);
  }
  /**
   * 普通緩存放入
   * @param key 鍵
   * @param value 值
   * @return true成功 false失敗
   */
  public boolean set(String key, Object value) {
    try {
      redisTemplate.opsForValue().set(key, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 普通緩存放入並設置時間
   * @param key 鍵
   * @param value 值
   * @param time 時間(秒) time要大於0 如果time小於等於0 將設置無限期
   * @return true成功 false 失敗
   */
  public boolean set(String key, Object value, long time) {
    try {
      if (time > 0) {
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
      } else {
        set(key, value);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 遞增
   * @param key 鍵
   * @param delta 要增加幾(大於0)
   * @return
   */
  public long incr(String key, long delta) {
    if (delta < 0) {
      throw new RuntimeException("遞增因子必須大於0");
    }
    return redisTemplate.opsForValue().increment(key, delta);
  }
  /**
   * 遞減
   * @param key 鍵
   * @param delta 要減少幾(小於0)
   * @return
   */
  public long decr(String key, long delta) {
    if (delta < 0) {
      throw new RuntimeException("遞減因子必須大於0");
    }
    return redisTemplate.opsForValue().increment(key, -delta);
  }
  // ================================Map=================================
  /**
   * HashGet
   * @param key 鍵 不能爲null
   * @param item 項 不能爲null
   * @return 值
   */
  public Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
  }
  /**
   * 獲取hashKey對應的所有鍵值
   * @param key 鍵
   * @return 對應的多個鍵值
   */
  public Map<Object, Object> hmget(String key) {
    return redisTemplate.opsForHash().entries(key);
  }
  /**
   * HashSet
   * @param key 鍵
   * @param map 對應多個鍵值
   * @return true 成功 false 失敗
   */
  public boolean hmset(String key, Map<String, Object> map) {
    try {
      redisTemplate.opsForHash().putAll(key, map);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * HashSet 並設置時間
   * @param key 鍵
   * @param map 對應多個鍵值
   * @param time 時間(秒)
   * @return true成功 false失敗
   */
  public boolean hmset(String key, Map<String, Object> map, long time) {
    try {
      redisTemplate.opsForHash().putAll(key, map);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 向一張hash表中放入數據,如果不存在將創建
   * @param key 鍵
   * @param item 項
   * @param value 值
   * @return true 成功 false失敗
   */
  public boolean hset(String key, String item, Object value) {
    try {
      redisTemplate.opsForHash().put(key, item, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 向一張hash表中放入數據,如果不存在將創建
   * @param key 鍵
   * @param item 項
   * @param value 值
   * @param time 時間(秒) 注意:如果已存在的hash表有時間,這裏將會替換原有的時間
   * @return true 成功 false失敗
   */
  public boolean hset(String key, String item, Object value, long time) {
    try {
      redisTemplate.opsForHash().put(key, item, value);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 刪除hash表中的值
   * @param key 鍵 不能爲null
   * @param item 項 可以使多個 不能爲null
   */
  public void hdel(String key, Object... item) {
    redisTemplate.opsForHash().delete(key, item);
  }
  /**
   * 判斷hash表中是否有該項的值
   * @param key 鍵 不能爲null
   * @param item 項 不能爲null
   * @return true 存在 false不存在
   */
  public boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
  }
  /**
   * hash遞增 如果不存在,就會創建一個 並把新增後的值返回
   * @param key 鍵
   * @param item 項
   * @param by 要增加幾(大於0)
   * @return
   */
  public double hincr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, by);
  }
  /**
   * hash遞減
   * @param key 鍵
   * @param item 項
   * @param by 要減少記(小於0)
   * @return
   */
  public double hdecr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, -by);
  }
  // ============================set=============================
  /**
   * 根據key獲取Set中的所有值
   * @param key 鍵
   * @return
   */
  public Set<Object> sGet(String key) {
    try {
      return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   * 根據value從一個set中查詢,是否存在
   * @param key 鍵
   * @param value 值
   * @return true 存在 false不存在
   */
  public boolean sHasKey(String key, Object value) {
    try {
      return redisTemplate.opsForSet().isMember(key, value);
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 將數據放入set緩存
   * @param key 鍵
   * @param values 值 可以是多個
   * @return 成功個數
   */
  public long sSet(String key, Object... values) {
    try {
      return redisTemplate.opsForSet().add(key, values);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 將set數據放入緩存
   * @param key 鍵
   * @param time 時間(秒)
   * @param values 值 可以是多個
   * @return 成功個數
   */
  public long sSetAndTime(String key, long time, Object... values) {
    try {
      Long count = redisTemplate.opsForSet().add(key, values);
      if (time > 0)
        expire(key, time);
      return count;
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 獲取set緩存的長度
   * @param key 鍵
   * @return
   */
  public long sGetSetSize(String key) {
    try {
      return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 移除值爲value的
   * @param key 鍵
   * @param values 值 可以是多個
   * @return 移除的個數
   */
  public long setRemove(String key, Object... values) {
    try {
      Long count = redisTemplate.opsForSet().remove(key, values);
      return count;
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  // ===============================list=================================
  /**
   * 獲取list緩存的內容
   * @param key 鍵
   * @param start 開始
   * @param end 結束 0 到 -1代表所有值
   * @return
   */
  public List<Object> lGet(String key, long start, long end) {
    try {
      return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   * 獲取list緩存的長度
   * @param key 鍵
   * @return
   */
  public long lGetListSize(String key) {
    try {
      return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 通過索引 獲取list中的值
   * @param key 鍵
   * @param index 索引 index>=0時， 0 表頭，1 第二個元素，依次類推；index<0時，-1，表尾，-2倒數第二個元素，依次類推
   * @return
   */
  public Object lGetIndex(String key, long index) {
    try {
      return redisTemplate.opsForList().index(key, index);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   * 將list放入緩存
   * @param key 鍵
   * @param value 值
   * @param time 時間(秒)
   * @return
   */
  public boolean lSet(String key, Object value) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 將list放入緩存
   * @param key 鍵
   * @param value 值
   * @param time 時間(秒)
   * @return
   */
  public boolean lSet(String key, Object value, long time) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      if (time > 0)
        expire(key, time);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 將list放入緩存
   * @param key 鍵
   * @param value 值
   * @param time 時間(秒)
   * @return
   */
  public boolean lSet(String key, List<Object> value) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 將list放入緩存
   *
   * @param key 鍵
   * @param value 值
   * @param time 時間(秒)
   * @return
   */
  public boolean lSet(String key, List<Object> value, long time) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      if (time > 0)
        expire(key, time);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 根據索引修改list中的某條數據
   * @param key 鍵
   * @param index 索引
   * @param value 值
   * @return
   */
  public boolean lUpdateIndex(String key, long index, Object value) {
    try {
      redisTemplate.opsForList().set(key, index, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 移除N個值爲value
   * @param key 鍵
   * @param count 移除多少個
   * @param value 值
   * @return 移除的個數
   */
  public long lRemove(String key, long count, Object value) {
    try {
      Long remove = redisTemplate.opsForList().remove(key, count, value);
      return remove;
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }

}

使用案例

controller類

package com.imserver.common.controller;

import com.imserver.common.service.ImUserService;
import com.imserver.config.huanxin.EasemobService;
import com.imserver.imuser.entity.ImUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @description: 用戶管理
 * @author: monkey.G
 * @create: 2020-04-09 18:51
 **/

public class ImUserController2 {
  @Autowired
  private EasemobService easemobService;
  /*  環信相關操作 */
  @RequestMapping("/getToken")
  public Object getToken(){
    return easemobService.getEasemobToken();
  }
}

service類

package com.imserver.config.huanxin;

import com.alibaba.fastjson.JSONObject;
import com.imserver.config.redis.RedisUtilService;
import com.imserver.imuser.entity.ImUser;
import java.util.Map;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @description: Restful請求環信處理數據
 * @author: monkey.G
 * @create: 2020-04-08 17:47
 **/
@Service
public class EasemobService {
  @Autowired
  private RedisUtilService redisUtilService;
    /**
   * 獲取環信的token接口
   * 1、從redis中獲取，獲取不到從環信獲取
   * @return
   */
  public EasemobToken getEasemobToken() {
  //先從redis中獲取token，如果獲取不到，在請求接口獲取token
    EasemobToken tokenFromRedis = (EasemobToken) redisUtilService.get("easemob:token");
    if(tokenFromRedis!=null && !StringUtils.isBlank(tokenFromRedis.getAccessToken())  ){
      return tokenFromRedis;
    }
    //沒有從redis中獲取到，就從接口獲取
    /*****************************************/
    /*省略獲取邏輯，最終拿到一個EasemobToken */
    EasemobToken token = 獲取到token對象;
    /*****************************************/
   
    //將結果保存到redis中，並設置過去時間
      redisUtilService.set("easemob:token",easemobToken);
      redisUtilService.expire("easemob:token",easemobToken.getExpiresIn()-1000);
      return easemobToken;
    
  }

至此redis工具類中的方法就可以使用了