百度360必应搜狗淘宝本站头条
php redisredis 命令redis 锁redis 主从redis 删除
当前位置：网站首页 > 技术教程 > 正文

Redis学习2——SpringBoot整合Redis，Redis工具类

mhr18 2024-12-06 17:44 19 浏览 0 评论

1. 依赖和配置

1.1. pom.xml

SpringBoot整合Redis，需要引入spring-boot-starter-data-redis依赖

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

当我们需要配置redis的连接池时，还需要引入commons-pool2依赖

 <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

1.2. application.yml配置

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    jedis:
      pool:
        max-idle: 8
        max-active: 8
        min-idle: 0

这里的jedis指的是使用jedis客户端，这里也可以将jedis改为lettuce，表示使用lettuce客户端，客户端下面的pool表示的是连接池的相关配置。

上述的配置针对的是单机redis配置，如果使用的是集群，配置如下：

spring:
  redis:
    password: 123456
    cluster:
      nodes: 10.255.144.115:7001,10.255.144.115:7002,10.255.144.115:7003,10.255.144.115:7004,10.255.144.115:7005,10.255.144.115:7006
      max-redirects: 3

2. RedisTemplate

上述的配置完毕后，我们就可以在项目中操作redis了，操作的时候，可以直接使用spring-boot-starter-data-redis为我们提供的RedisTemplate这个类，也可以使用StringRedisTemplate，两者的方法基本一致，后者可以看作RedisTemplate<String, String> 。

在上一节中，提到，Redis有多种数据类型，比如string、list、hash、set、zset等，这些类型的操作在RedisTemplate分别对应opsForValue(), opsForList(), opsForHash(), opsForSet(), opsForZSet()。

具体的操作演示如下：


@SpringBootTest
public class RedisAppTest {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void testGet() {
        System.out.println("字符串操作=================");
        redisTemplate.opsForValue().set("name", "cxy");
        System.out.println(redisTemplate.opsForValue().get("name"));

        System.out.println("列表操作");
        redisTemplate.opsForList().leftPush("school", "华南理工大学");
        redisTemplate.opsForList().leftPush("school", "中山大学");
        redisTemplate.opsForList().leftPush("school", "华南农业大学");
        List<String> school = redisTemplate.opsForList().range("school", 0, 5);
        for (String s : school) {
            System.out.print(s + " ");
        }
        System.out.println();

        System.out.println("hash操作");
        redisTemplate.opsForHash().put("student", "name", "cxy");
        redisTemplate.opsForHash().put("student", "age", "21");
        redisTemplate.opsForHash().put("student", "sex", "male");
        System.out.println(redisTemplate.opsForHash().get("student", "name"));
        System.out.println(redisTemplate.opsForHash().get("student", "age"));
        System.out.println(redisTemplate.opsForHash().get("student", "sex"));

        System.out.println("set操作");
        redisTemplate.opsForSet().add("project", "软件工程", "计算机技术", "通信工程", "软件工程");
        Set<String> project = redisTemplate.opsForSet().members("project");
        for (String s : project) {
            System.out.print(s + " ");
        }
        System.out.println();

        System.out.println("zset操作");
        redisTemplate.opsForZSet().add("movie", "热辣滚烫", 2.7d);
        redisTemplate.opsForZSet().add("movie", "飞驰人生", 9.1d);
        redisTemplate.opsForZSet().add("movie", "熊出没之逆转时空", 9.3d);
        redisTemplate.opsForZSet().add("movie", "二十一条", 8.2d);
        Set<String> movie = redisTemplate.opsForZSet().rangeByScore("movie", 3.0d, 9.3d);
        for (String s : movie) {
            System.out.print(s + " ");
        }
        System.out.println();

