SpringBoot使用Redis

已于 2024-01-29 19:12:39 修改
阅读量378 收藏 5
点赞数 6
分类专栏： SpringBoot系列基础教程 文章标签： spring boot redis 后端 java maven
于 2024-01-29 17:19:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laisc7301/article/details/135916969
版权

[!NOTE]

本教程是《SpringBoot系列基础教程》之一，教程目录：https://blog.csdn.net/laisc7301/article/details/135918617

首先按照图示新建项目：

添加以下依赖：

找到application.properties文件，并写入下面内容：

server.port=8001

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0


#也可以写成下面这样：
#spring:
#redis:
#host: localhost
#port: 6379
#password:
#database: 0

整个项目的文件结构如下图所示：

贴出代码，代码里注释写得比较多，就不解释太多了。

TestController.java

package com.laisc.example5.controller;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Controller
@RequestMapping("/test")
public class TestController {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @ResponseBody
    @RequestMapping("/setvalue1")
    public String setValue1() { //使用JDK序列化策略设置键
        redisTemplate.opsForValue().set("测试1", "测试123");
        String out = redisTemplate.opsForValue().get("测试1").toString();
        return out;
    }

    @ResponseBody
    @RequestMapping("/setmapvalue")
    public String setMapValue() { //使用JDK序列化策略设置键
        Map<String, String> map = new HashMap<>();
        map.put("aaa", "bbb");
        map.put("ccc", "ddd");
        redisTemplate.opsForValue().set("map1", map); //直接存储Map对象
        String out = redisTemplate.opsForValue().get("map1").toString();
        return out;
    }

    @ResponseBody
    @RequestMapping("/setvalue2")
    public String setValue2() { //使用String序列化策略设置键
        stringRedisTemplate.opsForValue().set("测试2", "测试1234");
        String out = stringRedisTemplate.opsForValue().get("测试2");
        return out;
    }
    /*
     * RedisTemplate和StringRedisTemplate的区别：
     * 两者的关系是StringRedisTemplate继承RedisTemplate。
     * 两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据，包括删除操作。
     * SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
     * 使用场景：
     * StringRedisTemplate：当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候。
     * RedisTemplate：但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象。
     */

    @ResponseBody
    @RequestMapping("/setvalue3")
    public String setValue3() { //使用String序列化策略设置键，并设置过期时间
        stringRedisTemplate.opsForValue().set("测试3", "测试12345", 3600, TimeUnit.SECONDS);//设置过期时间为3600秒
        String out = stringRedisTemplate.opsForValue().get("测试3");
        return out;
    }

    @ResponseBody
    @RequestMapping("/setexpire")
    public boolean setExpire() { //设置过期时间
        return stringRedisTemplate.expire("测试2", 3600, TimeUnit.SECONDS);//设置过期时间为3600秒
        /*
         * expire(String key, long timeout, TimeUnit unit)
         * 该方法用于设置过期时间
         * 当该键存在并且没有设置过期时间时，将设置过期时间并返回true
         * 当该键存在并且有过期时间时，将覆盖原来的过期时间并返回true
         * 当该键不存在时，返回false
         */
    }

    @ResponseBody
    @RequestMapping("/persist")
    public boolean persist() {// 移除过期时间
        return stringRedisTemplate.boundValueOps("测试3").persist();
        /*
         * persist()
         * 当存在过期时间并且已清除时，返回true
         * 当键不存在过期时间或找不到该键时，返回false
         */
    }


    @ResponseBody
    @RequestMapping("/haskey")
    public boolean hasKey() { //查看键是否存在
        return stringRedisTemplate.hasKey("测试2");
    }

    @ResponseBody
    @RequestMapping("/del")
    public String del() { //删除值
        String out = stringRedisTemplate.delete("测试2").toString();
        return out;
        /*
         * delete(String key)
         * 该方法用来删除值
         * 当值存在，删除并返回true
         * 当值不存在，返回false
         */
    }

    @RequestMapping("/addset")
    @ResponseBody
    public String addSet() { //添加Set集合
        SetOperations<String, String> set = stringRedisTemplate.opsForSet();
        set.add("myset", "22");
        set.add("myset", "33");
        set.add("myset", "44");
        Set<String> resultSet = stringRedisTemplate.opsForSet().members("myset");
        return resultSet.toString();
    }

    @RequestMapping("/addset2")
    @ResponseBody
    public String addSet2() { //批量添加Set集合
        stringRedisTemplate.opsForSet().add("myset", "1", "2", "3");//向指定key中存放set集合
        Set<String> resultSet1 = stringRedisTemplate.opsForSet().members("myset");
        return resultSet1.toString();
    }

    /*
     * 当插入的Set元素重复时，会自动跳过重复的元素。
     */


