springBoot3业务实战中使用redisspringBoot3项目中使用redis，配置redis、直接操作red

一 springDataRedis 直接使用redis

1 maven配置

  <!-- 直接操作 redis -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

2 配置 application.yaml

  spring:
      data:
        # redis 配置
        redis:
          # 地址
          host: 192.168.1.44
          # 端口，默认为6379
          port: 6379
          # 数据库索引
          database: 0
          # 密码
          password: 19910129
          # 连接超时时间
          timeout: 10s
          lettuce:
            pool:
              # 连接池中的最小空闲连接
              min-idle: 0
              # 连接池中的最大空闲连接
              max-idle: 8
              # 连接池的最大数据库连接数
              max-active: 8
              # #连接池最大阻塞等待时间（使用负值表示没有限制）
              max-wait: -1ms

3 创建配置文件

  
  /**
   * redis配置
   */
  @SuppressWarnings("deprecation")
  @Configuration
  @EnableCaching
  public class RedisConfig extends CachingConfigurerSupport
  {
      @Bean
      @SuppressWarnings(value = { "unchecked", "rawtypes" })
      public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
      {
          // 1 创建redis模板对象
          RedisTemplate<Object, Object> template = new RedisTemplate<>();
          // 2 设置连接工厂对象，去application中的连接信息
          template.setConnectionFactory(connectionFactory);
  
          // 3 自定义序列化器
          FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
  
          // 4 使用StringRedisSerializer来序列化和反序列化redis的key值
          template.setKeySerializer(new StringRedisSerializer());
          // 5 使用fastjson2序列化器来序列化和反序列化redis的value值
          template.setValueSerializer(serializer);
  
          // 6 Hash的key也采用StringRedisSerializer的序列化方式
          template.setHashKeySerializer(new StringRedisSerializer());
          // 7 Hash的value也采用fastjson2序列化器
          template.setHashValueSerializer(serializer);
          // 8 刷新缓存
          template.afterPropertiesSet();
          // 9 返回
          return template;
      }
  
      @Bean
      public DefaultRedisScript<Long> limitScript()
      {
          DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
          redisScript.setScriptText(limitScriptText());
          redisScript.setResultType(Long.class);
          return redisScript;
      }
  
      /**
       * 限流脚本
       */
      private String limitScriptText()
      {
          return "local key = KEYS[1]\n" +
                  "local count = tonumber(ARGV[1])\n" +
                  "local time = tonumber(ARGV[2])\n" +
                  "local current = redis.call('get', key);\n" +
                  "if current and tonumber(current) > count then\n" +
                  "    return tonumber(current);\n" +
                  "end\n" +
                  "current = redis.call('incr', key)\n" +
                  "if tonumber(current) == 1 then\n" +
                  "    redis.call('expire', key, time)\n" +
                  "end\n" +
                  "return tonumber(current);";
      }
  }

4 封装直接使用redis 的方法

 
  
  /**
   * spring redis 工具类
   **/
  @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 Redis键
       * @return 有效时间
       */
      public Long getExpire(final String key)
      {
  
          return redisTemplate.getExpire(key, TimeUnit.MINUTES);
      }
  
      /**
       * 判断 key是否存在
       *
       * @param key 键
       * @return true 存在 false不存在
       */
      public Boolean hasKey(String key)
      {
          return redisTemplate.hasKey(key);
      }
  
      /**
       * 获得缓存的基本对象。
       *
       * @param key 缓存键值
       * @return 缓存键值对应的数据
       */
      public <T> T getCacheObject(final String key)
      {
          if (StringUtils.isEmpty(key)){
              return null;
          }
          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 boolean deleteObject(final Collection collection)
      {
          return redisTemplate.delete(collection) > 0;
      }
  
      /**
       * 缓存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);
      }
  
      /**
       * 删除Hash中的某条数据
       *
       * @param key Redis键
       * @param hKey Hash键
       * @return 是否成功
       */
      public boolean deleteCacheMapValue(final String key, final String hKey)
      {
          return redisTemplate.opsForHash().delete(key, hKey) > 0;
      }
  
      /**
       * 获得缓存的基本对象列表
       *
       * @param pattern 字符串前缀
       * @return 对象列表
       */
      public Collection<String> keys(final String pattern)
      {
          return redisTemplate.keys(pattern);
      }
  }

