Spring-boot集成Redis

转载

mob604756f6b718 2021-11-01 21:00:00

文章标签 redis json spring 序列化 java 文章分类 Redis 数据库

pom文件

        <!-- springboot整合redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.5.6</version>
        </dependency>

配置类

Redisconfig

package com.eagle.common.config;

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

/**
 * @Author LiGuangLong
 * @Date 2021-11-01 9:58
 * @Version 1.0
 **/
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        //设置工厂链接
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置自定义序列化方式
        setSerializeConfig(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }
    private void setSerializeConfig(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory redisConnectionFactory) {
        //对字符串采取普通的序列化方式 适用于key 因为我们一般采取简单字符串作为key
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //普通的string类型的key采用 普通序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //普通hash类型的key也使用 普通序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        //解决查询缓存转换异常的问题  大家不能理解就直接用就可以了 这是springboot自带的jackson序列化类，但是会有一定问题
        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);
        //普通的值采用jackson方式自动序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //hash类型的值也采用jackson方式序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        //属性设置完成afterPropertiesSet就会被调用，可以对设置不成功的做一些默认处理
        redisTemplate.afterPropertiesSet();
    }

}

备注: 可以避免序列化对象

如果不进行自定义序列化存放的key和value都是默认序列化(16进制数据) java中进行取得时候会默认反序列化

如果进行了自定义序列化取值得时候进行判断会出错

所以现在存入数据的时候转为String 取得时候在吧 String 转为json对象

net.sf.json
JSONArray.fromObject(list).toString()   //list转字符串 list<e> 可以是对象
JSONArray.fromObject(redis.get("sfzxx"))  // 获取 给对象没什么区别就是 swagger 没有提示了
    
    
jsonObject.toString()   //存
JSONObject.fromObject(redis.get("dpdtsj")); // 取

虽然不太好但是也可以用

使用阿里巴巴的json库可以解决swagger问题

JSON.toJSONString(list)    //list<dto> list<dto>转字符串存入
List<TollStation> list =JSON.parseArray(redis.get("sfzxx"),TollStation.class);   //取 并提供list中对象的类型 

String s = JSON.toJSONString(user);//dto转字符串
User user1 = JSON.parseObject(s, User.class);
String b="["+s+"]";
List<User> users = JSON.parseArray(b, User.class);   //字符串转 list<dto>

工具类

package com.eagle.common.utils;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @Author LiGuangLong
 * @Date 2021-11-01 10:18
 * @Version 1.0
 **/
@SuppressWarnings("ALL")
@Component
@Slf4j
public class RedisUtils {
    @Resource
    private RedisTemplate<String,Object> redisTemplate;


    public String get(String key){
        return  key == null ? null : (String) redisTemplate.opsForValue().get(key);
    }
    public Object getObject(String key){
        return  key == null ? null : redisTemplate.opsForValue().get(key);
    }
    public void set(String key,Object value){
        redisTemplate.opsForValue().set(key,value);
    }

    /**
     *本来只可以放入string类型，但是我们配置了自动序列化所以这儿可以传入object
     */
    public void setex(String key,Object value,long expire){
        redisTemplate.opsForValue().set(key,value,expire, TimeUnit.SECONDS);
    }
    public  <T> List<T> ObjectToList(Object obj, Class<T> clazz){
        List<T> result = new ArrayList<T>();
        if(obj instanceof List<?>) {
            for (Object o : (List<?>) obj) {
                result.add(clazz.cast(o));
            }
            return result;
        }
        return null;
    }
    public String ObjectToString(Object obj){
        return JSON.toJSONString(obj);
    }
    public <T> T StringToObject(String text, Class<T> clazz) {
        return JSON.parseObject(text, clazz);
    }
    public <T> List<T> StringToList(String text, Class<T> clazz) {
        return JSON.parseArray(text, clazz);
    }
    /**
     *判断key是否存在
     */
    public boolean exists(String key){
        return redisTemplate.hasKey(key);
    }

    public boolean expire(String key,long expire){
        return redisTemplate.expire(key,expire,TimeUnit.SECONDS);
    }


    /**
     *查看key过期时间
     */
    public long ttl(String key){
        return redisTemplate.getExpire(key);
    }
    public void del(String ...keys){
        if(keys!=null&&keys.length>0) {
            redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(keys));
        }
    }
    public long incrBy(String key,long step){
        return redisTemplate.opsForValue().increment(key,step);
    }
    public boolean setnx(String key,Object value){
        return redisTemplate.opsForValue().setIfAbsent(key,value);
    }
    public boolean setnxAndExpire(String key,Object value,long expire){
        return redisTemplate.opsForValue().setIfAbsent(key,value,expire,TimeUnit.SECONDS);
    }
    public Object getAndSet(String key,Object value){
        return redisTemplate.opsForValue().getAndSet(key,value);
    }
}

对于接口请求慢的可以放入redis 并设置超时时间

取得时候判断下