自定义封装Redis工具类Java-操作java对象

最新推荐文章于 2024-04-29 20:00:00 发布
最新推荐文章于 2024-04-29 20:00:00 发布
阅读量550 收藏 2
点赞数 3
分类专栏： java工具类 文章标签： redis java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuyuanshun/article/details/108501950
版权

自定义Redis工具类Java

简介redis

Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)

工具类方法简介

工具类操作的数据类型都为字符串,
工具类包含: 1.切换库方法 、2.通过key获取redis内容String、3.获取全部keys、
4.通过正则获取匹配的keys、5.通过keys获取多个结果集、6.通过keys获取多个结果集实体、
7.通过key删除内容、8.保存key和value值、9.保存key和value值同时设置保存时长（参数默认为秒）、
10.保存key和value值同时设置保存时长（时间参数0：秒 ；1：分； 2：时； 3：天； 其他值 默认 秒）、
11.保存key和自定义对象 设置保存时长、12.保存key和自定义对象集合 设置保存时长、
13.保存key和自定义对象 设置保存时长（保存可设置一段范围内随机值 如 5到10分钟内的随机值）、
14. 通过key获取自定义对象、15.通过key获取自定义对象集合

配置文件

使用的是springboot ,yml编写redis配置如下：

server:
  port: 6666
spring:
  # redis settings
  redis:
    host: 127.0.0.1
    port: 6379
    database: 1
    timeout: 0

核心工具类代码

工具类代码如下：

package cn.wys.utils;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang.StringUtils;
import org.json.JSONArray;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @program: Service
 * @description redis工具
 * @author: wys
 * @create: 2020-09-06 09:10
 **/
@Component
public class RedisServiceUtils {
    private Logger log = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 默认数据库
     */
    @Value("${spring.redis.database}")
    private Integer dbIndex;
    @Resource
    private ObjectMapper objectMapper;

    @PostConstruct
    public void init() {
        //改变切换库
        changeDatabase(dbIndex);
    }


    /**
     * 改变切换库
     *
     * @param indexDb redis库
     */
    private void changeDatabase(int indexDb) {
        try {
            JedisConnectionFactory connectionFactory = (JedisConnectionFactory) stringRedisTemplate.getConnectionFactory();
            //当前库 与要切换的库不相等 则切换
            if (connectionFactory.getDatabase() != indexDb) {
                connectionFactory.setDatabase(indexDb);
            }
        } catch (Exception e) {
            log.error("RedisServiceUtils.changeDatabase() indexDb:" + indexDb, e);
        }
    }

    /**
     * 获取key
     *
     * @param indexDb redis库
     * @param key     查询key
     * @return 返回value
     */
    public String getRedis(int indexDb, String key) {
        try {
            changeDatabase(indexDb);
            Object o = stringRedisTemplate.opsForValue().get(key);
            if (o != null) {
                String string = o.toString();
                if (StringUtils.isNotEmpty(string)) {
                    return string;
                }
            }
        } catch (Exception e) {
            log.error("RedisServiceUtils.getRedis() indexDb:" + indexDb + "\r\n" +
                    "key:" + key, e);
        }
        return null;
    }

    /**
     * 获取当前redis库中所有的key
     *
     * @param indexDb redis库
     * @return
     */
    public Set<String> getKeys(int indexDb) {
        try {
            return getKeys(indexDb, "*");
        } catch (Exception e) {
            log.error("RedisServiceUtils.getKeys() indexDb:" + indexDb + "\r\n" +
                    "key: *", e);
        }
        return null;
    }

    /**
     * 获取当前redis库中符合正则的key
     *
     * @param indexDb redis库
     * @return
     */
    public Set<String> getKeys(int indexDb, String pattern) {
        try {
            changeDatabase(indexDb);

            Set<String> keys = stringRedisTemplate.keys(pattern);
            if (keys != null && keys.size() > 0) {
                return keys;
            }
        } catch (Exception e) {
            log.error("RedisServiceUtils.getKeys() indexDb:" + indexDb + "\r\n" +
                    "pattern: " + pattern, e);
        }
        return null;
    }