5 业务使用redis

  
  /**
   * token验证处理
   */
  @Component
  public class TokenService
  {
      private static final Logger log = LoggerFactory.getLogger(TokenService.class);
  
      // 令牌自定义标识
      @Value("${token.header}")
      private String header;
  
      // 令牌秘钥
      @Value("${token.secret}")
      private String secret;
  
      // 令牌有效期（默认30分钟）
      @Value("${token.expireTime}")
      private int expireTime;
  
      // 是否允许账户多终端同时登录（true允许 false不允许）
      @Value("${token.soloLogin}")
      private boolean soloLogin;
  
      protected static final long MILLIS_SECOND = 1000;
  
      protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;
  
      private static final Long MILLIS_MINUTE_TEN = 20 * 60 * 1000L;
  
      @Autowired
      private RedisCache redisCache;
  
      /**
       * 根据token生成 - redis - 用户登录的key
       * @param token
       * @return
       */
      private String getTokenKey(String token)
      {
          return CacheConstants.LOGIN_TOKEN_KEY + token;
      }
  
      /**
       * 根据userId生成 - redis - 单点登录记录的key
       * @param userId
       * @return
       */
      private String getUserIdKey(Long userId)
      {
          return CacheConstants.LOGIN_USERID_KEY + userId;
      }
  
      public String getTokenInTokenKey(String userKey)
      {
          if (StringUtils.isEmpty(userKey))
          {
              return null;
          }
          // 从getTokenKey中分割出token部分
          return userKey.replaceFirst(CacheConstants.LOGIN_TOKEN_KEY, "");
      }
  
      /**
       * 根据userId生成 - redis - 异地登录记录的key
       * @param token
       * @return
       */
      private String getRemoteLoginKey(String token)
      {
          return CacheConstants.REMOTE_LOGIN_KEY + token;
      }
  
      /**
       * 根据userId生成 - redis - 强制退出记录的key
       * @param token
       * @return
       */
      private String getForceQuitKey(String token)
      {
          return CacheConstants.FORCE_QUIT_KEY + token;
      }
  
      /**
       * 获取用户身份信息
       *
       * @return 用户信息
       */
      public LoginUser getLoginUser(HttpServletRequest request)
      {
          // 获取请求头携带的token
          String token = getToken(request);
          if (StringUtils.isNotEmpty(token))
          {
              try
              {
                  Claims claims = parseToken(token);
                  // 解析对应的权限以及用户信息
                  String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
                  String userKey = getTokenKey(uuid);
                  LoginUser user = redisCache.getCacheObject(userKey);
                  return user;
              }
              catch (Exception e)
              {
                  log.error("获取用户信息异常:'{}'", e.getMessage());
                  return null;
              }
          }
          return null;
      }
  
      /**
       * 获取请求头中token解析后的 uuid
       * @param request
       * @return
       */
      public String getUuid(HttpServletRequest request)
      {
          // 获取请求头携带的token
          String token = getToken(request);
          if (StringUtils.isNotEmpty(token))
          {
              try
              {
                  Claims claims = parseToken(token);
                  // 解析对应的权限以及用户信息
                  return (String) claims.get(Constants.LOGIN_USER_KEY);
              }
              catch (Exception e)
              {
                  log.error("获取用户信息异常:'{}'", e.getMessage());
                  return null;
              }
          }
          return null;
      }
  
      /**
       * 设置用户身份信息
       */
      public void setLoginUser(LoginUser loginUser)
      {
          if (StringUtils.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken()))
          {
              refreshToken2(loginUser);
          }
      }
  
      /**
       * 创建token令牌
       *
       * @param loginUser 用户信息
       * @return 令牌
       */
      public String createToken(LoginUser loginUser)
      {
          String token = IdUtils.fastUUID();
          loginUser.setToken(token);
          setUserAgent(loginUser);
          refreshToken2(loginUser);
  
          Map<String, Object> claims = new HashMap<>();
          claims.put(Constants.LOGIN_USER_KEY, token);
          return generateToken(claims);
      }
  
      /**
       * 从数据声明生成令牌
       *
       * @param claims 数据声明
       * @return 令牌
       */
      private String generateToken(Map<String, Object> claims)
      {
          String token = Jwts.builder()
                  .setClaims(claims)
                  .signWith(SignatureAlgorithm.HS512, secret).compact();
          return token;
      }
  
      /**
       * 从请求头中 获取token
       * @param request
       * @return token
       */
      private String getToken(HttpServletRequest request)
      {
          // 获取请求头中的token字段
          String token = request.getHeader(header);
          // 存在token -> 格式化 token
          if (StringUtils.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX))
          {
              token = token.replace(Constants.TOKEN_PREFIX, "");
          }
          // 返回正常格式的 token
          return token;
      }
  
      /**
       * 解析token 获取数据体
       * @param token 令牌
       * @return 数据声明
       */
      private Claims parseToken(String token)
      {
          return Jwts.parser()
                  .setSigningKey(secret)
                  .parseClaimsJws(token)
                  .getBody();
      }
  
      /**
       * 解析token 获取用户名
       * @param token 令牌
       * @return 用户名
       */
      public String getUsernameFromToken(String token)
      {
          Claims claims = parseToken(token);
          return claims.getSubject();
      }
  
      /**
       * 验证令牌有效期，相差不足20分钟 -> 自动刷新缓存
       * @param loginUser
       * @return 令牌
       */
      public void verifyToken(LoginUser loginUser)
      {
          long expireTime = loginUser.getExpireTime();
          long currentTime = System.currentTimeMillis();
          if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
          {
              refreshToken2(loginUser);
          }
      }
  
      /**
       * 刷新令牌有效期 - 单点登录维护的方法
       * @param loginUser 登录信息
       */
      public void refreshToken2(LoginUser loginUser)
      {
          loginUser.setLoginTime(System.currentTimeMillis());
          loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
          // 根据uuid将loginUser缓存
          String userKey = getTokenKey(loginUser.getToken());
          redisCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
          if (!soloLogin)
          {
              // 缓存用户唯一标识，防止同一帐号，同时登录
              String userIdKey = getUserIdKey(loginUser.getUser().getUserId());
              redisCache.setCacheObject(userIdKey, userKey, expireTime, TimeUnit.MINUTES);
          }
      }
  
      /**
       * 刷新令牌有效期
       * @param loginUser 登录信息
       */
      public void refreshToken(LoginUser loginUser)
      {
          loginUser.setLoginTime(System.currentTimeMillis());
          loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
          // 根据uuid将loginUser缓存
          String userKey = getTokenKey(loginUser.getToken());
          redisCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
      }
  
      /**
       * 设置用户代理信息
       * @param loginUser 登录信息
       */
      public void setUserAgent(LoginUser loginUser)
      {
          UserAgent userAgent = UserAgent.parseUserAgentString(ServletUtils.getRequest().getHeader("User-Agent"));
          String ip = IpUtils.getIpAddr();
          loginUser.setIpaddr(ip);
          loginUser.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
          loginUser.setBrowser(userAgent.getBrowser().getName());
          loginUser.setOs(userAgent.getOperatingSystem().getName());
      }
  
      /**
       * 退出登录 删除用户身份信息 - 单点登录
       */
      public void delLoginUser(String token, Long userId)
      {
          if (StringUtils.isNotEmpty(token))
          {
              String userKey = getTokenKey(token);
              redisCache.deleteObject(userKey);
          }
          if (!soloLogin && StringUtils.isNotNull(userId))
          {
              String userIdKey = getUserIdKey(userId);
              redisCache.deleteObject(userIdKey);
          }
      }
  
      /**
       * 强制推出删除操作
       * @param token
       */
      public void delLoginUser(String token)
      {
          if (StringUtils.isNotEmpty(token))
          {
              try
              {
                  String userKey = getTokenKey(token);
                  LoginUser loginUser = redisCache.getCacheObject(userKey);
                  if (loginUser != null)
                  {
                      String userIdKey = getUserIdKey(loginUser.getUser().getUserId());
                      redisCache.deleteObject(userIdKey);
                      redisCache.deleteObject(userKey);
                      // 登记 强制退出的 token
                      setForceQuitToken(token);
                  }
              }
              catch (Exception e)
              {
                  log.error("强制退出登录异常：'{}'", e.getMessage());
              }
          }
      }
  
      // ================= 异地登录  Token 处理 ======================
      /**
       * 记录 异地登录的token
       * @param token
       */
      public void setRemoteLoginToken(String token){
          if (StringUtils.isNotEmpty(token))
          {
              try
              {
                  String remoteLoginKey = getRemoteLoginKey(token);
                  // 创建当前时间，时间格式是 yyyy-mm-dd hh:mm:ss
                  String currentTime = DateUtils.getTime();
                  redisCache.setCacheObject(remoteLoginKey, currentTime, 1, TimeUnit.DAYS);
              }
              catch (Exception e)
              {
                  log.error("异地登录的token记录异常：'{}'", e.getMessage());
              }
          }
      }
  
      /**
       * 获取异地登陆的时间
       * @param token
       */
      public String getRemoteLoginToken(String token)
      {
          if (StringUtils.isEmpty(token))
          {
              return null;
          }
          try
          {
              String remoteLoginKey = getRemoteLoginKey(token);
              String currentTime = redisCache.getCacheObject(remoteLoginKey);
              if (StringUtils.isNotEmpty(currentTime))
              {
                  return currentTime;
              }
              return null;
          }
          catch (Exception e)
          {
              log.error("获取异地登录的token异常：'{}'", e.getMessage());
              return null;
          }
      }
  
      /**
       * 删除异地登录的记录
       * @param token
       */
      public void removeRemoteLoginToken(String token)
      {
          if (StringUtils.isNotEmpty(token))
          {
              try
              {
                  String remoteLoginKey = getRemoteLoginKey(token);
                  redisCache.deleteObject(remoteLoginKey);
              }
              catch (Exception e)
              {
                  log.error("删除异地登录的记录异常：'{}'", e.getMessage());
              }
          }
      }
  
      // ================= 强制退出 Token 处理 ======================
      /**
       * 记录 强制退出 的token
       * @param token
       */
      public void setForceQuitToken(String token)
      {
          if (StringUtils.isNotEmpty(token))
          {
              try
              {
                  String forceQuitKey = getForceQuitKey(token);
                  // 创建当前时间，时间格式是 yyyy-mm-dd hh:mm:ss
                  String currentTime = DateUtils.getTime();
                  redisCache.setCacheObject(forceQuitKey, currentTime,1, TimeUnit.DAYS);
              }
              catch (Exception e)
              {
                  log.error("强制退出的token记录异常：'{}'", e.getMessage());
              }
          }
      }
  
      /**
       * 获取 强制退出 的时间
       * @param token
       */
      public String getForceQuitToken(String token)
      {
          if (StringUtils.isEmpty(token))
          {
              return null;
          }
          try
          {
              String forceQuitKey = getForceQuitKey(token);
              String currentTime = redisCache.getCacheObject(forceQuitKey);
              if (StringUtils.isNotEmpty(currentTime))
              {
                  return currentTime;
              }
              return null;
          }
          catch (Exception e)
          {
              log.error("获取强制退出的token异常：'{}'", e.getMessage());
              return null;
          }
      }
  
      /**
       * 删除 强制退出 的记录
       * @param token
       */
      public void removeForceQuitKey(String token)
      {
          if (StringUtils.isNotEmpty(token))
          {
              try
              {
                  String forceQuitKey = getForceQuitKey(token);
                  redisCache.deleteObject(forceQuitKey);
              }
              catch (Exception e)
              {
                  log.error("删除异地登录的记录异常：'{}'", e.getMessage());
              }
          }
      }
  
  }

