项目中Redis的使用

原创

龙崎流河 2023-02-04 08:56:24 ©著作权

文章标签 redis 数据库缓存 spring 文章分类 Redis 数据库

©著作权归作者所有：来自51CTO博客作者龙崎流河的原创作品，请联系作者获取转载授权，否则将追究法律责任

添加依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- Sa-Token 整合 Redis （使用 jackson 序列化方式） -->
<dependency>
  <groupId>cn.dev33</groupId>
  <artifactId>sa-token-dao-redis-jackson</artifactId>
  <version>1.33.0</version>
</dependency>
<!-- 提供Redis连接池 -->
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
</dependency>

application.yml配置

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

Redis三部曲

使用StringRedisTemplate

//如果redis里面的key和value都是字符串可以用这个操作
@Autowired
StringRedisTemplate stringRedisTemplate;
private static final long TIME_IN_MS5 = 5 * 60 * 1000;  // 表示5分钟的毫秒数
String key = Constants.EMAIL_CODE + emailPrefix + email;
Integer code = Integer.valueOf(RandomUtil.randomNumbers(6));
stringRedisTemplate.opsForValue().set(key, code, TIME_IN_MS5, TimeUnit.MICROSECONDS);
// 如果这样设置过期时间，是存不进去的
//TimeUnit.MILLISECONDS 是微秒，会导致过期时间过快，很快就没了

String code = stringRedisTemplate.opsForValue().get(key);
stringRedisTemplate.opsForValue().set(key,"“);

项目中Redis的使用_spring

使用RedisTemplate

private final RedisTemplate<String, Object> redisTemplate;
redisTemplate.delete(key);

防止键和值默认的jdk序列化方式出现二进制码：

package com.partner.boot.common;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置 key的序列化方式  防止默认的jdk序列化方式出现二进制码  看不懂
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型

        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}

使用RedisUtils封装

基本使用工具类：

package com.partner.boot.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisConnectionCommands;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;

@SuppressWarnings(value = {"unchecked"})
@Component
@Slf4j
public class RedisUtils {
    private static RedisTemplate<String, Object> staticRedisTemplate;

