SpringBoot使用Jedis实现zset数据类型获取过去24h的数据

最新推荐文章于 2023-09-24 21:39:38 发布
最新推荐文章于 2023-09-24 21:39:38 发布
阅读量736 收藏
点赞数 1
分类专栏： redis 文章标签： spring boot redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46075209/article/details/126804453
版权

介绍

Jedis 是 Redis 官方推荐的 Java 连接开发工具，提供了比较全面的 Redis 命令的支持。Jedis 中的方法调用是比较底层的暴露的 Redis 的 API，也即 Jedis 中的 Java 方法基本和 Redis 的 API 保持着一致，了解 Redis 的 API，也就能熟练的使用 Jedis。
  Jedis 使用阻塞的 I/O，且其方法调用都是同步的，程序流需要等到 sockets 处理完 I/O 才能执行，不支持异步。Jedis 客户端实例不是线程安全的，所以需要通过连接池来使用 Jedis。

今日内容

  • 通过读取配置文件的方式连接redis-cli
  • 实现Jedis添加数据 （zset类型）
  • 实现Jedis查询一天范围的数据

开始

引入的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <spring-boot.version>2.1.6.RELEASE</spring-boot.version>
        <fastjson.version>1.2.78</fastjson.version>
        <jedis.version>2.7.0</jedis.version>
        <mybatis.version>2.1.4</mybatis.version>
    </properties>

    <dependencies>
        <!--        解决@ConfigurationProperties()提示的问题-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>
        <!--        SpringBoot依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--        jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${jedis.version}</version>
        </dependency>
        <!--        lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <!--        mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

代码我就挑主要的介绍了

配置

yml配置
myredis:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    #客户端连接超时时间
    timeout: 10000
    #最小空闲数：低于minIdle时，将创建新的连接
    minIdle: 50
    #最大空闲数：空闲连接数大于maxIdle时，将进行回收
    maxIdle: 300
    #最大连接数据库连接数,设 0 为没有限制
    maxTotal: 5000
    #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制
    maxWaitMillis: 1000
    #重连次数
    retryNum: 5
配置类
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@ConfigurationProperties("myredis.redis")
@Data
@Configuration
public class RedisConfig {

    private String host;

    private Integer port;

    private String password;

    private Integer maxIdle;

    private Integer timeout;

    private Integer minIdle;

    private Integer maxTotal;

    private Integer maxWaitMillis;

    private Integer retryNum;
}

jedis工具类

package com.guyong.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;

@Configuration
public class JedisUtils {
    private Logger logger=Logger.getLogger(this.getClass().getName());

    @Autowired
    private RedisConfig config;

    private Map<String,JedisPool> maps = new HashMap<>();

    private JedisPool pool;


    /**
     * 获取jedis连接对象
     * @return
     */
    public  JedisPool getPool(){
        String key=config.getHost()+":"+config.getPort();
        //containsKey(key)判断是否包含指定键名
        if (!maps.containsKey(key)){
            JedisPoolConfig poolConfig = new JedisPoolConfig();
            poolConfig.setMaxIdle(config.getMaxIdle());
            poolConfig.setTestOnBorrow(true);
            poolConfig.setTestOnCreate(true);
            pool = new JedisPool(poolConfig, config.getHost(), config.getPort(), config.getMaxIdle());
            maps.put(key,pool);
        }else{
            pool=maps.get(key);
        }
        return pool;
    }


    /**
     * 连接jedis
     * @return
     */
    public Jedis getJedis(){
        Jedis jedis = null;
        int count = 0;
        do{
            try{
                count++;
                //getResource()获取资源
                jedis=getPool().getResource();
            }catch(Exception e){
                e.printStackTrace();
//                关闭连接池
                getPool().close();
//                关闭jedis
                jedis.close();
            }
        }while(jedis == null && count<config.getRetryNum());
        return jedis;
    }

    /**
     * 断开jedis
     * @param jedis
     */
    public void closeJedis(Jedis jedis){
        if (null != jedis){
            jedis.close();
//            pool.close();
        }
    }

    /**
     * 获取前24小时时间范围的值
     * @param key
     * @param jedis
     * @return
     */
    public Set<String> getZset(String key,Jedis jedis){
        //minusHours() 要减去的小时时间
        //起始时间为当前时间24小时前
        LocalDateTime sparseTimeStart = LocalDateTime.now().minusHours(24);
        //结束时间为当前时间
        LocalDateTime sparseTimeEnd = LocalDateTime.now();
        //toInstant(ZoneOffset.of("+8")) 先将localDateTime转换成0时区时间，而ZoneOffset表示偏移量，在这里表示localDateTime比0时区偏移了+8个小时
        //计算出时间戳.toEpochMilli()
        Set<String> strings = jedis.zrangeByScore(key, sparseTimeStart.toInstant(ZoneOffset.of("+8")).toEpochMilli(), sparseTimeEnd.toInstant(ZoneOffset.of("+8")).toEpochMilli());
        return strings;
    }


}

service

接口
import java.util.List;

public interface RedisService {