二 springCache 注解方式使用redis

1 maven配置

  <!-- 通过注解操作缓存 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
  </dependency>
  <!-- redis客户端 决定缓存使用redis -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

2 开启注解缓存功能

  
  @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
  @EnableCaching // 启动类上开启注解缓存功能
  public class OkYunApplication{......}

3 配置 application.yaml

  # 添加TTL管理
  custom:
    cache:
      ttl:
        tenantCostMethod: 600    # 缓存10分钟
        userCache: 3600          # 缓存1小时
        menuCache: 300           # 缓存5分钟

4 创建一个配置类 CustomCacheProperties.java

  
  package com.okyun.framework.config;
  
  import lombok.Data;
  import org.springframework.boot.context.properties.ConfigurationProperties;
  import org.springframework.stereotype.Component;
  
  import java.util.HashMap;
  import java.util.Map;
  
  /**
   * 自定义注解缓存配置属性：可配置 缓存名与其对应的 TTL，单位：秒
   */
  @Data
  @Component
  @ConfigurationProperties(prefix = "custom.cache")
  public class CustomCacheProperties {
  
      /**
       * 缓存名与其对应的 TTL，单位：秒
       */
      private Map<String, Long> ttl = new HashMap<>();
  }

5 RedisConfig.java 中新增 cacheManager 方法

  
  /**
       * 注解缓存管理器
       * @param redisConnectionFactory    // Redis 连接工厂
       * @param customCacheProperties     // 自定义缓存配置
       * @return
       */
  @Bean
  public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory, CustomCacheProperties customCacheProperties) {
      // 全局默认配置
      RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
              .entryTtl(Duration.ofMinutes(30))
              .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
              .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new FastJson2JsonRedisSerializer<>(Object.class)))
              .disableCachingNullValues()
              // 自定义前缀（去掉默认 ::）
              .computePrefixWith(cacheName -> cacheName + ":");
  
      // 构建每个 cacheName 对应的配置
      Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
      customCacheProperties.getTtl().forEach((cacheName, ttlSeconds) -> {
          configMap.put(cacheName, defaultConfig.entryTtl(Duration.ofSeconds(ttlSeconds)));
      });
  
      return RedisCacheManager.builder(redisConnectionFactory)
              .cacheDefaults(defaultConfig)
              .withInitialCacheConfigurations(configMap)
              .transactionAware()
              .build();
  }

