Redis使用String类型中遇到的问题

redis在springboot项目整合中用到的依赖配置，这个大家都知道。

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

配置了RedisConfig，这一点大家也都清楚，网上有很多版本，各有不同吧。

package com.zcf.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

/**
 * @Description Redis基础配置
 * @Author zcf
 * @Date 2020/9/27
 **/
@Configuration
@EnableCaching
public class RedisConfig {
    private static final Logger LOG = LoggerFactory.getLogger(RedisConfig.class);

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory) {
        LOG.info("加载了！！！！！！redisTemplate");
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // JSON序列化配置
        Jackson2JsonRedisSerializer jsonRedisSerializer= new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jsonRedisSerializer.setObjectMapper(objectMapper);

        // String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // value采用String序列化方式
        template.setValueSerializer(stringRedisSerializer);

        // hash的key采用String序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // hash的value采用jackson序列化方式
        template.setHashValueSerializer(jsonRedisSerializer);

        template.afterPropertiesSet();
        return template;
    }

}

这里我目前只是测试了redis的string类型，其他类型的等我遇到了在记录，整理了一个redis的工具类

package com.zcf.utils;

import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

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

/**
 * @Description redis的工具类
 * @Author zcf
 * @Date 2022/9/27
 **/
@Component
public class RedisUtil {
    private static final Logger LOG = LoggerFactory.getLogger(RedisUtil.class);

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     * @param key
     * @param value
     */
    public void set(String key, Object value) {
        String jsonValue = JSON.toJSONString(value);
//        LOG.info("缓存数据：{}",jsonValue);
        redisTemplate.opsForValue().set(key, jsonValue);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等，有过期时间
     * @param key
     * @param value
     * @param time
     */
    public void set(String key, Object value, long time) {
        String jsonValue = JSON.toJSONString(value);
//        LOG.info("缓存数据：{}",jsonValue);
        redisTemplate.opsForValue().set(key, jsonValue, time, TimeUnit.SECONDS);  //TimeUnit.SECONDS指定类型为秒
    }

    /**
     * 设置有效时间
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(String key, long timeout){
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     * @param key
     * @param timeout
     * @param unit
     * @return
     */
    public boolean expire(String key, long timeout, TimeUnit unit){
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取数据
     * @param key
     * @return
     */
    public String get(String key) {
        Object object = redisTemplate.opsForValue().get(key);
//        LOG.info("获取数据：{}",object);
        return (String)object;
    }

    /**
     * 删除数据
     * @param key
     * @return
     */
    public Boolean del(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public boolean hasKey(String key){
        return redisTemplate.hasKey(key);
    }
    
}

string是redis最基本的类型，一个key对应一个value。在序列化的时候，遇到过各种问题，我对set和get时的value做了调整。当然，网上也有其他的方法。我只是说明一下自己的解决办法。存对象时，在存之前用JSON转化了一下，取数据时，在通过JSON转换一下。

• 存数据

• 取数据

后期，我对其他类型在实际过程中遇到的问题在做记录吧。