    /**
     *获取rediszset类型排序后的数据
     * @param paramTypeId
     * @return
     */
    List<DeviceParamLogVo> redisFindLog(Long paramTypeId);

    /**
     * 添加zset类型的数据
     * @param param
     */
    void AddData(String param);

}
实现类
package com.guyong.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.guyong.config.JedisUtils;
import com.guyong.constant.DataTypeConstant;
import com.guyong.dao.DeviceParamTypeDao;
import com.guyong.entity.DeviceParamType;
import com.guyong.service.DeviceParamTypeService;
import com.guyong.service.RedisService;
import com.guyong.vo.DeviceParamLogVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;

@Service
public class RedisServiceImpl implements RedisService {

    @Autowired
    private JedisUtils utils;

    @Autowired
    private DeviceParamTypeService deviceParamTypeService;

    @Override
    public List<DeviceParamLogVo> redisFindLog(Long paramTypeId) {
        Jedis jedis = utils.getJedis();
        try{
            DeviceParamType deviceParamType = deviceParamTypeService.findById(paramTypeId);
            String name = deviceParamType.getName();
            Integer dataType = deviceParamType.getDataType();
            String key = getCurrentDate();
            Set<String> zset = utils.getZset(key, jedis);
            List<DeviceParamLogVo> list = new ArrayList<>();
            zset.forEach((String s) -> {
                DeviceParamLogVo vo = new DeviceParamLogVo();
                //获取zset的score值
                Double zscore = jedis.zscore(key, s);
                long timestamp = zscore.longValue();
                String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(timestamp);
                DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                LocalDateTime parse = LocalDateTime.parse(format, df);
                //上传时间
                vo.setUpLoadTime(parse);
                JSONObject json = JSON.parseObject(s);
                String properties = json.get("properties").toString();
                JSONObject aJson = JSON.parseObject(properties);
                Object value;
                if (!properties.contains(deviceParamType.getName())) {
                    value = "0";
                } else {
                    value = deviceParamTypeService.getValue(aJson.get(name), dataType);
                }
                if (DataTypeConstant.LONG.equals(dataType)) {
                    vo.setCurrentValueLong(Long.parseLong(value.toString()));
                } else if (DataTypeConstant.DECIMAL.equals(dataType)) {
                    vo.setCurrentValueDecimal(new BigDecimal(value.toString()));
                }
                //属性名称
                vo.setAttributeName(deviceParamType.getTitle());
                //当前值
                vo.setCurrentValueString(String.valueOf(value));
                list.add(vo);
            });
            return list;
        }finally {
            utils.closeJedis(jedis);
        }
    }

    @Override
    public void AddData(String param) {
        //获取jedis连接
        Jedis jedis = utils.getJedis();
        //Double.parseDouble(System.currentTimeMillis() + "") 获取当前时间戳
        jedis.zadd(getCurrentDate(), Double.parseDouble(System.currentTimeMillis() + ""), param);
    }

    private static String getCurrentDate(){
        //获取当前时间转成年月日格式
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String day = simpleDateFormat.format(date);
        String key =day+"";
        return key;
    }
}

redisFindLog类的实现代码可以跟着实际的业务进行更改

结尾

zset的key值存储的是当前时间戳，value就是需要的取值
其实取前一天的时间范围就是根据时间戳范围进行取值