6 常用注解

  
  // 1 添加到启动类上，开始缓存注解功能
  @EnableCaching  
  // 2 在方法上先查询缓存，如果有数据直接返回缓存，如果没有数据，则调用方法并将返回值放到缓存中
  @Cacheable(cacheNames = "tenantCostMethod", key = "'tenantId_' + #tenantId")  
  // 3 将方法的返回值更新缓存
  @CachePut(cacheNames = "tenantCostMethod", key = "'tenantId_' + #tenantId")
  // 4 删除指定缓存
  @CacheEvict(cacheNames = "tenantCostMethod", key = "'tenantId_' + #tenantId") 
  // 5 删除所有缓存
  @CacheEvict(cacheNames = "tenantCostMethod", allEntries = true)

三项目实战应用

1 需求

  
  1 多租户
  2 商品缓存
  3 关键字过滤商品(商品名称模糊查询，商品编码精确查询)

2 查询所有商品并缓存

  @Service
  @RequiredArgsConstructor
  public class ProductSkuCache {
  
      private final ProductSkuMapper productSkuMapper;
  
      /**
       * 获取所有SKU
       * @param tenantId
       * @return
       */
      @Cacheable(value = "skuListCache", key = "'tenant_' + #tenantId")
      public List<ProductSkuVo> getAllProductSkuByTenant(Long tenantId) {
          ProductSku query = new ProductSku();
          query.setTenantId(tenantId);
          return productSkuMapper.selectProductSkuList(query);
      }
  }

