springboot下使用redis原生jedis 并使用zsort实现简单热词

最新推荐文章于 2024-04-11 09:27:09 发布
最新推荐文章于 2024-04-11 09:27:09 发布
阅读量779 收藏 3
点赞数
文章标签： redis springBoot jedis 热词搜索 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/frgzs/article/details/88407997
版权

1.redis依赖

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

2.redis配置文件 application.properties中添加

#=====redis config======
redis.sentinel.masterName=XXXXXXX
redis.host=XXXXXXX
redis.port=XXX
redis.password=XXXXX
redis.timeout=1000
redis.pool.maxTotal=200
redis.pool.maxWaitMillis=300
redis.pool.minIdle=10
redis.pool.maxIdle=50
redis.pool.testOnBorrow=true
redis.pool.testOnReturn=true
redis.pool.testWhileIdle=true
redis.sentinel.sentinel.list.host=ip:port,ip2:port2,ip3:port3
##=====redis config end======

3.初始化redis

public class RedisInit {
    private static String matserName;
    private static GenericObjectPoolConfig poolConfig;
    private static Set<String> sensitle;
    private static JedisSentinelPool jedisSentinelPool;

    private RedisInit() {
    }

    public static synchronized void init() {
        matserName = ConfigUtil.getProp("redis.sentinel.masterName");
        sensitle = new HashSet<>();
        String sentinelStr = ConfigUtil.getProp("redis.sentinel.sentinel.list.host");
        String[] split = sentinelStr.split(",");
        for (String sentinel : split) {
            sensitle.add(sentinel);
        }

        poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(Integer.parseInt(ConfigUtil.getProp("redis.pool.maxTotal")));
        poolConfig.setMaxWaitMillis(Long.parseLong(ConfigUtil.getProp("redis.pool.maxWaitMillis")));
        poolConfig.setMinIdle(Integer.parseInt(ConfigUtil.getProp("redis.pool.minIdle")));
        poolConfig.setMaxIdle(Integer.parseInt(ConfigUtil.getProp("redis.pool.maxIdle")));
        poolConfig.setTestOnBorrow(Boolean.parseBoolean(ConfigUtil.getProp("redis.pool.testOnBorrow")));
        poolConfig.setTestOnReturn(Boolean.parseBoolean(ConfigUtil.getProp("redis.pool.testOnReturn")));
        poolConfig.setTestWhileIdle(Boolean.parseBoolean(ConfigUtil.getProp("redis.pool.testWhileIdle")));
        jedisSentinelPool = new JedisSentinelPool(matserName, sensitle, poolConfig, 3000);
    }

    public static String getMatserName() {
        return matserName;
    }

    public static GenericObjectPoolConfig getPoolConfig() {
        return poolConfig;
    }

    public static Set<String> getSensitle() {
        return sensitle;
    }

    public static JedisSentinelPool getJedisSentinelPool() {
        return jedisSentinelPool;
    }
}

public class RedisClentFactory {


    public static Jedis getClient() {
        return RedisInit.getJedisSentinelPool().getResource();
    }
}

@Component
@Order(value = Ordered.LOWEST_PRECEDENCE)
public class ServiceInit implements InitializingBean {

    private static final Logger log = LoggerFactory.getLogger(ServiceInit.class);


    public ServiceInit() {
        super();
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("===============redis初始化开始===============");

        RedisInit.init();
        log.info("===============redis初始化完成===============");

    }
}

4.测试类以及zsort基本操作

