第三章 SpringBoot快速开发框架 - 集成Redis

作者简介：
🌹 作者：暗夜91
🤟 个人主页：暗夜91的主页
📝 如果感觉文章写的还有点帮助，请帮忙点个关注，我会持续输出高质量技术博文。

---

专栏文章:
1、集成Swagger，生成API文档
2、Mysql数据源配置
3、集成Redis
4、Spring Security + JWT实现登录权限认证
5、跨域配置

专栏源码：
针对该专栏功能，对源码进行整理，可以直接下载运行。
源码下载请移步：SpringBoot快速开发框架

---

三、集成Redis

本项目使用Redis作为服务的缓存管理，用来存储用户登录的token及相关的用户信息。

Redis相关知识这里不做太多赘述，如需学习Redis相关的知识，可以关注本人的另一篇专栏：
Redis技术学习及开发运维

1、集成方法

（1）引入依赖

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

（2）添加Redis配置文件

package com.lll.framework.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    private RedisSerializer<Object> valueSerializer() {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        return jackson2JsonRedisSerializer;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        // 配置序列化
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        RedisCacheConfiguration redisCacheConfiguration =
                config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer((valueSerializer())));

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(redisCacheConfiguration)
                .build();
        return cacheManager;
    }
}

（3）封装Redis工具类

package com.reach.dv.common.service;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

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

/**
 * @ClassName RedisTemplateService
 * @Date 2019/5/16
 * @Version 1.0
 **/
@Service
public class RedisTemplateService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 数据写入redis
     *
     * @param key
     * @param value
     * @param <T>
     * @return
     */
    public <T> boolean set(String key, T value) {
        String val = beanToString(value);
        if (val == null || val.length() <= 0) {
            return false;
        }
        redisTemplate.opsForValue().set(key, val);
        return true;
    }

    /**
     * 写入hash类型的数据
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key, Map<String,Object> value) {
        redisTemplate.opsForHash().putAll(key,value);
        return true;
    }

    /**
     * 数据写入redis
     * @param key
     * @param value
     * @param timeout 超时时长(S) >0时设置
     * @param <T>
     * @return
     */
    public <T> boolean set(String key, T value,int timeout) {
        String val = beanToString(value);
        if (val == null || val.length() <= 0) {
            return false;
        }
        redisTemplate.opsForValue().set(key, val);
        if (timeout>0){
            redisTemplate.expire(key,timeout, TimeUnit.SECONDS);
        }
        return true;
    }

    private <T> String beanToString(T value) {
        String result = "";
        if (value == null) {
            return null;
        }
        Class clazz = value.getClass();
        if (clazz == int.class || clazz == Integer.class) {
            result = String.valueOf(value);
        } else if (clazz == long.class || clazz == Long.class) {
            result = String.valueOf(value);
        } else if (clazz == String.class) {
            result = String.valueOf(value);
        } else {
            result = JSON.toJSONString(value);
        }
        return result;
    }

    /**
     * 查询数据，返回序列化数据
     * @param key
     * @param <T>
     * @return
     */
    public <T> T get(String key, Class<T> clazz) {
        String value = redisTemplate.opsForValue().get(key);
        if(key.equals("vin")){
            value = value.toUpperCase();
        }
        return stringToBean(value, clazz);
    }

    /**
     * 查询hash数据，返回序列化数据
     * @param key
     * @param mkey
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T get(String key,String mkey, Class<T> clazz){
        String value = String.valueOf(redisTemplate.opsForHash().get(key,mkey));
        if(key.equals("vin")){
            value = value.toUpperCase();
        }
        return stringToBean(value, clazz);
    }

    private <T> T stringToBean(String value, Class<T> clazz) {
        T result;
        if (value == null || value.length() <= 0 || clazz == null) {
            return null;
        }
        if (clazz == int.class || clazz == Integer.class) {
            result = (T) Integer.valueOf(value);
        } else if (clazz == long.class || clazz == Long.class) {
            result = (T) Long.valueOf(value);
        } else if (clazz == String.class) {
            result = (T) value;
        } else {
            result = JSON.parseObject(value,clazz);
//            result = JSON.toJavaObject(value,clazz);
        }
        return result;
    }

    public boolean delete(String key){
        redisTemplate.delete(key);
        return true;
    }

    public Set<String> getKeys(String prefix){
        Set<String> keys = redisTemplate.keys(prefix);
        return keys;
    }

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

    /**
     * 更新key的过期时间
     * @param key
     * @param newTimeOut
     * @return
     */
    public Boolean expireKey(String key,int newTimeOut){
        return redisTemplate.expire(key, newTimeOut, TimeUnit.SECONDS);
    }
}

到这里，我们就完成了对Redis的集成，可以在业务模块通过Redis的工具类对Redis进行操作了。