    /**
     * 通过keys获取多个结果集
     *
     * @param indexDb redis库
     * @return
     */
    public List<String> multiGet(int indexDb, List<String> keys) {
        try {
            changeDatabase(indexDb);

            List<String> list = stringRedisTemplate.opsForValue().multiGet(keys);
            if (list != null && list.size() > 0) {
                return list;
            }
        } catch (Exception e) {
            log.error("RedisServiceUtils.multiGet() indexDb:" + indexDb + "\r\n" +
                    "key: " + keys, e);
        }
        return null;
    }

    /**
     * 通过keys获取多个结果集对象
     *
     * @param indexDb redis库
     * @return
     */
    public <T> List<T> multiGetType(int indexDb, List<String> keys, Class<T> valueType) {
        try {
            changeDatabase(indexDb);

            List<String> list = stringRedisTemplate.opsForValue().multiGet(keys);
            if (list != null && list.size() > 0) {
                List<T> tempList = new ArrayList<>(list.size());
                for (String s : list) {
                    tempList.add(objectMapper.readValue(s, valueType));
                }
                return tempList;
            }
        } catch (Exception e) {
            log.error("RedisServiceUtils.multiGetType() indexDb:" + indexDb + "\r\n" +
                    "key: " + keys, e);
        }
        return null;
    }


    /**
     * 删除key
     *
     * @param key
     */
    public void delRedis(int indexDb, String key) {
        try {
            changeDatabase(indexDb);
            stringRedisTemplate.delete(key);
        } catch (Exception e) {
            log.error("RedisServiceUtils.delRedis() indexDb:" + indexDb + "\r\n" +
                            "key:" + key
                    , e);
        }
    }

    /**
     * 设置key 和 value
     *
     * @param key
     * @param value
     */
    public void setRedis(int indexDb, String key, String value) {
        try {
            changeDatabase(indexDb);
            stringRedisTemplate.opsForValue().set(key, value);
        } catch (Exception e) {
            log.error("RedisServiceUtils.setRedis() indexDb:" + indexDb + "\r\n" +
                    "key:" + key + "\r\n" +
                    "value:" + value, e);
        }
    }


    /**
     * 设置key value和时间
     *
     * @param key
     * @param value
     * @param time
     */
    public void setRedis(int indexDb, String key, String value, Integer time) {
        try {
            changeDatabase(indexDb);
            stringRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } catch (Exception e) {
            log.error("RedisServiceUtils.setRedis() indexDb:" + indexDb + "\r\n" +
                    "key:" + key + "\r\n" +
                    "value:" + value + "\r\n" +
                    "time:" + time, e);
        }
    }