@RunWith(SpringRunner.class)
@SpringBootTest
@WebAppConfiguration
public class Test {
    private static Logger logger = LoggerFactory.getLogger(Test.class);
    @Test
    public void test() {
        Jedis jedis1 =null;
        try{
            jedis1 =  RedisClentFactory.getClient();
            //评分降序前四个
            Set<String> keys1 = jedis1.zrevrange("res", 0, 3);
            System.out.println(keys1);
            //取相应member的分值
            System.out.println(jedis1.zscore("res","红楼梦w"));
            System.out.println(jedis1.zscore("res","qqqqqqq"));


            logger.info("清除元素清空，清除前长度={}",jedis1.zcard("res"));
            jedis1.zremrangeByRank("res",0,jedis1.zcard("res"));
            jedis1.zremrangeByRank("res1",0,jedis1.zcard("res1"));
            jedis1.zremrangeByRank("today",0,jedis1.zcard("today"));

            //清除分值为0的记录
            jedis1.zremrangeByScore("res",0,0);

            //填充初始化记录
            for(int i=1;i<4;i++){
                jedis1.zincrby("res",1,"A");
                jedis1.zincrby("today",-1,"A");
                jedis1.zincrby("res",1,"B");
                jedis1.zincrby("today",-1,"B");
                jedis1.zincrby("res",1,"C");
                jedis1.zincrby("today",-1,"C");
                jedis1.zincrby("res",1,"D");
            }
            jedis1.zadd("res",2,"E");
            
            logger.info("取并集前：");
            logger.info("resA======={}======",jedis1.zscore("res","A"));
            logger.info("resB======={}======",jedis1.zscore("res","B"));
            logger.info("resC======={}======",jedis1.zscore("res","C"));
            logger.info("resD======={}======",jedis1.zscore("res","D"));
            logger.info("resE======={}======",jedis1.zscore("res","E"));
            logger.info("today======{}======",jedis1.zscore("today","A"));
            logger.info("today======{}======",jedis1.zscore("today","B"));
            logger.info("today======{}======",jedis1.zscore("today","C"));
            Set<String> keys2 = jedis1.zrevrange("res", 0, 3);
            System.out.println(keys2);
            //并集
            jedis1.zunionstore("res1","res","today");
            jedis1.zunionstore("res","res","today");
            logger.info("并集后后：");
            logger.info("resA======={}======",jedis1.zscore("res","A"));
            logger.info("resB======={}======",jedis1.zscore("res","B"));
            logger.info("resC======={}======",jedis1.zscore("res","C"));
            logger.info("resD======={}======",jedis1.zscore("res","D"));
            logger.info("resE======={}======",jedis1.zscore("res","E"));
            logger.info("today======{}======",jedis1.zscore("today","A"));
            logger.info("today======{}======",jedis1.zscore("today","B"));
            logger.info("today======{}======",jedis1.zscore("today","C"));
            logger.info("test--------->");
            logger.info("res1A======={}======",jedis1.zscore("res1","A"));
            logger.info("res1B======={}======",jedis1.zscore("res1","B"));
            logger.info("res1C======={}======",jedis1.zscore("res1","C"));
            logger.info("res1D======={}======",jedis1.zscore("res1","D"));
            logger.info("res1E======={}======",jedis1.zscore("res1","E"));
            logger.info("过期时间={}",jedis1.ttl("res"));//-1永不过期
            Set<String> keys3 = jedis1.zrevrange("res", 0, 3);
            System.out.println(keys3);
            System.out.println("++++++++++++++++++++++++++++++++++++++");

        }catch (Exception e){
            logger.info("error",e);
        }finally {
            if (null != jedis1) {
                jedis1.close();
            }
        }
    }

  
}

5.zsort实现简单热词功能，展示7天内的热词

定义枚举

public enum HotWordEnum {
    RESULT("res"),
    DAY1("day1"),
    DAY2("day2"),
    DAY3("day3"),
    DAY4("day4"),
    DAY5("day5"),
    DAY6("day6"),
    DAY7("day7"),
    TOYDAY("today");

    private String value;

    private HotWordEnum(String value) {
        this.value = value;
    }

    public String getValue() {
        return this.value;
    }

    public void setValue(String value) {
        this.value = value;
    }

实现记录和返回

public class TestHotWord {

    private static Logger logger = LoggerFactory.getLogger(TestHotWord.class);

    /**
     * @param keyword
     * 热词统计，每查询一次数量加一
     */
    @Override
    public void hotWordStatistics(String  keyword){
        Jedis jedis =null;
        try{
            jedis = RedisClentFactory.getClient();
            //查询词分数加一
            jedis.zincrby(HotWordEnum.RESULT.getValue(),1,keyword);
            //当天数据减一
            jedis.zincrby(HotWordEnum.TOYDAY.getValue(),-1,keyword);
        }catch (Exception e){
            logger.error("HotWordServiceImpl error",e);
        }finally{
            if(null!=jedis){
                jedis.close();
            }
        }

    }