        System.out.println("基数操作");
        redisTemplate.opsForHyperLogLog().add("accessIp", "127.0.0.1");
        redisTemplate.opsForHyperLogLog().add("accessIp", "192.168.10.1");
        redisTemplate.opsForHyperLogLog().add("accessIp", "192.168.0.1");
        redisTemplate.opsForHyperLogLog().add("accessIp", "33.45.23.1");
        System.out.println(redisTemplate.opsForHyperLogLog().size("accessIp"));

    }

}

运行结果如下：

3. RedisUtils工具类

虽然RedisTemplate提供的redis操作很全面，但对于不了解redis的开发同学来说，直接看RedisTemplate的方法不够见名知义，因此一般情况下，我们都会单独封装一个工具类，将常用的一些方法进行抽象，以方便后续使用。

创建Redis配置类，配置RedisTemplate

@Configuration
public class RedisConfiguration {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}

工具类代码如下：

package org.example.util;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public boolean removeKey(String key) {
        return redisTemplate.delete(key);
    }

    public boolean hasKey(String key) {
        if (StringUtils.isEmpty(key)) {
            return false;
        }
        return redisTemplate.hasKey(key);
    }

    public boolean expire(String key, long time) {
        return expire(key, time, TimeUnit.SECONDS);
    }

    public boolean expire(String key, long time, TimeUnit timeUnit) {
        if (StringUtils.isEmpty(key)) {
            return false;
        }
        return redisTemplate.expire(key, time, timeUnit);
    }

    public void addKey(String key, Object value, long time) {
        addKey(key, value, time, TimeUnit.SECONDS);
    }

    public void addKey(String key, Object value, long time, TimeUnit timeUnit) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForValue().set(key, value, time, timeUnit);
    }

    public void addKey(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public Object getKey(String key) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        return redisTemplate.opsForValue().get(key);
    }

    public void increment(String key) {
        increment(key, 1L);
    }

    public void increment(String key, long delta) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForValue().increment(key, delta);
    }

    public void decrement(String key) {
        decrement(key, 1L);
    }

    public void decrement(String key, long delta) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForValue().decrement(key, delta);
    }

    public void leftPush(String key, List<Object> values) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForList().leftPushAll(key, values);
    }

    public void leftPush(String key, Object... value) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForList().leftPushAll(key, value);
    }

    public Object leftPop(String key) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        return redisTemplate.opsForList().leftPop(key);
    }

    public List<Object> range(String key, long start, long end) {
        if (StringUtils.isEmpty(key)) {
            return new ArrayList<>();
        }
        return redisTemplate.opsForList().range(key, start, end);
    }

    public Object indexOfList(String key, int index) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        return redisTemplate.opsForList().index(key, index);
    }

    public void addHash(String key, Map<String, Object> map) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        if (map == null || map.isEmpty()) {
            return;
        }
        map.forEach((field, value) -> {
            redisTemplate.opsForHash().put(key, field, value);
        });
    }

    public void addField(String key, String field, Object value) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
            return;
        }
        redisTemplate.opsForHash().put(key, field, value);
    }

     public void removeField(String key, String field) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
            return;
        }
        redisTemplate.opsForHash().delete(key, field);
    }

    public Map<String, Object> getEntries(String key) {
        if (StringUtils.isEmpty(key)) {
            return new HashMap<>();
        }
        Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
        Map<String, Object> result = new HashMap<>();
        entries.forEach((k, v) -> {
            result.put(k.toString(), v);
        });
        return result;
    }

    public Object getField(String key, String field) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
            return null;
        }
        return redisTemplate.opsForHash().get(key, field);
    }

    public Boolean hasField(String key, String field) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
            return false;
        }
        return redisTemplate.opsForHash().hasKey(key, field);
    }

    public void addSet(String key, String... value) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForSet().add(key, value);
    }

    public Set<Object> members(String key) {
        if (StringUtils.isEmpty(key)) {
            return new HashSet<>();
        }
        return redisTemplate.opsForSet().members(key);
    }

    public Boolean isMember(String key, Object value) {
        if (StringUtils.isEmpty(key)) {
            return false;
        }
        return redisTemplate.opsForSet().isMember(key, value);
    }

    public void addZSet(String key, Object value, Double score) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForZSet().add(key, value, score);
    }

    public Set<Object> rangeByScore(String key, Double min, Double max) {
        if (StringUtils.isEmpty(key)) {
            return new HashSet<>();
        }
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

    public Set<ZSetOperations.TypedTuple<Object>> rangeByScoreWithScore(String key, Double min, Double max) {
        if (StringUtils.isEmpty(key)) {
            return new HashSet<>();
        }
       return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
    }

    public void addHyperLogLog(String key, Object... value) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForHyperLogLog().add(key, value);
    }

    public void addHyperLogLog(String key, List value) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        redisTemplate.opsForHyperLogLog().add(key, value);
    }

    public Long countHyperLogLog(String key) {
        if (StringUtils.isEmpty(key)) {
            return 0L;
        }
        return redisTemplate.opsForHyperLogLog().size(key);
    }
}