    @RequestMapping("/addvalue")
    @ResponseBody
    public String addValue() {
        Long mycounter = stringRedisTemplate.boundValueOps("counter").increment(1);//先将counter累加1并更新到Redis，然后把累加后的值返回给mycounter
        return mycounter.toString();
    }

    @RequestMapping("/getexpire")
    @ResponseBody
    public String getExpire() {
        Long time = stringRedisTemplate.getExpire("测试3"); //返回当前key所对应的剩余过期时间，单位为秒
        return time.toString();
        /*
         * getExpire(String key)
         * 返回当前key所对应的剩余过期时间
         * 当返回值为-1，表示永不过期
         * 当返回值为-2，表示不存在该键
         */
    }


    @ResponseBody
    @RequestMapping("/listpush")
    public String listPush() { //将一些值插入列表中。
        // leftPush依次向右边添加
        stringRedisTemplate.opsForList().rightPush("myList", "1");
        stringRedisTemplate.opsForList().rightPush("myList", "2");
        stringRedisTemplate.opsForList().rightPush("myList", "A");
        stringRedisTemplate.opsForList().rightPush("myList", "B");
        stringRedisTemplate.opsForList().rightPush("myList", "C");
        // leftPush依次向左边添加
        stringRedisTemplate.opsForList().leftPush("myList", "0");
        return "ok";
    }


    @RequestMapping("/getlist")
    @ResponseBody
    public String GetList() { // 查询列表中的元素
        // 查询类别所有元素
        List<String> listAll = stringRedisTemplate.opsForList().range("myList", 0, -1);
        // 查询前3个元素
        List<String> list = stringRedisTemplate.opsForList().range("myList", 0, 3);
        return "listAll=" + listAll.toString() + "  list=" + list.toString();
    }


    @RequestMapping("/listremove")
    @ResponseBody
    public String listRemove() { // 删除列表中的元素
        // 删除从右到左前2个值为'B'的元素；
        stringRedisTemplate.opsForList().remove("myList", -2, "B");
        return "ok";
        /*
         * remove(String key, long count,Object value)
         * 从存储在键中的列表中删除等于值的元素的第一个计数事件。
         * count > 0：删除从左到右前count个符合条件的元素；
         * count < 0：删除从右到左前|count|个符合条件的元素；
         * count = 0：删除等于value的所有元素。
         */
    }


    /*
     *下面将讲解Redis中的哈希表，哈希表其实就是Java里面的Map。
     */

    @RequestMapping("/hashput")
    @ResponseBody
    public String hashPut() { //添加哈希键值对
        stringRedisTemplate.opsForHash().put("mytest:test1", "a", "b");
        stringRedisTemplate.opsForHash().put("mytest:test1", "c", "d");
        stringRedisTemplate.opsForHash().put("mytest:test1", "e", "f");
        return "ok";
        /*
         * put(String key, Object hashKey, Object value)
         * key 是哈希表名
         * hashKey 就是Map里的key，value 就是Map里的value
         * 当 hashKey 相同，后添加的将覆盖原有的。
         */
    }


    @RequestMapping("/hashget")
    @ResponseBody
    public String hashGet() { //获取哈希键值对
        Map<Object, Object> map = stringRedisTemplate.opsForHash().entries("mytest:test1");
        return map.toString();
    }


    @RequestMapping("/hashdel")
    @ResponseBody
    public String hashDelete() { //删除哈希表里的元素
        stringRedisTemplate.opsForHash().delete("mytest:test1", "a", "e");
        return "ok";
        /*
         * delete(String key, Object... hashKeys)
         * 根据key 和 hashKeys 删除元素
         * key 是哈希表名
         * hashKey 就是Map里的key
         */
    }


    @RequestMapping("/hashgetkeys")
    @ResponseBody
    public String hashGetKeys() { //获取哈希表里的key集合
        Set<Object> objects = stringRedisTemplate.opsForHash().keys("mytest:test1");
        return objects.toString();
    }

    @RequestMapping("/hashgetvaluelist")
    @ResponseBody
    public String hashGetValueList() { //获取哈希表里的value列表
        List<Object> objects = stringRedisTemplate.opsForHash().values("mytest:test1");
        return objects.toString();
    }

    @RequestMapping("/hashsize")
    @ResponseBody
    public String hashSize() {// 获取哈希表大小
        // 获取map对象大小
        long size = stringRedisTemplate.opsForHash().size("mytest:test1");
        return String.valueOf(size);
    }
}

项目源代码下载：https://pan.baidu.com/s/1sxrkiyjnCiUPEgCaRCsgtA?pwd=9z5e

上一篇：SpringBoot使用MongoDB：https://laisc7301.github.io/blog/2024/01/12/202401120000SpringBoot%E4%BD%BF%E7%94%A8MongoDB/

