SpringBoot整合Redis，自定义Redis序列化以及Redis常用工具类分享

柒邯

已于 2022-10-26 15:34:08 修改

阅读量938

点赞数

于 2022-10-25 20:26:58 首次发布

本文链接：https://blog.csdn.net/g1024173314/article/details/127520957

版权

原文连接：SpringBoot整合Redis，自定义Redis序列化以及Redis常用工具类分享 - 柒邯

本次使用的SpringBoot版本为2.6.4。
首先导入pom.xml

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

设置配置application文件

spring.redis.host=127.0.0.1//根据自己的来
spring.redis.port=6379

导入好后编写自己的RedisTemplate
为什么要重写？因为原本的RedisTemplate有些不方便是RedisTemplate<Object, Object>类型
我们可以改成RedisTemplate<String, Object>类型
还可以自定义序列化

以下是使用Jackson序列化(推荐)

@Configuration
public class RedisConfig {
//qihan.tech
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //为了自己方便 一般使用<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        //序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om=new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); 好像过时了
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //String 序列化
        StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
        //key 采用String序列化
        template.setKeySerializer(stringRedisSerializer);
        //hash 的key采用String序列化
        template.setHashKeySerializer(stringRedisSerializer);

        //Value序列化采用Jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

还有一个比较经常的是Redis使用fastjson序列化
先导入相关的包

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.58</version>
</dependency>

fastjson 为RedisSerializer 接口提供了两个实现类GenericFastJsonRedisSerializer 和FastJsonRedisSerializer
GenericFastJsonRedisSerializer: 不支持设置FastJsonConfig 特性, 生成json串会多一个type参数， type的值为class 名称
FastJsonRedisSerializer: 支持设置FastJsonCofing 特性, 默认生成json串不包含type属性

注:高版本的Fastjson好像不提供实现类了，需要自己实现

以下是使用fastjson序列化redis

@Configuration
public class RedisConfig {
//qihan.tech
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
    {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //使用fastjson序列化

        GenericFastJsonRedisSerializer fastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
        // value值的序列化采用fastJsonRedisSerializer
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        // key的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

到这来基本上就可以使用Redis了，不过为了方便尝尝会封装一个工具类。
以下是Redis的常用工具类，可以满足日常大部分的需求。

@Component
public class RedisUtil {
    //封装redis方法
    //qihan.tech

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    //指定缓存消失时间     key 键    time 时间(秒)
    public boolean expire(String key,long time)
    {
        try{
            if (time>0)
            {
                redisTemplate.expire(key,time, TimeUnit.SECONDS);//TimeUnit.SECONDS表示秒  还有day
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    //根据key获取过期时间(秒)  key不能为空  return 0表示永久有效
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    //判断key是否存在    key键   true存在  false不存在
    public boolean haskey(String key){
        try{
            return redisTemplate.hasKey(key);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    //删除缓存   key键  可以传一个或者多个
    public void del(String... key){
        //String…是java5新加入的功能，表示的是一个可变长度的参数列表。
        //其语法就是类型后跟…，表示此处接受的参数为0到多个Object类型的对象，或者是一个Object[]。
        if (key!=null&&key.length>0)
        {
            if (key.length==1){
                redisTemplate.delete(key[0]);
            }else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    //获取key对应的值
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    //普通存入  key   value   true表示成功  false表示失败  默认存入表示无限期
    public boolean set(String key,Object value){
        try{
            redisTemplate.opsForValue().set(key,value);
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }
    //存入并且设置时间(秒)
    //key 键  value 值  time 时间 (秒) 小于等于0表示将设置无限期
    //true成功 false失败
    public boolean set(String key,Object value,long time){
        try{
            if (time>0)
            {
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }else {
                set(key, value);
            }
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }

    //递增   实现计数器 delta需要大于0
    public long incr(String key,long delta){
        if (delta<0){
            throw new RuntimeException("必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    //递减
    public long decr(String key,long delta){
        if (delta<0){
            throw new RuntimeException("必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //HashGet获取值   key 值  item项
    public Object hmget(String key,String item){

        return redisTemplate.opsForHash().get(key,item);
    }

    //获取hashKey对应所有的键值
    public Map<Object,Object>hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    //HashSet存入
    public boolean hset(String key,Map<Object,Object> map){
        try{
            redisTemplate.opsForHash().putAll(key,map);
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }
    //HashSet存入 并且设置时间(秒)
    public boolean hmset(String key,Map<Object,Object> map,long time){
        try{
            redisTemplate.opsForHash().putAll(key,map);
            if (time>0){
                expire(key, time);
            }
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }

    //向一张hash表中存入数据 如果不存在将被创建  key键  item项  value 值
    public boolean hset(String key,String item,Object value){
        try{
            redisTemplate.opsForHash().put(key,item,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    //向一张hash表中存入数据 如果不存在将被创建 并且设置时间  key键  item项  value 值
    public boolean hset(String key,String item,Object value,long time){
        try{
            redisTemplate.opsForHash().put(key,item,value);
            if (time>0){
                expire(key,time);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    //删除hash表中的值
    //key 键  item 项 可以多个 不能为空
    public void hdel(String key,Object... item){
        redisTemplate.opsForHash().delete(key, item);
    }

    //判断hash表中是否有该项的值
    //true 表示存在
    public boolean hHasKey(String key,String item){
        return redisTemplate.opsForHash().hasKey(key,item);
    }

    //hash递增  如果不存在 就创建一个并把新增的值返回
    //key 键 item项  by要增加几
    public double hincr(String key,String item,double by){
        return redisTemplate.opsForHash().increment(key,item,by);
    }

    //hash递减  如果不存在 就创建一个并把新增的值返回
    //key 键 item项  by要减多少
    public double hidecr(String key,String item,double by){
        return redisTemplate.opsForHash().increment(key,item,-by);
    }

    //根据key获取Set中所有的值
    public Set<Object> sGet(String key){
        try{
            return redisTemplate.opsForSet().members(key);
        }catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }

    //根据Value从一个set中查询，是否存在
    //true 存在
    public boolean sHasKey(String key,Object value){
        try{
            return redisTemplate.opsForSet().isMember(key, value);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    //将数据放入set缓存   key键  value 值 可以是多个
    //return  成功个数
    public long sSet(String key,Object... value){
        try{
            return redisTemplate.opsForSet().add(key, value);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    //将set数据放入缓存  并且设置时间(秒)
    //return 成功个数
    public long sSet(String key,long time,Object... values){
        try{
            long count =redisTemplate.opsForSet().add(key, values);
            if (time>0){
                expire(key,time);
            }
            return count;

        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    //获取set缓存长度
    public long sGetSetSize(String key){
        try{
            return redisTemplate.opsForSet().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    //移除值为value的
    //return 返回移除个数
    public long setRenove(String key,Object... value){
        try{
            return redisTemplate.opsForSet().remove(key, value);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    //获取list缓存的内容
    //key 键  start 开始  end结束0到-1 代表所有值
    public List<Object> lGet(String key,long start,long end){
        try{
            return redisTemplate.opsForList().range(key, start, end);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    //获取list缓存的长度 key键
    public long lGetListSize(String key){
        try{
            return redisTemplate.opsForList().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    //通过索引  获取list中的值
    public Object lGetIndex(String key,long index){
        try{
            return redisTemplate.opsForList().index(key,index);
        }catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }

    //将list放入缓存
    public boolean lSet(String key,Object value){
        try{
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }
    //将list放入缓存 并且设置时间（秒）
    public boolean lSet(String key,Object value,long time){
        try{
            redisTemplate.opsForList().rightPush(key, value);
            if (time>0){
                expire(key, time);
            }
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }
    //将List<Object>放入缓存
    public boolean lSet(String key,List<Object> value){
        try{
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }
    //将List<Object>放入缓存 并且设置时间（秒）
    public boolean lSet(String key,List<Object> value,long time){
        try{
            redisTemplate.opsForList().rightPush(key, value);
            if (time>0){
                expire(key, time);
            }
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }

    //根据索引 修改list某条数据的值
    public boolean lUpdateIndex(String key,long index,Object value){
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        }catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }

    //移除N个值为value的行为
    //return 返回被删除的个数
    public long lRemove(String key,long count,Object value){
        try {
            return redisTemplate.opsForList().remove(key, count, value);
        }catch (Exception e)
        {
            e.printStackTrace();
            return 0;
        }

    }

}

柒邯

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot整合Redis，自定义Redis序列化以及Redis常用工具类分享

SpringBoot整合Redis，自定义RedisTemplate，使用fastjson和Jackson来对Redis序列化以及Redis常用工具类分享
复制链接

扫一扫