修改之前的测试代码，将redisTemplate，改为我们的工具类

@Autowired
    private RedisUtils redisUtils;

    @Test
    public void testRedisUtils() {
        System.out.println("字符串操作=================");
       redisUtils.addKey("name", "cxy");
        System.out.println(redisUtils.getKey("name"));

        System.out.println("列表操作");
        redisUtils.leftPush("school", "华南理工大学");
        redisUtils.leftPush("school", "中山大学");
        redisUtils.leftPush("school", "华南农业大学");
        List<Object> school = redisUtils.range("school", 0, 5);
        for (Object s : school) {
            System.out.print(s + " ");
        }
        System.out.println();

        System.out.println("hash操作");
        redisUtils.addField("student", "name", "cxy");
        redisUtils.addField("student", "age", "21");
        redisUtils.addField("student", "sex", "male");
        System.out.println(redisUtils.getField("student", "name"));
        System.out.println(redisUtils.getField("student", "age"));
        System.out.println(redisUtils.getField("student", "sex"));

        System.out.println("set操作");
        redisUtils.addSet("project", "软件工程", "计算机技术", "通信工程", "软件工程");
        Set<Object> project = redisUtils.members("project");
        for (Object s : project) {
            System.out.print(s + " ");
        }
        System.out.println();

        System.out.println("zset操作");
        redisUtils.addZSet("movie", "热辣滚烫", 2.7d);
        redisUtils.addZSet("movie", "飞驰人生", 9.1d);
        redisUtils.addZSet("movie", "熊出没之逆转时空", 9.3d);
        redisUtils.addZSet("movie", "二十一条", 8.2d);
        Set<Object> movie = redisUtils.rangeByScore("movie", 3.0d, 9.3d);
        for (Object s : movie) {
            System.out.print(s + " ");
        }
        System.out.println();

        System.out.println("基数操作");
        redisUtils.addHyperLogLog("accessIp", "127.0.0.1");
        redisUtils.addHyperLogLog("accessIp", "192.168.10.1");
        redisUtils.addHyperLogLog("accessIp", "192.168.0.1");
        redisUtils.addHyperLogLog("accessIp", "33.45.23.1");
        System.out.println(redisUtils.countHyperLogLog("accessIp"));
    }

在测试之前，先删除之前添加的数据

测试结果如下：

相关推荐

京东大佬问我，每天新增100w订单数据的分库分表方案

京东大佬问我，每天新增100w订单数据的分库分表方案嗯，用户问的是高并发订单系统的分库分表方案，每天新增100万订单。首先，我得理解需求。每天100万订单，那每秒大概是多少呢？算一下，100万除以86...

MySQL 内存使用构成解析与优化实践

在为HULK平台的MySQL提供运维服务过程中，我们常常接到用户反馈：“MySQL内存使用率过高”。尤其在业务高峰期，监控中内存占用持续增长，即便数据库运行正常，仍让人怀疑是否存在异常，甚至...