原文：https://laisc7301.github.io/blog/2024/01/21/202401210000SpringBoot%E4%BD%BF%E7%94%A8Redis/

睿虎
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot使用redis
weixin_73310020的博客
04-26 5173
默认有三种方式连接redis.第一种:jedis—传统的项目–ssm第二种:lettuce:---->刚出现没有多久就被springboot整合进来。第三种:springboot连接redis。
SpringBoot使用Redisson操作Redis及使用场景实战
最新发布
ToBeMaybe_的博客
07-11 2281
从 spring-boot 2.x 版本开始，spring-boot-data-redis 默认使用 Lettuce 客户端操作数据。
springboot中使用redis
m0_57786140的博客
04-12 546
本文介绍了如何使用 Spring Boot 集成 Redis，通过添加依赖、配置 Redis 连接、注入 RedisTemplate 类和使用 @Cacheable 注解来操作 Redis。Spring Data Redis 提供了许多对 Redis 的封装，简化了 Redis 的使用。Redis 可以持久化数据，保证数据的可靠性。在上面的代码中，通过 @Cacheable 注解将 getUserById 方法的返回值缓存到 Redis 中，value 属性表示缓存的名称，缓存的键由方法的参数决定。
Spring Boot中使用Redis
shaopengjie的博客
08-23 8137
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。
spring boot使用Redis
EaseMob.沈冲
07-09 457
    关系型数据库在性能上总存在一些这样那样的缺陷，所以大家有时候在使用传统型数据库时，会与具有高效存取功能的缓存系统结合使用，以提高系统的访问性能，如Redis。Redis是一种可以持久存储的缓存系统，是一个高性能的key-value数据库，它使用键值对的方式来存储数据。    1、Redis依赖配置        &lt;dependencies&gt; &lt;dependency...
SpringBoot使用Redis实现分布式锁
08-19
SpringBoot 使用 Redis 实现分布式锁 分布式锁是指在分布式系统中，多个节点或机器之间对共享资源的访问进行控制和协调，以避免冲突和竞争的机制。SpringBoot 使用 Redis 实现分布式锁是指使用 SpringBoot 框架和 ...
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
springboot_redis
04-03
综上所述，"springboot_redis"项目是一个实践教程，演示了如何在Spring Boot应用中配置和使用Redis。通过学习和理解这些关键点，开发者可以快速掌握Spring Boot与Redis的集成，并将其应用于实际项目中，提高应用的...
SpringBoot集成Redis
02-26
在本项目中，我们将探讨如何在SpringBoot应用中配置和使用Redis，以及如何利用Redis实现登录缓存功能。 首先，集成SpringBoot与Redis的关键在于添加依赖。在`pom.xml`或`build.gradle`文件中，我们需要引入Spring ...
基于springboot和redis实现单点登录
08-25
基于SpringBoot和Redis实现单点登录是当前热门的技术栈之一，本文将详细介绍如何使用SpringBoot和Redis实现单点登录。 单点登录的优点 1. 提高用户体验：用户只需要登录一次即可访问所有相关的应用系统，提高了...
SpringBoot中使用redis
m0_58969296的博客
11-22 349
最开始学习redis是在redis-cli界面中写指令连写的，但最终还是要在SpringBoot项目中运用，所以了解完基本指令之后就可以在项目中进行练习了。本例以最基础的String数据类型为例进行练习，之后可以再自行学习练习其他集中数据类型的操作方法。
Redis在SpringBoot中的配置
MIYAOW
06-22 956
如何使用 1、引入 spring-boot-starter-redis dependency> groupId>org.springframework.bootgroupId> artifactId>spring-boot-starter-redisartifactId> dependency> 2、添加配置文件 # REDIS (Redis
SpringBoot中使用Redis
qq_51225888的博客
06-07 532
SpringBoot中使用Redis
SpringBoot使用redis
跟派大星学编程
06-14 684
1. 下载redis和工具 2. 加载redis的jar包 3. 添加配置文件 4. 使用 5. 在redis工具中查看数据 6. 封装工具类 6.1 JSON工具类 6.2 redis操作工具类 1. 下载redis和工具 redis服务器下载： 点击这里 解压，双击start.bat启动服务 下载redis桌面管理程序：点击这里 安装即可 2. 加载redis的jar包...
springboot 使用Redis
qq_38345598的博客
02-09 102
1 StringTemplateRedis和RedisTemplate的区别 1 两者关系是StringRedisTemplate继承了RedisTemplate ，但是两者的数据是不共通的也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据,RedisTemplate只能管理RedisTemplate中的数据 2 RedisTemplate 是使用的JdkSerialzationRedisSerializer 存入数据会将数据先序列化字节数组然后.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值