springboot 整合 redis(一)

最新推荐文章于 2024-09-27 20:21:25 发布
最新推荐文章于 2024-09-27 20:21:25 发布
阅读量316 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41908336/article/details/107825820
版权

springboot 整合 redis(一)

每天点滴努力，成就编程路

描述

前言：redis是一个高性能键值对(key-value)NOSQL数据库。
优点：性能极高 – Redis能支持超过 100K+ 每秒的读写频率。
丰富的数据类型，Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
缺点：数据库容量受到物理内存的限制,不能用作海量数据的高性能读写。
redis应用场景
1.热点数据缓存。针对经常需要被查询，而不经常性被修改或者删除的数据。
2.限时业务的应用。例如验证码生存周期，接口api防刷,订单重复提交问题。
3.计数、队列应用，商品限时+限量秒杀。
4.针对大量数据排序渲染问题，排行榜， list-zored
5.好友关系绑定，集合

环境准备

采用docker部署redis
在这里插入图片描述

pom.xml 文件

<!--  redis 依赖包      -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<!--  redis 依赖包      -->

application.properties

##=====================redis ========
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host= ip地址
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password= redis密码
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

redis工具类(百度找)

package com.sise.demo1.demo.common.utils;



import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;


/**
 * author zxq
 * date 2020/8/4 22:49
 * Redis工具类
 */
@Component
public class RedisUtil {


    @Resource
    private RedisTemplate<String, Object> redisTemplate;




    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

// ============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

// ================================Map=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

// ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0){
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

// ===============================list=================================
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

测试例子

package com.sise.demo2.demo;

import com.sise.demo1.demo.DemoApplication;
import com.sise.demo1.demo.common.utils.RedisUtil;
import com.sise.demo1.demo.model.entity.User;
import com.sise.demo1.demo.model.service.IUserService;
import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;


/**
 * author zxq
 * date 2020/8/4 23:11
 */

@SpringBootTest(classes = DemoApplication.class)
public class RedisTest {


    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private IUserService userService;