阿里云国际站:怎样计算内存优化型需求?

本文由【云老大】TG@yunlaoda360撰写一、内存优化型实例的核心价值内存优化型ECS实例专为数据密集型场景设计，具有以下核心优势：高内存配比：内存与CPU比例可达1:8（如ecs.re6....

MySQL大数据量处理常用解决方案

1、读写分离读写分离，将数据库的读写操作分开，比如让性能比较好的服务器去做写操作，性能一般的服务器做读操作。写入或更新操作频繁可以借助MQ，进行顺序写入或更新。2、分库分表分库分表是最常规有效的一种大...

1024程序员节 花了三个小时调试 集合近50种常用小工具 开源项目

开篇1024是程序员节了，本来我说看个开源项目花半个小时调试之前看的一个不错的开源项目，一个日常开发常常使用的工具集，结果花了我三个小时，开源作者的开源项目中缺少一些文件，我一个个在网上找的，好多坑...

免费全开源，功能强大的多连接数据库管理工具!-DbGate

DBGate是一个强大且易于使用的开源数据库管理工具，它提供了一个统一的Web界面，让你能够轻松地访问和管理多种类型的数据库。无论你是开发者、数据分析师还是DBA，DBGate都能帮助你提升工作效率...

10个最佳的开源免费的酒店系统，接私活创业拿来改改
  • 10个最佳的开源免费的酒店系统，接私活创业拿来改改
  • 10个最佳的开源免费的酒店系统，接私活创业拿来改改
  • 10个最佳的开源免费的酒店系统，接私活创业拿来改改
  • 10个最佳的开源免费的酒店系统，接私活创业拿来改改
使用operator部署Prometheus

一、介绍Operator是CoreOS公司开发，用于扩展kubernetesAPI或特定应用程序的控制器，它用来创建、配置、管理复杂的有状态应用，例如数据库，监控系统。其中Prometheus-Op...

java学习总结

SpringBoot简介https://spring.io/guideshttp://www.spring4all.com/article/246http://www.spring4all.com/a...

Swoole难上手?从EasySwoole开始

前言有些童鞋感觉对Swoole不从下手，也不知在什么业务上使用它，看它这么火却学不会也是挺让人捉急的一件事情。Swoole：面向生产环境的PHP异步网络通信引擎啥是异步网络通信?10年架构师领你架...

一款商用品质的开源商城系统(Yii2+Vue2.0+uniapp)

一、项目简介这是一套很成熟的开源商城系统【开店星】，之前推过一次，后台感兴趣的还不少，今天再来详细介绍一下：基于Yii2+Vue2.0+uniapp框架研发，代码质量堪称商用品质，下载安装无门槛，UI...

Yii2中对Composer的使用

如何理解Composer？若使用Composer我们应该先知道这是一个什么东西，主要干什么用的，我们可以把Composer理解为PHP包的管理工具，管理我们用到的Yii2相关的插件。安装Compose...

SpringBoot实现OA自动化办公管理系统源码+代码讲解+开发文档

今天发布的是由【猿来入此】的优秀学员独立做的一个基于springboot脚手架的自动化OA办公管理系统，主要实现了日常办公的考勤签到等一些办公基本操作流程的全部功能，系统分普通员工、部门经理、管理员等...

7层架构解密:从UI到基础设施，打造真正可扩展的系统

"我们系统用户量暴增后完全崩溃了！"这是多少工程师的噩梦？选择正确的数据库只是冰山一角，真正的系统扩展性是一场全栈战役。客户端层：用户体验的第一道防线当用户点击你的应用时，0.1秒...

Win11系统下使用Django+Celery异步任务队列以及定时(周期)任务

首先明确一点，celery4.1+的官方文档已经详细说明，该版本之后不需要引入依赖django-celery这个库了，直接用celery本身就可以了，就在去年年初的一篇文章python3.7....

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表