3 封装增/删/改预热刷新缓存

  @Service
  @RequiredArgsConstructor
  @Slf4j
  public class ProductSkuCacheManager {
  
      private final RedisTemplate redisTemplate;
      private final ProductSkuCache productSkuCache;
  
      /**
       * 根据租户ID清除缓存
       * @param tenantId
       */
      public void clearCacheByTenantId(Long tenantId) {
          String cacheKey = "skuListCache:tenant_" + tenantId;
          redisTemplate.delete(cacheKey);
      }
  
      /**
       * 根据租户ID 热更新缓存
       * @param tenantId
       */
      public void refreshCacheByTenant(Long tenantId) {
          if (tenantId == null){
              return;
          }
          clearCacheByTenantId(tenantId);
          // 触发缓存预热
          productSkuCache.getAllProductSkuByTenant(tenantId);
      }
  }

3 处理增/删/改刷新缓存

  
  // 举例 新增
  
  @Service
  @RequiredArgsConstructor
  @Slf4j
  public class ProductSkuServiceImpl implements IProductSkuService 
  {
  
      private final ProductSkuMapper productSkuMapper;
      private final ProductSkuCacheManager productSkuCacheManager;
  
      @Override
      @TenantId(tableAlias = "k")
      public int insertProductSku(ProductSku productSku)
      {
          // 1 检查 SKU编码的唯一性
          checkSkuCodeUnique(productSku);
          int res =  productSkuMapper.insertProductSku(productSku);
          if (res > 0){
              // 刷新缓存
              productSkuCacheManager.refreshCacheByTenant(productSku.getTenantId());
          }
          return res;
      }
  }