    /**
     * 设置key value 时间和时间单位
     *
     * @param key
     * @param value
     * @param time
     * @param timeUnitInt 0：秒 ；1：分； 2：时； 3：天； 其他值 默认 秒
     */
    public void setRedisTime(int indexDb, String key, String value, Integer time, Integer timeUnitInt) {
        try {
            changeDatabase(indexDb);
            TimeUnit timeUnit = setTimeUtil(timeUnitInt);
            stringRedisTemplate.opsForValue().set(key, value, time, timeUnit);
        } catch (Exception e) {
            log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
                            "key:" + key + "\r\n" +
                            "value:" + value + "\r\n" +
                            "time:" + time + "\r\n" +
                            "timeUnitInt:" + timeUnitInt
                    , e);
        }
    }

    /**
     * 设置key value 时间和时间单位
     * 保存 泛型
     *
     * @param key
     * @param value
     * @param time
     * @param timeUnitInt 0：秒 ；1：分； 2：时； 3：天； 其他值 默认 秒
     */
    public <T> void setRedisTime(int indexDb, String key, T value, Integer time, Integer timeUnitInt) {
        try {
            changeDatabase(indexDb);
            TimeUnit timeUnit = setTimeUtil(timeUnitInt);
            String redisValue = objectMapper.writeValueAsString(value);
            stringRedisTemplate.opsForValue().set(key, redisValue, time, timeUnit);
        } catch (Exception e) {
            log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
                            "key:" + key + "\r\n" +
                            "value:" + value + "\r\n" +
                            "time:" + time + "\r\n" +
                            "timeUnitInt:" + timeUnitInt
                    , e);
        }
    }

    /**
     * 设置key value 时间和时间单位
     * 保存 泛型集合
     *
     * @param key
     * @param values
     * @param time
     * @param timeUnitInt 0：秒 ；1：分； 2：时； 3：天； 其他值 默认 秒
     */
    public <T> void setRedisTime(int indexDb, String key, List<T> values, Integer time, Integer timeUnitInt) {
        try {
            changeDatabase(indexDb);
            TimeUnit timeUnit = setTimeUtil(timeUnitInt);
            String redisValue = objectMapper.writeValueAsString(values);
            stringRedisTemplate.opsForValue().set(key, redisValue, time, timeUnit);
        } catch (Exception e) {
            log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
                            "key:" + key + "\r\n" +
                            "values:" + values + "\r\n" +
                            "time:" + time + "\r\n" +
                            "timeUnitInt:" + timeUnitInt
                    , e);
        }
    }

    /**
     * 设置key value 时间和时间单位
     * 保存 泛型集合
     *
     * @param key
     * @param values
     * @param startTime
     * @param endTime
     * @param timeUnitInt 0：秒 ；1：分； 2：时； 3：天； 其他值 默认 秒
     */
    public <T> void setRedisTimeRandom(int indexDb, String key, Collection<T> values, Integer startTime, Integer endTime, Integer timeUnitInt) {
        try {
            //切换库
            changeDatabase(indexDb);
            //获取随机保存时间
            Integer randomTime = getRandom(startTime, endTime);
            // 传入Integer值 返回 TimeUnit时间类型
            TimeUnit timeUnit = setTimeUtil(timeUnitInt);
            //转json
            String redisValue = objectMapper.writeValueAsString(values);
            //保存
            stringRedisTemplate.opsForValue().set(key, redisValue, randomTime, timeUnit);
        } catch (Exception e) {
            log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
                            "key:" + key + "\r\n" +
                            "values:" + values + "\r\n" +
                            "startTime:" + startTime + "\r\n" +
                            "endTime:" + endTime + "\r\n" +
                            "timeUnitInt:" + timeUnitInt
                    , e);
        }
    }

    /**
     * 传入Integer值 返回 TimeUnit时间类型
     *
     * @param timeUnitInt 0：秒 ；1：分； 2：时； 3：天； 其他值 默认 秒
     * @return
     */
    private TimeUnit setTimeUtil(Integer timeUnitInt) {
        TimeUnit timeUnit = null;
        if (timeUnitInt == null) {
            timeUnitInt = 0;
        }
        switch (timeUnitInt) {
            case 1:
                timeUnit = TimeUnit.MINUTES;
                break;
            case 2:
                timeUnit = TimeUnit.HOURS;
                break;
            case 3:
                timeUnit = TimeUnit.DAYS;
                break;
            default:
                timeUnit = TimeUnit.SECONDS;
        }
        return timeUnit;
    }

    /**
     * @param indexDb   redis 库 默认 spring.redis.database
     * @param redisKey  redis key
     * @param valueType 返回集合的 类型
     * @param <T>       泛型
     * @return
     */
    public <T> T getRedisValue(Integer indexDb, String redisKey, Class<T> valueType) {
        try {
            //默认redis 库
            if (indexDb == null) {
                indexDb = dbIndex;
            }
            //通过key 获取redis 内容
            String redis = getRedis(indexDb, redisKey);
            if (StringUtils.isBlank(redis)) {
                //key不存在 或失效返回 null
                return null;
            }
            T item = objectMapper.readValue(redis, valueType);
            return item;
        } catch (Exception e) {
            log.error("RedisServiceUtils.getRedisValue() indexDb:" + indexDb + "\r\n" +
                    "redisKey:" + redisKey + "\r\n" +
                    "valueType:" + valueType + "\r\n", e);
        }
        return null;
    }

    /**
     * @param indexDb   redis 库 默认 spring.redis.database
     * @param redisKey  redis key
     * @param valueType 返回集合的 类型
     * @param <T>       泛型
     * @return
     */
    public <T> List<T> getRedisValueList(Integer indexDb, String redisKey, Class<T> valueType) {
        try {
            //默认redis 库
            if (indexDb == null) {
                indexDb = dbIndex;
            }
            //通过key 获取redis 内容
            String redis = getRedis(indexDb, redisKey);
            if (StringUtils.isBlank(redis)) {
                //key不存在 或失效返回 null
                return null;
            }
            //解析
            JSONArray redisJsonArray = new JSONArray(redis);
            List<T> redisList = new ArrayList<>(redisJsonArray.length());
            //封装
            for (int i = 0; i < redisJsonArray.length(); i++) {
                T item = objectMapper.readValue(redisJsonArray.getString(i), valueType);
                redisList.add(item);
            }
            //返回
            return redisList;
        } catch (Exception e) {
            log.error("RedisServiceUtils.getRedisValueList() indexDb:" + indexDb + "\r\n" +
                    "redisKey:" + redisKey + "\r\n" +
                    "valueType:" + valueType + "\r\n", e);
        }
        return null;
    }


    private Integer getRandom(Integer start, Integer end) {
        //创建Random类对象
        Random random = new Random();
        //产生随机数
        int number = random.nextInt(end - start + 1) + start;
        //打印随机数
        log.info("RedisServiceUtils.getRandom() start:" + start + "\r\n" +
                "end:" + end + "\r\n" +
                "return number:" + number);
        return number;
    }
}