    private final RedisTemplate<String, Object> redisTemplate;

    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // Springboot启动成功之后会调用这个方法
    @PostConstruct
    public void initRedis() {
        // 初始化设置 静态staticRedisTemplate对象，方便后续操作数据
        staticRedisTemplate = redisTemplate;
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public static <T> void setCacheObject(final String key, final T value) {
        staticRedisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public static <T> void setCacheObject(final String key, final T value, final long timeout, final TimeUnit timeUnit) {
        staticRedisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public static <T> T getCacheObject(final String key) {
        return (T) staticRedisTemplate.opsForValue().get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public static boolean deleteObject(final String key) {
        return Boolean.TRUE.equals(staticRedisTemplate.delete(key));
    }

    /**
     * 获取单个key的过期时间
     *
     * @param key
     * @return
     */
    public static Long getExpireTime(final String key) {
        return staticRedisTemplate.getExpire(key);
    }

    /**
     * 发送ping命令
     * redis 返回pong
     */
    public static void ping() {
        String res = staticRedisTemplate.execute(RedisConnectionCommands::ping);
        log.info("Redis ping ==== {}", res);
    }

}

完整工具类：

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
* redis 工具类
**/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisUtils {
private static RedisTemplate staticRedisTemplate;

private final RedisTemplate redisTemplate;

public RedisUtils(RedisTemplate redisTemplate) {
    // 防止key中文乱码
    redisTemplate.setKeySerializer(new StringRedisSerializer()); // key的序列化类型

    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                                       ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.afterPropertiesSet();
    this.redisTemplate = redisTemplate;
}

@PostConstruct
public void initRedis() {
    // 初始化设置 静态redis对象，方便后续操作数据
    staticRedisTemplate = redisTemplate;
}

/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key   缓存的键值
* @param value 缓存的值
*/
public static <T> void setCacheObject(final String key, final T value) {
    staticRedisTemplate.opsForValue().set(key, value);
}

        /**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key      缓存的键值
* @param value    缓存的值
* @param timeout  时间
* @param timeUnit 时间颗粒度
*/
public static <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
    staticRedisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}

public static <T> void setCacheObject(final String key, final T value, final long timeoutInSecond) {
  setCacheObject(key, value, timeoutInSecond, TimeUnit.SECONDS);
}

  /**
  * 设置有效时间
  *
  * @param key     Redis键
  * @param timeout 超时时间
  * @return true=设置成功；false=设置失败
  */
  public static 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 static boolean expire(final String key, final long timeout, final TimeUnit unit) {
    return Boolean.TRUE.equals(staticRedisTemplate.expire(key, timeout, unit));
  }

 /**
 * 获取单个key的过期时间
 * @param key
 * @return
 */
  public static Long getExpireTime(final String key) {
    return staticRedisTemplate.getExpire(key);
  }

  /**
  * 获得缓存的基本对象。
  *
  * @param key 缓存键值
  * @return 缓存键值对应的数据
  */
  public static <T> T getCacheObject(final String key) {
  ValueOperations<String, T> operation = staticRedisTemplate.opsForValue();
    return operation.get(key);
  }

  /**
  * 删除单个对象
  *
  * @param key
  */
  public static boolean deleteObject(final String key) {
    return Boolean.TRUE.equals(staticRedisTemplate.delete(key));
  }

  /**
  * 删除集合对象
  *
  * @param collection 多个对象
  * @return
  */
  public static Long deleteObject(final Collection collection) {
    return staticRedisTemplate.delete(collection);
  }

  /**
  * 缓存List数据
  *
  * @param key      缓存的键值
  * @param dataList 待缓存的List数据
  * @return 缓存的对象
  */
  public static <T> long setCacheList(final String key, final List<T> dataList) {
  Long count = staticRedisTemplate.opsForList().rightPushAll(key, dataList);
    return count == null ? 0 : count;
  }

  /**
  * 获得缓存的list对象
  *
  * @param key 缓存的键值
  * @return 缓存键值对应的数据
  */
  public static <T> List<T> getCacheList(final String key) {
    return staticRedisTemplate.opsForList().range(key, 0, -1);
  }

  /**
  * 缓存Set
  *
  * @param key     缓存键值
  * @param dataSet 缓存的数据
  * @return 缓存数据的对象
  */
  public static <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
      BoundSetOperations<String, T> setOperation = staticRedisTemplate.boundSetOps(key);
      Iterator<T> it = dataSet.iterator();
      while (it.hasNext()) {
      setOperation.add(it.next());
      }
      return setOperation;
  }

  /**
  * 获得缓存的set
  *
  * @param key
  * @return
  */
  public static <T> Set<T> getCacheSet(final String key) {
    return staticRedisTemplate.opsForSet().members(key);
  }

  /**
  * 缓存Map
  *
  * @param key
  * @param dataMap
  */
  public static <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
      if (dataMap != null) {
        staticRedisTemplate.opsForHash().putAll(key, dataMap);
      }
  }

  /**
  * 获得缓存的Map
  *
  * @param key
  * @return
  */
  public static <T> Map<String, T> getCacheMap(final String key) {
    return staticRedisTemplate.opsForHash().entries(key);
  }

  /**
  * 往Hash中存入数据
  *
  * @param key   Redis键
  * @param hKey  Hash键
  * @param value 值
  */
  public static <T> void setCacheMapValue(final String key, final String hKey, final T value) {
    staticRedisTemplate.opsForHash().put(key, hKey, value);
  }

  /**
  * 获取Hash中的数据
  *
  * @param key  Redis键
  * @param hKey Hash键
  * @return Hash中的对象
  */
  public static <T> T getCacheMapValue(final String key, final String hKey) {
  HashOperations<String, String, T> opsForHash = staticRedisTemplate.opsForHash();
    return opsForHash.get(key, hKey);
  }

  /**
  * 删除Hash中的数据
  *
  * @param key
  * @param hKey
  */
  public static void delCacheMapValue(final String key, final String hKey) {
      HashOperations hashOperations = staticRedisTemplate.opsForHash();
      hashOperations.delete(key, hKey);
  }

  /**
  * 获取多个Hash中的数据
  *
  * @param key   Redis键
  * @param hKeys Hash键集合
  * @return Hash对象集合
  */
  public static <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
    return staticRedisTemplate.opsForHash().multiGet(key, hKeys);
  }

  /**
  * 获得缓存的基本对象列表
  *
  * @param pattern 字符串前缀
  * @return 对象列表
  */
  public static Collection<String> keys(final String pattern) {
    return staticRedisTemplate.keys(pattern);
    }
}