4 关键字查询数据

  
  @PreAuthorize("@ss.hasPermi('product:sku:list')")
  @GetMapping("/suggest")
  public AjaxResult suggest(@RequestParam String keyword) {
    // 获取租户信息
    Long tenantId = SecurityUtils.getLoginUser().getTenantId();
    if (tenantId == null){
      log.error("当前用户的公司ID为空！！");
      return AjaxResult.error("当前用户的公司ID为空！！");
    }
    // 获取所有sku数据
    List<ProductSkuVo> cacheList = productSkuCache.getAllProductSkuByTenant(tenantId);
    if (cacheList == null){
      log.error("当前用户没有sku数据！！");
      return AjaxResult.error("当前用户没有sku数据！！");
    }
    // 筛选数据
    if (StringUtils.isBlank(keyword)){
      return AjaxResult.success(cacheList);
    }
    String lowerKeyword = keyword.toLowerCase();
    List<ProductSkuVo> resultList = cacheList.stream()
      .filter(sku -> sku.getSkuName().toLowerCase().contains(lowerKeyword)
              || sku.getSkuCode().toLowerCase().equals(lowerKeyword))
      .limit(20) // 控制结果数量，提升前端性能
      .collect(Collectors.toList());
    return AjaxResult.success(resultList);
  }

5 注意事项

// key = "skuListCache:tenant_" + tenantId, 拼接时 value 与 key 之间自动拼接":"
@Cacheable(value = ErpCacheConstants.SKU_LIST, key = "'tenant_' + #tenantId")

// 直接手动拼接key, 需要添加层级":"
String cacheKey = ErpCacheConstants.SKU_LIST + ":tenant_" + tenantId;
log.info("-------------清除缓存：{}", cacheKey);
redisTemplate.delete(cacheKey);

springBoot3业务实战中使用redis

一 springDataRedis 直接使用redis

1 maven配置

2 配置 application.yaml

3 创建配置文件

4 封装直接使用redis 的方法

5 业务使用redis

二 springCache 注解方式使用redis

1 maven配置

2 开启注解缓存功能

3 配置 application.yaml

4 创建一个配置类 CustomCacheProperties.java

5 RedisConfig.java 中新增 cacheManager 方法

6 常用注解

三 项目实战应用

1 需求

2 查询所有商品并缓存

3 封装 增/删/改 预热刷新缓存

3 处理 增/删/改 刷新缓存

4 关键字查询数据

5 注意事项

三项目实战应用

3 封装增/删/改预热刷新缓存

3 处理增/删/改刷新缓存