maven引入

pom.xml如果没有引入的话可以按照以下引入：

 <!--redis start-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!--redis end-->

结束

如使用中发现问题，可以随时留言。
编写不易，如对您有用的话点个赞鼓励一下吧！

wuyuanshun
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
redis 存储java对象_安装redis 并把java对象存放在redis中
weixin_36027743的博客
02-13 360
一、下载的安装包解压到盘符的指定位置，如下结构：(纯手敲，如果有缺失，见谅)Redis.docredis-benchmark.exeredis-check-aop.exeredis-check-dump.exeredis-cli.exeRedisQFork_8524.datredis-server.exeRedisService.doc我的安装路径：D:\install_tool\redis\re...
微服务常用组件封装项目过程详细介绍总述(六)---基于springboot的自定义redis starter组件开发
weixin_47407416的博客
12-16 1466
对redis进行springboot starter组件封装，同时提供redis常用的操作方法封装，引入改starter即可直接使用redis
Java操作Redis存储对象类型数据
干了10几年测试的老油条的博客
12-24 9183
背景描述      关于JAVA去操作Redis时，如何存储一个对象的数据，这是大家非常关心的问题，虽然官方提供了存储String，List，Set等等类型，但并不满足我们现在实际应用。存储一个对象是非常常见的。经过网上查找资料以及参考其他网友的代码和实践操作后，整理出Redis如何存储一个对象的demo代码，如果有错误的地方大家可以留言指出。 参考资料 参考地址: https://blo...
Java中配置和使用Redis
最新发布
分享式获得也是一种学习的态度
04-29 837
每个人都有惰性，但不断学习是好好生活的根本，共勉！
redis只查前5条数据_前5个基于Redis的Java对象
weixin_32667011的博客
02-01 1273
Redis具有很多值得推荐的功能，包括速度，可伸缩性和可用性。但是，有一个问题是Redis不包括对Java之类的编程语言的内置支持。相反，用户需要为Redis安装第三方Java客户端，例如Redisson。Redisson是Redis Java客户端，其中包含许多熟悉的Java对象，接口和集合，这使Java开发人员比以往任何时候都更容易地开始使用Redis。下面，我们将讨论Radisson用户所依...
Redis的缓存问题（四）将redis常用操作封装成工具类
金鳞踏雨
08-25 1063
1. 将任意的Java对象序列化为json并储存在string类型的key中，并且可以设置时间。2. 将任意的Java对象序列化为json并储存在string类型的key中，并且可以设置时间，用于缓存击穿。3. 根据指定的key查询缓存，并反序列化为指定类型，利用的方式解决缓存穿透。4. 根据指定的key查询缓存，并反序列化为指定类型，利用解决缓存击穿。
Redis 和 Springboot基础整合
晴天天天蓝
04-13 457
思路 使用string存储。如果需要存储对象，建议将对象转为json字符串再存储。 环境 框架 Springboot spring-boot-starter-parent版本：1.5.15.RELEASE pom.xml &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; ...
13 Redis 的扩展类型GEO和自定义数据类型
热门推荐
海陆云的博客
12-06 3万+
13 Redis 的扩展类型GEO和自定义数据类型前言一、GEO 的底层结构二、GeoHash 的编码方法总结 前言 在日常生活中，我们越来越依赖搜索“附近的餐馆”、在打车软件上叫车，这些都离不开基于位置信息服务（Location-Based Service，LBS）的应用。LBS 应用访问的数据是和人或物关联的一组经纬度信息，而且要能查询相邻的经纬度范围，GEO 就非常适合应用在 LBS 服务的场景中。 一、GEO 的底层结构 叫车服务为例，来分析下 LBS 应用中经纬度的存取特点。 每一辆网约车都有一
Java自写的工具类代码
06-03
内部包含前后端Result类代码，redis，zookeeper，算法，自定义异常，分布式锁等常用框架所涉及到的基本封装
JAVA上百实例源码以及开源项目
01-03
　Java二进制IO类与文件复制操作实例，好像是一本书的例子，源代码有的是独立运行的，与同目录下的其它代码文件互不联系，这些代码面向初级、中级Java程序员。 Java访问权限控制源代码 1个目标文件 摘要:Java源码,...
Java 208道面试.docx
06-14
- Lock接口和并发工具类：如ReentrantLock、Semaphore、CountDownLatch等。 6. **反射**： - 反射API：Class类、Constructor类、Method类和Field类的使用。 - 动态代理：了解JDK动态代理和CGLIB动态代理的实现...
Redis的java工具类,Jedisutil
07-27
该工具包含该了JedisPool等,详情链接http://blog.csdn.net/miniduhua/article/details/76219737
Java精选面试题.pdf
09-23
- **封装**：封装是面向对象编程的核心概念，通过创建类并定义私有变量和公共方法来隐藏内部实现细节。 - **继承**：允许一个类（子类）继承另一个类（父类）的属性和方法，实现代码复用。 - **多态**：允许使用...
Java微服务架构163课
12-26
全套微服务架构，视频学习java微服务架构，包括如下 第1章 微服务简介 001构建单体应用 002微服务解决复杂问题 003微服务的优点 004微服务的缺点 第2章 Linux使用 005Linux 简介 006Linux 与 Windows ...
Java工具类之——RedisUtils类
laomadawei的博客
04-24 2425
同C3P0一样，这个是需要配置文件的类，配置文件的格式为properties格式，放在src目录之下，需要用到的工具包为两个，分别是：commons-pool2-2.3.jar和jedis-2.7.0.jarmaxIdle=20 maxTotal=100 minIdle=10 host=192.168.75.140 port=6379Java代码中涉及到了一点反射方面的知识import java....
Java：Java Redis工具类
是蟹老板的博客
10-16 996
Java Redis工具类
SpringBoot整合Redis
qq_42472710的博客
02-01 212
1、导入jar包 <!-- 操作redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- lombok --> <dependency> <gr
SpringBoot整合Redis限制IP频繁访问
窗台上的懒猫
09-13 1510
编写一个redis工具类 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.connection.DataType; import org.springframework.data.redis.core.Cursor; import org.springframework.data.redis.core.ScanOptions; import org.s
RedisUtils工具类-
酷萌的汉子
12-19 2690
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Component; import org.springframework.util.CollectionUtils; import java.util.List; import java..
java redis缓存工具类_redis工具类-JedisUtil
05-18
JedisUtil是一个Java Redis缓存工具类，它封装了Jedis客户端的基本操作，使得使用Redis缓存更加简单方便。 以下是JedisUtil的示例代码： ``` import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wuyuanshun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值