    /**
     * 获取指定数量的搜索热词
     * @param num
     * @return
     */
    @Override
    public List<String> getSortedHotWords(Integer num){
        Jedis jedis =null;
        try{
            jedis = RedisClentFactory.getClient();
            //热词搜索次数降序排列,取前num个
            Set<String> keys = jedis.zrevrange(HotWordEnum.RESULT.getValue(), 0, num-1);
            List<String> res = new ArrayList<>(keys);
            return res;
        }catch (Exception e){
            logger.error("HotWordServiceImpl error",e);
            return null;
        }finally{
            if(null!=jedis){
                jedis.close();
            }
        }
    }
}

定时任务0点更新

public class HotwordJob {
    private static final Logger logger = LoggerFactory.getLogger(HotwordJob.class);
    public void doJob() {
        logger.info("开始执行HotwordJob");
        Jedis jedis =null;
        try{
            jedis = RedisClentFactory.getClient();

            //时时搜索结果与七天前当日结果做并集，去除七天前数据
            jedis.zunionstore(HotWordEnum.RESULT.getValue(),HotWordEnum.RESULT.getValue(),HotWordEnum.DAY1.getValue());
            //清除分值为0的数据
            jedis.zremrangeByScore(HotWordEnum.RESULT.getValue(),0,0);

            //每日搜索结果集前移一天
            jedis.zremrangeByRank(HotWordEnum.DAY1.getValue(),0,jedis.zcard(HotWordEnum.DAY1.getValue()));
            jedis.zunionstore(HotWordEnum.DAY1.getValue(),HotWordEnum.DAY1.getValue(),HotWordEnum.DAY2.getValue());

            jedis.zremrangeByRank(HotWordEnum.DAY2.getValue(),0,jedis.zcard(HotWordEnum.DAY2.getValue()));
            jedis.zunionstore(HotWordEnum.DAY2.getValue(),HotWordEnum.DAY2.getValue(),HotWordEnum.DAY3.getValue());

            jedis.zremrangeByRank(HotWordEnum.DAY3.getValue(),0,jedis.zcard(HotWordEnum.DAY3.getValue()));
            jedis.zunionstore(HotWordEnum.DAY3.getValue(),HotWordEnum.DAY3.getValue(),HotWordEnum.DAY4.getValue());

            jedis.zremrangeByRank(HotWordEnum.DAY4.getValue(),0,jedis.zcard(HotWordEnum.DAY4.getValue()));
            jedis.zunionstore(HotWordEnum.DAY4.getValue(),HotWordEnum.DAY4.getValue(),HotWordEnum.DAY5.getValue());

            jedis.zremrangeByRank(HotWordEnum.DAY5.getValue(),0,jedis.zcard(HotWordEnum.DAY5.getValue()));
            jedis.zunionstore(HotWordEnum.DAY5.getValue(),HotWordEnum.DAY5.getValue(),HotWordEnum.DAY6.getValue());

            jedis.zremrangeByRank(HotWordEnum.DAY6.getValue(),0,jedis.zcard(HotWordEnum.DAY6.getValue()));
            jedis.zunionstore(HotWordEnum.DAY6.getValue(),HotWordEnum.DAY6.getValue(),HotWordEnum.DAY7.getValue());

            jedis.zremrangeByRank(HotWordEnum.DAY7.getValue(),0,jedis.zcard(HotWordEnum.DAY7.getValue()));
            jedis.zunionstore(HotWordEnum.DAY7.getValue(),HotWordEnum.DAY7.getValue(),HotWordEnum.TOYDAY.getValue());

            //清除当天结果集
            jedis.zremrangeByRank(HotWordEnum.TOYDAY.getValue(),0,jedis.zcard(HotWordEnum.TOYDAY.getValue()));

        }catch (Exception e){
            logger.error("HotWordServiceImpl error",e);
        }finally{
            if(null!=jedis){
                jedis.close();
            }
        }
    }

}
终将无路可逃
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot学习秒杀一、SpringBoot集成Redis (使用Jedis实现)
12-22
【SpringBoot集成Redis (使用Jedis实现)】 在Spring Boot应用中集成Redis是一个常见的需求，因为Redis作为一个高性能的键值数据库，常用于缓存、消息队列等多种场景。本篇文章将介绍如何通过Jedis库来实现Spring ...
Redis 有序集合实现排行榜（结合springboot实现）
和光同尘的博客
10-14 2005
Redis 有序集合(sorted set)和集合一样也是 string 类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序。有序集合的成员是唯一的，但分数(score)却可以重复。正是因为有分值，所以很适合用在排行榜业务中。下面举例对redis有序集合实现排行榜功能进行说明。 比如，业务需要某用户近30日工具使用率的排行榜。
SpringBoot中使用Jedis
GuessHat的博客
10-20 1255
SpringBoot中使用Jedis 1.pom依赖 <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> 2.创建配置类 ...
Redis数据类型, 在springboot中集成Redis
从零开始的异世界JAVA学习
01-06 1107
文章目录1.Redis数据类型String类型Hash类型List（列表类型）Set（无序集合）zset(sorted set：有序集合)2.可设置失效时间3.在springboot中集成Redis 1.Redis数据类型 string（字符串） hash（哈希） list（列表） set（集合 ) zset(sorted set：有序集合) 可安装可视化的Redis管理工具 连接之后,刷新一下;即可看到数据信息 String类型 最基础的键值对形式 string 类型是二进制形式。可以包含任何数
Springboot集成Redis做数据库缓存（原生版）
m0_51561690的博客
01-04 275
Springboot集成Redis做数据库缓存（原生版）
Redis的数据结构之Zsort和基本排序操作
CSDN甄子蛋
08-26 4782
package com.jiedistest; import java.util.HashMap; import java.util.Map; import java.util.Set; import com.tools.JedisDemo; import redis.clients.jedis.Jedis; public class JedisZsort { static JedisDe...
SpringBoot中使用Redis的完整实例
09-08
本文将详细讲解如何在SpringBoot项目中配置并使用Redis。 首先，我们需要在项目的`pom.xml`文件中引入SpringBoot的Redis启动器依赖。这将自动配置所需的Redis连接，并提供对Redis操作的API支持。以下是一个示例： ...
springboot中使用redis的方法代码详解
10-16
本文将详细介绍如何在Spring Boot 2.1.3版本中集成Redis，并展示两种使用Redis的方法：通过操作类和使用注解。 首先，为了安装Redis，我们可以利用Docker容器化技术。创建一个`docker-compose.yml`文件，配置如下：...
springboot中使用redis由浅入深解析
08-28
SpringBoot中使用Redis由浅入深解析 本文主要为读者介绍了SpringBoot中使用Redis的方法，具有较高的参考价值。下面将详细讲解使用Redis的步骤。 一、添加依赖 首先，在SpringBoot项目中添加Redis的依赖，使用以下...
SpringBoot使用Redis实现分布式锁
08-19
SpringBoot 使用 Redis 实现分布式锁 分布式锁是指在分布式系统中，多个节点或机器之间对共享资源的访问进行控制和协调，以避免冲突和竞争的机制。SpringBoot 使用 Redis 实现分布式锁是指使用 SpringBoot 框架和 ...
ZSortObject.cs
01-09
自动为Unity的2.5D游戏处理物体的遮挡关系
sortz:排序算法的集合
05-15
排序 排序算法的集合 安装 Node.js npm install sortz 浏览器 您也可以在浏览器中使用它。 通过npm安装并使用dist文件夹中的sortz.js文件。 例子： < script src =" ./node_modules/sortz/dist/sortz.js " > </ script > 用法 添加节点模块 const Sortz = require ( 'sortz' ) ; 基本用法 var animals = [ 'pig' , 'cow' , 'dog' , 'zebra' , 'cat' ] ; Sortz . QuickSort ( animals ) ; console . log ( animals ) ; // outputs: [ 'cat', 'cow', 'dog', 'pig', 'zebra' ] 比较功能 var
redis基本操作及数据类型命令
蜗牛敲代码的博客
11-01 3633
数据类型：string（字符串），list（链表），hash（哈希），set（集合），zsort（有序集合） 默认16个数据库，可通过配置文件修改。   基本操作 关于存取中文显示时是乱码，解决办法是启动客户端时加入 --raw（redis-cli --raw） config set requirepass 123456 设置密码 auth 123456 身份验证 ping 如果返回...
sort 和zsort的使用
weixin_45063957的博客
09-01 336
Redistemplete.boundSetOps("key"); public void testSet(){ BoundSetOperations operationLW =redisTemplate.boundSetOps("user:lw"); operationLW.add("A","B","C","D","E"); System.out.println("⽼王的粉丝:"+operationLW.members()); BoundSetOperations operationXD =redi.
Redis
路之痕
07-28 522
RedisRedis简介 开源的高性能键值对数据库，提供多种不同的键值数据类型适应于不同的存储需求； Redis:远程字典服务器(Remote Dictionary Server) 数据结构服务器，值可以为字符串(String)，哈希(Hash)，列表(List)，集合(Set)和有序集合(Sort set) key-value存储系统 性能极高 原子性 安装在ubuntu下安装：sudo apt-
深入浅出Redis（十二）：Redis的排序命令Sort
最新发布
关注菜菜的后端私房菜，获取更多技术干货~
04-11 912
本篇文章围绕Sort命令，深入浅出的解析Sort命令原理以及使用Sort命令使用新的等长数组来对list、set、zset对象进行排序，其中数组中的节点RedisSortObject存储元素地址和权值，先使用节点记录要排序对象中元素的地址和权值，再使用快速排序根据权值进行排序然后返回默认情况下权值为浮点型，如果是对字符串类型排序，需要使用alpha选项；想要使用其他key作为权值排序时使用by选项；限制结果集返回使用limit；想要返回其他key的值时使用get选项；
Redis：有序集合zset类型数据操作命令
dengfengling999的博客
07-03 982
单key ：多有序value有序集合兼顾List集合（有序，放入的顺序）和Set集合（无序，不能重复）的特点，但又与他们不同有序集合的元素关联一个分数，redis会自动根据这个分数进行排序，默认按照分数从小到大进行排序 有序集合类型(Zset)Redis 有序集合zset和集合set一样也是string类型元素的集合，且不允许重复的成员。不同的是zset的每个元素都会关联一个分数（分数可以重复），redis通过分数来为集合中的成员进行从小到大的排序。 1.zadd语法：zadd key score mem
Redis-有序集合(Zset)数据结构
一江溪水
10-06 1029
集合概念 Set Set类似于Java中的HashSet 。Redis中的set类型是一种无序集合，集合中的元 素没有先后顺序，并且不可重复。 当需要存储一个列表数据，又不不能出现重复数据时，Set 是一个很好的选择，并且set提供了判断某个成员是否在一个Set集合内的接口，List是没有这种接口的 可以基于set轻易实现交集、并集、差集的操作。Redis 可以非常方便的实现如共同关注、共同粉丝、共同喜好等功能。这个过程也就是求交集的过程。 Zset 和Set相比，sorted set增加了一个权重参数sc
Redis中的排序sort
Dazhu233的博客
05-01 1035
Redis中的排序sort        Redis的SORT命令可以对列表键、集合键或者有序集合键的值进行排序。        SORT命令对number列表元素排序        使用ALPHA选项对一个包含字符串值的集合键进行排序SORT&lt;key&gt;命令的实现        SORT命令的最简单执行形式为：        SORT&lt;key&gt;        这个命令可以对...
springboot整合redis和jedis
04-21
非常感谢您的提问！关于springboot整合redis和jedis的问题，我可以给您一些建议和参考。 首先，确保您已经在pom.xml中添加了spring-boot-starter-data-redis和jedis的依赖。 其次，您可以在application.properties中配置redis的相关参数，如下所示： spring.redis.host=your_redis_host spring.redis.port=your_redis_port spring.redis.password=your_redis_password spring.redis.database=your_redis_database 接着，在您的代码中，您可以注入RedisTemplate和JedisPool，来实现与redis的交互和连接池的管理。 最后，您可以根据具体需求，使用redis的各种API与数据进行交互，如set、get、incr等。 希望我的回答能对您有所帮助！如果还有其他问题，请随时提出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值