是程小姐呀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入学习 Redis - 深挖经典数据类型之 zset
CYK_byte的博客
07-27 6496
Zset 是一个有序且唯一的集合，在 zset 中的 member 同时引入了一个属性 score（分数），支持浮点类型，也就是说每一个 member 都安排一个分数，并且默认按照分数进行升序排序.
java获取zset_Redis Set和ZSet常用命令
weixin_42525328的博客
02-28 2247
Redis Set和ZSet常用命令Set1. SADD ：添加多个元素到集合中127.0.0.1:6379> sadd goodfood "potato" "tomato" "apple"(integer) 32. SMOVE 命令：移动集合元素到另一个集合中smove source destination member3. SUNIONSTORE 命令：保存多个集合元素到新集合中127....
Jedis操作Redis--SortedSet(ZSet)类型
weixin_38399962的博客
09-26 6425
Redis ZSet Redis中的ZSet是一个有序的Set，内部使用HashMap和跳表(SkipList)来保证数据的存储和有序，HashMap里放的是成员到score的映射，而跳跃表里存放的是所有的成员，排序依据是HashMap里存的score,使用跳跃表的结构可以获得比较高的查找效率，并且在实现上比较简单。 使用Jedis, 添加maven依赖 <!-...
Zset如何操作Redis--基于Jedis，Java版
qq_44231797的博客
03-21 3080
文章目录1、Zset概念2、Zset语法3、Zset在Jedis的示例 1、Zset概念 Zset有序集合(sorted set)： 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员即元素唯一！ 每个元素都会关联一个double类型的分数(score)，redis正是通过这些分数(score)对集合中的元素进行排序。 有序集合的元素是唯一的,但分数(score)却可以重复。 集合中最大的元素数为 2^32 - 1 (4294967295, 每个集合可存储40多亿个元素)。 2
在Spring Boot微服务使用JedisCluster操作Redis集群Zset(有序集合)
zhangbeizhen18的博客
06-09 1575
记录：453 场景：在Spring Boot微服务使用JedisCluster操作Redis集群的Redis集群Zset(有序集合)数据类型。
在Spring Boot微服务使用Jedis操作Redis Zset(有序集合)
zhangbeizhen18的博客
04-15 1026
记录：411 场景：在Spring Boot微服务使用Jedis操作Redis Zset(有序集合)。
SpringBoot学习秒杀一、SpringBoot集成Redis (使用Jedis实现)
12-22
【SpringBoot集成Redis (使用Jedis实现)】 在Spring Boot应用中集成Redis是一个常见的需求，因为Redis作为一个高性能的键值数据库，常用于缓存、消息队列等多种场景。本篇文章将介绍如何通过Jedis库来实现Spring ...
springboot-jedis.zip
06-07
Jedis则是Java语言的Redis客户端，提供了丰富的API来操作Redis服务器，支持多种数据类型和命令，如字符串、哈希、列表、集合、有序集合以及发布订阅等。 二、集成Jedis 1. 添加依赖：首先，我们需要在SpringBoot...
基于springboot,jedis,redis,mongodb,websocket的聊天系统websocket.zip
最新发布
05-25
该项目利用了基于springboot + vue + mysql的开发模式框架实现的课设系统，包括了项目的源码资源、sql文件、相关指引文档等等。 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理...
redis-cluster结合springboot的使用自定义序列化
12-05
本教程将深入探讨如何在SpringBoot应用中设置和使用Redis集群，并自定义序列化方法以便更方便地查看和管理缓存数据。 首先，我们来了解`springboot jedisCluster配置`。JedisCluster是Jedis库提供的一个类，用于...
Jedis对redis的五大类型操作代码详解
08-28
在JedisUtil类中，我们使用JedisPool来管理Jedis连接，使用getInstance()方法获取Jedis实例，并使用getJedis()方法获取Jedis连接。这样可以提高Redis连接的效率和可靠性。 本篇文章详细介绍了Jedis对Redis的五大...
学习笔记--redis
qq_54481534的博客
10-09 338
redis
基于Redis中 Zset数据类型实现各类高性能排行榜日榜、周榜（附上整合SpringBoot示例代码）
programming132的博客
11-08 5280
springboot操作redis种zset数据类型，实现日榜、周榜排行。本篇将引导大家实现高性能排行榜。
使用redis Zset根据score和时间从多个维度进行排序（Zset榜单多维度排序）
fengxiandada的博客
12-08 6011
使用redis Zset根据score和时间从多个维度进行排序（Zset榜单多维度排序）
SpringBoot中使用Redis保存对象
weixin_47345084的博客
11-03 2070
1、引入依赖 org.springframework.boot spring-boot-starter-data-redis 1234 2、配置主机 spring.redis.host=192.168.124.15 1 3、查看源码 4、配置类 @Configuration public class MyRedisConfig { @Bean public RedisTemplate<Object, Employee> empRedisTemplate(RedisConnectionF
SpringBoot：Redis中的zset
justlpf的专栏
04-20 649
【代码】SpringBoot：Redis中的zset。
Springboot整合Redis使用RedisTemplate操作redis五大类型用法详解
雾林小妖的博客
04-08 2967
主要讲解springboot整合redis后连接redis的集群服务。 通过RedisTemplate操作String、List、Hash、Set、Zset redisTemplate.opsForValue()用法 redisTemplate.opsForHash();用法 redisTemplate.opsForList();用法 redisTemplate.opsForSet();用法 redisTemplate.opsForZSet();用法
Redis——Jedis中zset类型使用
m0_60867520的博客
09-24 565
Redis‘的zset类型在Jedis中使用介绍，zadd，zrange, zcard, zrem, zscore, zrank
Redis使用ZSET实现消息队列使用总结
supeerzdj的博客
06-30 895
Java可以通过Redis的Java客户端包Jedis来使用Redis，Jedis提供了丰富的API来操作Redis，下面是一段实现用Redis的zset类型实现的消息队列的代码。成员和分数之间的映射关系：有序集合中的每个成员都有一个分数，这样就可以将相同的数据划分到不同的 queue 中，以及为每个 queue 设置不同的延时。Redis的zset有序集合是可以用来实现消息队列的，一般是按照时间戳作为score的值，将消息内容作为value存入有序集合中。一般来说，N取一个适当的数值，比如10。
jedis获取zset集合的所有成员
06-09
你可以使用Jedis中的zrange方法来获取ZSET集合中的所有成员。zrange方法的参数包括集合的key，开始和结束索引（在这里我们可以使用0和-1来表示从第一个元素到最后一个元素），并且可以选择是否返回成员的分数。 下面是使用Jedis获取ZSET集合中所有成员的示例代码： ```java Jedis jedis = new Jedis("localhost"); Set<String> members = jedis.zrange("myZset", 0, -1); ``` 这将返回一个包含所有成员的无序集合，你可以遍历该集合并打印出每个元素来查看所有的成员。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值