    @Test
    void test1(){
        redisUtil.set("redis", "hello world");
        System.out.println(redisUtil.get("aaaKey"));
        List<User> users = userService.findAllUsers();
        System.out.println(redisUtil.lSet("users",users));
    }

}

运行截图
在这里插入图片描述

运行到此处表示redis环境已经搭建完成，后续就是redis一些应用。

zengxiangqu
关注
专栏目录
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
Spring Boot中使用Redis
shaopengjie的博客
08-23 9457
1.Redis是基于内存的key-value结构数据库优点：基于内存存储，读写性能高适合存储热点数据（短时间被被大量用户读取的数据）2.NoSQL,泛指非关系型数据库，是关系型数据库的补充3.Redis应用场景：缓存，任务队列，消息队列，分布式锁,下载的redis是源文件，需要进行编译安装，Windows版本百度即可5.Linux下安装Redis安装过程中如果报错：You need tcl x.x or newer in order to run the Redis test。
Springboot集成Redis
m0_59961940的博客
09-23 1万+
springboot集成redis
SpringBoot集成Redis
最新发布
gghfzs1的博客
09-27 1479
作为数据库,Redis是一个非常快的非关系数据库(),它可以存储键(key)与五种不同类型的值之间的映射,可以将存储在内的键值对数据持久化到硬盘,可以使用复制特性来扩展读性能,还可以使用客户端分片来扩展写性能。1.1数据类型Redis数据类型不仅与关系数据库管理系统(RDBMS)不同,也不同于任何简单的NoSQL键值数据存储。String（字符串）Hash（哈希）List（列表）Set（集合）Zset（Sorted Set：有序集合）
【SpringBoot高级篇】SpringBoot集成redis缓存
输入技术、输出想法
05-03 4664
SpringBoot整合redis1. Redis概述1.1 什么是Redis1.2 redis的应用场景2. Redis安装2.1 在线安装2.2 安装包安装2.2.1 在Ubuntu上安装GCC2.2.2 tar安装docker安装拉取镜像启动镜像3. 命令操作3.1 redis的数据结构：3.1.1 字符串类型 String3.1.2 哈希类型 hash3.1.3 列表类型 list3.1.4 集合类型 set3.1.5 有序集合类型 sortedset3.1.6 通用命令4. 持久化5. Java客
基础篇：Springboot项目集成Redis组件（详细教程）
weixin_48255516的博客
04-21 1265
基础篇：Springboot项目集成Redis组件（详细教程）
Redis在Springboot中的使用——Hash
选择与何种痛苦为伴
10-09 1929
在讲解Redis中Hash的使用之前，大家需要知道Hash是怎么样的结构，方便在合适的场景中去使用。值的域 field 执行 HINCRBY 命令将造成一个错误。这个我在之前的博客也有讲过，各位看官老爷可以移步到这篇。如果给定域已经存在且没有操作被执行，返回 0。设置成功，返回 1。
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
**SpringBoot整合Redis** 1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`application.yml`文件配置Redis连接信息，包括主机地址、端口、密码等。 2. **添加依赖**: 在`pom.xml`文件...
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
springboot整合redis集群零配置
07-28
首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、...
Redis-09-SpringBoot整合Redis
小新的笔记博客
11-18 206
Redis-09-SpringBoot整合Redis SpringBoot操作数据:spring-data jpa jdbc mongodb redis ! SpringData也是和SpringBoot齐名的项目! 说明︰j在SpringBoot2.x之后，原来使用的edis被替换为了lettuce? jedis:采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用jedis pool连接池!更像BIO模式 lettuce :采用netty，实例可以再多个线程中进行共享，不存在线程不安全的
SpringBoot整合Redis
飞上云端看彩虹
01-15 244
maven价包： <parent> <!-- 依赖管理，引入以后在声明其它dependency的时候就不需要version --> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactI...
java jredis hset_SpringBoot中 集成 redisTemplate 对 Redis 的操作（四）HSet
weixin_33389310的博客
03-02 1228
SpringBoot中 集成 redisTemplate 对 Redis 的操作(四)HSetredis 数据结构中，set用于去重，hset 则用于 去重加排序.在hset 中，有两个概念：1⃣️ rank 集合的下标2⃣️score 集合排序的依据值下面就来说一说hset 的基本操作1、添加数据 并按score 排序 有相同的key-value score 会累加Boolean aBoolea...
SpringBoot整合Redis[详细版]
wang20000102的博客
09-04 8469
SpringBoot整合Redis[详细版]Redis是现在最受欢迎的NoSQL数据库之一，Redis是一个使用ANSI C编写的开源。spring-boot-starter-data-redis在SpringBoot中集成了两个模版一个是RedisTemplate，另一个为 StringRedisTemplate而虽然StringRedisTempate帮助我们做了序列化，但是存储数据的时候只能存储Sting类型的数据，而RedisTemplate可以存储Object类型，所以我们一个使用RedisT
Spring Boot整合Redis
热门推荐
梁辰兴的博客
06-16 2万+
Redis是一个开源（BSD许可）的、内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件，并提供多种语言的API。Redis支持多种类型的数据结构，如 字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）与范围查询、bitmaps、 hyperloglogs 和 地理空间（geospatial）、索引半径查询。
springboot整合redis
欢迎一起学习交流
06-28 1万+
简单来说，不过与传统数据库不同的是，也就是它是内存数据库，所以读写速度非常快，因此 Redis 被广泛应用于缓存方向。另外，（在互联网API接口中，由于网络超时、手动刷新等经常导致客户端重复提交数据到服务端）比如说添加一次和添加多次结果是一样的，只会执行一次如何防止重复提交：用注解 + AOP。通过在自定义注解里定义一些相关的字段，比如过期时间即该时间内同一用户不能重复提交请求。然后把注解按需加在接口上，最后在拦截器里判断接口上是否有该接口，如果存在则拦截。
SpringBoot中 集成 redisTemplate 对 Redis 的操作（四）HSet
chinaichao2949的博客
09-01 4380
SpringBoot中 集成 redisTemplate 对 Redis 的操作（四）HSet redis 数据结构中，set用于去重，hset 则用于 去重加排序.在hset 中，有两个概念： 1⃣️ rank 集合的下标 2⃣️score 集合排序的依据值 下面就来说一说hset 的基本...
SpringBoot教程（十四） | SpringBoot之集成Redis
qq_20236937的博客
04-09 8626
Redis是我们Java开发中，使用频次非常高的一个nosql数据库，数据以key-value键值对的形式存储在内存中。redis的常用使用场景，可以做缓存，分布式锁，自增序列等，使用redis的方式和我们使用数据库的方式差不多，首先我们要在自己的本机电脑或者服务器上安装一个redis的服务器，通过我们的java客户端在程序中进行集成，然后通过客户端完成对redis的增删改查操作。
SpringBoot整合Redis工具类
"redis工具类是用于简化springboot与redis集成时操作的辅助类，它提供了对redis各种数据类型的存取及设置过期时间等方法。" 在Spring Boot项目中，集成Redis作为缓存或持久化存储是常见的需求。`RedisUtil`是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值