Redis工具

最新推荐文章于 2024-07-23 10:13:20 发布
最新推荐文章于 2024-07-23 10:13:20 发布
阅读量1.2k 收藏
点赞数
分类专栏： Redis 文章标签： java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48903815/article/details/123689779
版权
本文介绍了如何在Spring Boot项目中集成Redis，并通过RedisTemplate实现常见的缓存操作，如设置、获取、删除键值对，以及设置过期时间和处理列表、映射等数据结构。配置包括在pom.xml中添加依赖，编写RedisConfig配置类，定义RedisService接口及其实现类RedisServiceImpl。
摘要由CSDN通过智能技术生成

黑发不知勤学早，白首方悔读书迟

网上好多RedisUtil工具类，这里给大家展示用接口来实现，我们可以注入后直接调用：
注：
里面的方法并不全面，有没涉及到的方法可以进入到RedisTemplate看源码中的方法，然后写到接口中实现一下就可以使用。

例子：

  private RedisService redisService;
  public void redisTest(@RequestBody User user) {
        User user1 = new User("loveLetter", 18, "测试");
        boolean set = redisService.set(user.getId(), user1);
        System.out.println("Redis set key:" + set);
        System.out.println("Redis get key:"+redisService.get(user.getId()));
    }

控制台输出：
在这里插入图片描述

1、在pom里引入Maven依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、配置RedisConfig
package com.loveletter.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
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.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author loveLetter
 * @create 2022/3/23
 */
@Configuration
public class RedisConfig {

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate redisTemplate = new StringRedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        /**
         * 通用的序列化和反序列化设置
         * ObjectMapper类是Jackson库的主要类。它提供一些功能将转换成Java对象匹配JSON结构，反之亦然。
         */
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // key序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}
3、新建RedisService
package com.loveletter.redis;

import java.util.List;
import java.util.Map;

/**
 * @author loveLetter
 * @create 2022/3/23
 */
public interface RedisService {
    /**
     * 批量删除
     *
     * @param keys key数组
     */
    public void remove(final String... keys);

    /**
     * 批量删除指定key
     *
     * @param pattern
     */
    public void removePattern(final String pattern);

    /**
     * 删除指定key
     *
     * @param key
     */
    public void remove(final String key);

    /**
     * 判断指定key是否存在
     *
     * @param key
     * @return
     */
    public boolean exists(final String key);

    /**
     * 设置key的过期时间(秒)
     *
     * @param key
     * @param expireTime
     */
    public void refreshExpireTime(final String key, Integer expireTime);

    /**
     * 获取指定key
     *
     * @param key
     * @return
     */
    public Object get(final String key);

    /**
     * 添加key-value（使用默认失效时间1天）
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value);

    /**
     * 添加key-value（指定失效时间）
     *
     * @param key
     * @param value
     * @param expireTime 失效时间为null则永久生效（单位秒）
     * @return
     */
    public boolean set(final String key, Object value, Integer expireTime);

    /**
     * 插入list
     *
     * @param key
     * @param list
     * @param <T>
     */
    <T> boolean setList(String key, List<T> list);

    /**
     * 插入list
     *
     * @param key
     * @param list
     * @param expireTime
     * @param <T>
     */
    <T> boolean setList(String key, List<T> list, Integer expireTime);

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    boolean lSet(String key, Object value);

    /**
     * 将list放入缓存
     *
     * @param key        键
     * @param value      值
     * @param expireTime 超时时间秒
     * @return
     */
    boolean lSet(String key, Object value, Integer expireTime);

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    boolean rSet(String key, Object value);

    /**
     * 将list放入缓存
     *
     * @param key        键
     * @param value      值
     * @param expireTime 超时时间秒
     * @return
     */
    boolean rSet(String key, Object value, Integer expireTime);

    /**
     * 取list
     *
     * @param key
     * @param <T>
     * @return
     */
    <T> List<T> getList(String key);

    /**
     * 存储map
     *
     * @param key
     * @param map
     * @param expireTime 失效时间为null则永久生效（单位秒）
     * @return
     */
    public <K, HK, HV> boolean setMap(K key, Map<HK, HV> map, Integer expireTime);

