Redis常用工具类

RedisConfig

package com.lemon.move.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * 解决存入redis后,显示乱码
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory){

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //  设置连接池工厂
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);

        //  首先解决key的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);

        //  解决value的序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

        //  序列化时将类的数据类型存储json，以便反序列化的时候转换成正确的类型
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);

        //  解决jackson2无法反序列化localDateTime问题
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.registerModule(new JavaTimeModule());

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;

    }
}

RedisUtil

package com.lemon.move.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 */
@Slf4j
@Component
public class RedisUtil {


    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 清空所有缓存
     */
    public void clear() {
        redisTemplate.execute(new RedisCallback<String>() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb();
                return "ok";
            }
        });
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * 生成登录使用的验证码并存入redis
     * 过期时间五分钟
     */
    public String sendYZM(String redisPrefix, String mobile) {
        // 生一个随机6位数的整数
        String YZM = "";
        for (int i = 0; i < 6; i++) {
            YZM = YZM + (int) (Math.random() * 9);
        }
        log.info("生成的验证码是:" + YZM);
        // 把生成的验证码存入redis,设置5分钟过期 key设置规则: 业务名称+手机号 例如: mobileLogin+1222222222
        String redisKey = redisPrefix + mobile;
        boolean sendRedisResult = this.set(redisKey, YZM, 300L);
        if (sendRedisResult) {
            return YZM;
        } else {
            log.info("redis存入验证码失败");
            return "false";
        }
    }

    /**
     * 生成注册使用的验证码并存入redis
     * 过期时间五分钟
     */
    public String sendYZM(String redisPrefix, String mobile, String companyName) {
        // 生一个随机6位数的整数
        String YZM = "";
        for (int i = 0; i < 6; i++) {
            YZM = YZM + (int) (Math.random() * 9);
        }
        String redisKey = redisPrefix + mobile + companyName;
        boolean sendRedisResult = this.set(redisKey, YZM, 300L);
        if (sendRedisResult) {
            return YZM;
        } else {
            log.info("redis存入验证码失败");
            return "false";
        }
    }


    /**
     * 将生成的token存入redis
     * 过期时间:1小时5分钟
     * token的过期时间是1小时,多余出来5分钟是防止网络延迟,存入时间比生成token时间晚
     */
    public boolean setToken(String s, String token) {
        return set(s, token, 3900L);
    }
}