    /**
     * 获取map
     *
     * @param key
     * @param <K>
     * @param <HK>
     * @param <HV>
     * @return
     */
    public <K, HK, HV> Map<HK, HV> getMap(final K key);

    /**
     * redis计数器
     *
     * @param key
     * @return
     */
    Integer incr(String key);
}
4、新建RedisServiceImpl
package com.loveletter.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author loveLetter
 * @create 2022/3/23
 */
@Service
public class RedisServiceImpl implements RedisService {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 一天有多少分钟，默认时间是一天
     */
    private static final Integer MINUTES_OF_ONE_DAY = 24 * 60;

    //private static ObjectMapper objectMapper = new ObjectMapper();

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

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

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

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

    /**
     * 更新缓存时间
     *
     * @param key
     * @param expireTime
     */
    @Override
    public void refreshExpireTime(final String key, Integer expireTime) {
        if (exists(key)) {
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        }
    }

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

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

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

    /**
     * 插入list
     *
     * @param key
     * @param list
     * @param <T>
     */
    @Override
    public <T> boolean setList(String key, List<T> list) {
        return setList(key, list, MINUTES_OF_ONE_DAY * 60);
    }

    @Override
    public <T> boolean setList(String key, List<T> list, Integer expireTime) {
        return set(key, list, expireTime);
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    @Override
    public boolean lSet(String key, Object value) {
        return lSet(key, value, 0);
    }

    /**
     * 将list放入缓存
     *
     * @param key        键
     * @param value      值
     * @param expireTime 超时时间秒
     * @return
     */
    @Override
    public boolean lSet(String key, Object value, Integer expireTime) {
        try {
            redisTemplate.opsForList().leftPush(key, value);
            if (expireTime > 0) {
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    @Override
    public boolean rSet(String key, Object value) {
        return lSet(key, value, 0);
    }
    
    /**
     * 将list放入缓存
     *
     * @param key        键
     * @param value      值
     * @param expireTime 超时时间秒
     * @return
     */
    @Override
    public boolean rSet(String key, Object value, Integer expireTime) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (expireTime > 0) {
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    
    /**
     * 取list
     *
     * @param key
     * @param <T>
     * @return
     */
    @Override
    public <T> List<T> getList(String key) {
        Object jsonStr = get(key);
        if (jsonStr == null) {
            return null;
        }
        try {
            return (List<T>) jsonStr;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public <K, HK, HV> boolean setMap(K key, Map<HK, HV> map, Integer expireTime) {
        HashOperations<K, HK, HV> operations = redisTemplate.opsForHash();
        operations.putAll(key, map);

        if (expireTime != null) {
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        }
        return false;
    }

    @Override
    public <K, HK, HV> Map<HK, HV> getMap(final K key) {
        HashOperations<K, HK, HV> operations = redisTemplate.opsForHash();
        return operations.entries(key);
    }


    /**
     * redis计数器
     *
     * @param key
     * @return
     */
    @Override
    public Integer incr(String key) {
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        try {
            //此方法会先检查key是否存在，存在+1，不存在先初始化，再+1
            ops.increment(key, 1);

            return (int) get(key);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        return 0;
    }
}
情书
关注
专栏目录
java用set报空指针_redisService.set方法报空指针
weixin_42353186的博客
02-27 1099
package com.game.brag.server;import java.util.HashSet;import java.util.Set;import org.nutz.dao.Dao;import org.nutz.integration.jedis.RedisService;import org.nutz.ioc.loader.annotation.Inject;import or...
Redis工具类
coderWang
05-28 219
RedisUtil package com.qrcode.token; import java.util.List; import java.util.concurrent.TimeUnit; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.red...
Redis数据类型之Set（四）
a81561826的博客
06-20 134
前言:set类似于数学上面的集合概念，包含的元素无序，不能重复，能进行交、并、差操作。 一、内部原理 set数据结构，也是随着元素数目的多少而变化。当set中添加的元素都是整数且元素数据较少时，set使用intset为底层的数据结构，否则，set使用dict作为底层的数据结构。 intset是什么？ ...
Redisson中RSet的使用场景及用它来做网站独立访客统计的例子
最新发布
qq_40592590的博客
07-23 1105
网站访客统计
Redisson_RMap/RSet系列
看表该写博客了
04-11 2396
RMap是基于Redis的分布式集合中的数据结构”映射Map“，是Redisson提供的一种高性能组件。继承于接口 java.util.Map和java.util.concurrent.ConcurrentMap,所以不仅拥有了两者的功能，同时自身也提供了很多特有的方法。
Redis使用
小菜鸟博客
09-28 186
Redis使用
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
redis工具类以及redis 连接池配置
07-01
创建jedis池配置实例，redis各种crud方法，包括使用主从同步，读写分离。工具类中包括存放hash表键值对，键值对以map的方式储存，删除键值对，永久存放键值对，设置过期时间，需要的直接去gitHab上看...
spring-redis工具类
04-22
Spring整合Redis工具类，导入redis依赖，并使用工具类，不必使用RedisTemplate调用redis，并且采用java更常用的方式调用方法。
Windows 64 Redis 工具
01-04
"Windows-X64-Redis工具"正是针对这样的环境提供的一套实用工具集。 该压缩包中的主要组件是 "Redis"，这通常指的是Redis的Windows 64位版本。安装和运行Redis在Windows上与在Linux等其他操作系统上的方式略有不同...
redis分别存取rstring/list/set/zset/hash等数据类型
wangfeng117254的博客
01-22 221
1、redisTemplate的基本配置 spring: ## redis 配置 redis: host: 192.168.28.200 port: 6379 2、redisTemplate配置类 使用redisTemplate需要首先在spring容器中初始化该配置类，配置主要是对key和value序列化的方式进行设定，这里的key和value分别采用string,object的数据类型，key使用string序列化方式，value使用json序列化方式，这样可以基本满足绝大部分的
Spring Boot集成redis，实现redisService ，动态设置数据缓存时间
码农六子
07-17 4676
1、导入maven依赖 &lt;!-- springboot整合 redis --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-redis&lt;/artifactId&gt; &lt...
redis—Zset有序集合
终为nullptr
01-30 1318
redis—Zset有序集合介绍。
业务场景系列:更新Redis中设置过期时间Key的值
lumingzhu111的博客
04-25 1949
1.需求分析 在编写一个插入数据的接口，这个接口是对接前端的的，前端的功能大致就是用户浏览和留言，因为这个页面是无登录的，只要是使用者都可以提交这个数据，这个接口是公开的，为了避免有恶意的数据提交请求导致大量的脏数据保存，造成程序卡顿甚至宕机，对这个接口进行优化改造。 2.初级构思 在用户发送请求时，传过来的同时有HttpServletRequest，从这个里面可以获取用户的IP地址，利用Redis可以设置过期Key的方式，以ration加上用户IP为key，插入的value为可以提交数据的次数，然后设置过
利用Redis锁解决并发问题
软件研发实战应用技术分享
10-11 2531
用redis处理高并发是个很常见的方式，因为redis的访问效率很高（直接访问内存），一般我们会用来处理网站一瞬间的并发量。 那如果要使用redis来进行高并发问题的解决的话，应注意以下几点： 1、首先我们要先知道，我们在存储时，应使用redis的setnx方法，不应该使用set方法，因为setnx拥有原子操作命令（正确点说法应该是使用setnx，根据其属性可以保证共享资源的原子性操作），当资源锁...
springboot-redis，java redis
草叶儿的博客
10-19 334
redis从入门到放弃1.安装配置redis2.先新建一个springboot项目3.添加依赖（xml）4.配置（yml）5.配置文件Config(直接导入的)RedisConfig6.redis的接口和实现(直接导入的。底层代码？？)redisServiceredisServiceImpl7.开始使用CacheServiceCacheServiceImpl8.调用缓存接口 1.安装配置redis 管理员运行cmd 到安装目录下 redis-server.exe redis.windows.conf wi
SpringBoot整合Redis工具类
"redis工具类是用于简化springboot与redis集成时操作的辅助类，它提供了对redis各种数据类型的存取及设置过期时间等方法。" 在Spring Boot项目中，集成Redis作为缓存或持久化存储是常见的需求。`RedisUtil`是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值