03. SpringBoot 整合 Redis

最新推荐文章于 2024-08-09 23:58:44 发布
最新推荐文章于 2024-08-09 23:58:44 发布
阅读量867 收藏 7
点赞数 9
分类专栏： Redis 学习笔记 文章标签： spring boot redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45594025/article/details/139131724
版权

文章目录

Jedis

Jedis 是 Redis 官方推荐的 Java 连接工具。

导入依赖

  </dependencies>
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.2.0</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
    </dependency>
  </dependencies>

测试连接

package com.zk.jedis;

import redis.clients.jedis.Jedis;

public class TestJedis {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        System.out.println(jedis.ping());
    }
}

输出：

PONG

Jedis 实现事务

执行成功：

package com.zk.jedis;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class TestJedis {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "xiaoming");
        jsonObject.put("num", "24");
        String result = jsonObject.toJSONString();

        // 开启事务
        Transaction multi = jedis.multi();

        try{
            multi.set("user1", result);
            multi.set("user2", result);
            // 执行事务
            multi.exec();
        }catch (Exception e){
            // 失败就放弃事务
            multi.discard();
        }finally {
            // 关闭事务
            multi.close();
        }

        System.out.println(jedis.get("user1"));
        System.out.println(jedis.get("user2"));
    }
}

输出：

{"num":"24","name":"xiaoming"}
{"num":"24","name":"xiaoming"}

执行失败：

package com.zk.jedis;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class TestJedis {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "xiaoming");
        jsonObject.put("num", "24");
        String result = jsonObject.toJSONString();

        // 开启事务
        Transaction multi = jedis.multi();
//        jedis.watch(result);

        try{
            multi.set("user1", result);
            multi.set("user2", result);

            int i = 1 / 0; // 代码执行异常，事务会执行失败

            // 执行事务
            multi.exec();
        }catch (Exception e){
            // 失败就放弃事务
            multi.discard();
        }finally {
            // 关闭事务
            multi.close();
        }

        System.out.println(jedis.get("user1"));
        System.out.println(jedis.get("user2"));
    }
}

输出：

null
null

SpringBoot 整合 Redis

SpringBoot 操作数据：Spring Data jpa jdbc redis。
Spring Data 也是和 SpringBoot 齐名的项目。

在 SpringBoot 2.x 之后，Jedis 被换成了 Lettuce。

Jedis：底层采用直连的方式，如果多个线程操作，不安全。要避免不安全，就要使用 Jedis Pool 连接池！更像 BIO 模式！

Lettuce：采用 netty，实例可以在多个线程中共享，不存在不安全的情况！可以减少线程数，性能高，更像 NIO 模式！

SpringBoot 所有的配置类，都有一个自动配置类，RedisAutoConfiguration；
自动配置类都会绑定一个 properties 文件，RedisProperties。

RedisTemplate

  • 默认的 RedisTemplate 没有过多的设置，redis 保存的对象都是需要序列化的！
  • RedisTemplate<Object, Object> 的两个参数都是 Object 类型的，我们使用需要强制转换 RedisTemplate<String, Object>（我们期望使用 String 类型的 key）;
  • @ConditionalOnMissingBean：判断当前需要注入 Spring 容器的 bean 的实现类是否已经含有，有的话不注入，没有就注入。（可以使用默认的 RedisTemplate，也可以自定义 RedisTemplate）

SpringBoot 整合 Redis 测试

  1. 导入依赖
	<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
  1. 配置连接
# SpringBoot 所有的配置类，都有一个自动配置类，RedisAutoConfiguration；
# 自动配置类都会绑定一个 properties 文件，RedisProperties。

# 配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
  1. 测试

RedisTemplate 序列化

默认的 RedisTemplate 没有过多的设置，redis 保存的对象都是需要序列化的！

	@Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        // 我们为了自己使用方便，一般直接使用<String, Object>
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 配置连接工厂
        redisTemplate.setConnectionFactory(connectionFactory);
        
        // Json 的序列化
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        //指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        
        // String 的序列化
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        
        
        // key 采用 String 的序列化方式
        redisTemplate.setKeySerializer(stringSerializer);
        // Hash 的 key 也采用 String 的序列化方式
        redisTemplate.setHashKeySerializer(stringSerializer);
        // value 采用 jackson 的序列化方式
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // Hash 的 value 也采用 jackson 的序列化方式
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        
        RedisUtils.setRedisTemplate(redisTemplate);
        
        return redisTemplate;
    }

RedisUtils

package com.zte.rdcloud.wbs.util;

import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

/**
 * @author 10307952
 * @date 2023/1/31 下午5:05
 */
@Slf4j
@Component
public class RedisUtils {

    @Setter
    private static RedisTemplate<String, Object> redisTemplate;

    /**
     * 为键值设置过期时间，单位秒
     *
     * @param key  键
     * @param time 时间(秒)
     * @return true:成功；false:失败
     */
    public static boolean expire(String key, long time) {
        try {
            if (time > 0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception e){
            log.error(e.getMessage());
            return false;
        }
    }

    //------------------------------String-----------------------------

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

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

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public static void del(String... key) {
        try {
            if(null != key && key.length > 0){
                if(key.length == 1){
                    redisTemplate.delete(key[0]);
                }else{
                    redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                }
            }
        }catch(Exception e){
            log.error(e.getMessage());
        }
    }

    /**
     * 普通缓存获取
     *
     * @param key
     * @return
     */
    public static Object get(String key){
        try {
            return null == key ? null : redisTemplate.opsForValue().get(key);
        }catch(Exception e){
            log.error(e.getMessage());
            return null;
        }
    }

    /**
     * 获取旧值，缓存新值
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public static Object getAndSet(String key, Object value) {
        try {
            return redisTemplate.opsForValue().getAndSet(key, value);
        } catch (Exception e) {
            return null;
        }
    }

    //------------------------------Hash-----------------------------

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

    /**
     * 向一张hash表中放入数据,如果不存在将创建，存在则覆盖，并设置过期时间
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
  /*  public static 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){
            log.error(e.getMessage());
            return false;
        }
    }*/

    /**
     * 向一张hash表中放入数据,如果不存在将创建，存在则只设置失效时间（不会设置新值）
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
   /* public static boolean hSetIfAbsent(String key, String item, Object value, long time) {
        try {
            Boolean result = redisTemplate.opsForHash().putIfAbsent(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return result;
        } catch (Exception e) {
            log.error(e.getMessage());
            return false;
        }
    }*/

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

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以是多个 不能为null
     */
    public static void hDel(String key, Object... item) {
        try {
            redisTemplate.opsForHash().delete(key, item);
        }catch(Exception e){
            log.error("redis failed hdel", e);
        }
    }

    /**
     * 获取指定键对应的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public static Object hGet(String key, String item) {
        try {
            return redisTemplate.opsForHash().get(key, item);
        }catch (Exception e){
            log.error(e.getMessage());
            return null;
        }
    }

}
TheManba
关注
专栏目录
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
使用 Spring Boot 整合 Redis 构建高效缓存应用
qq_28068311的博客
11-18 189
在 Spring Boot 项目中，通过整合 Redis，我们能够轻松实现缓存功能，提高应用程序的性能。注解，Spring Boot 将自动将方法的返回值缓存起来，下次调用相同的方法时，将直接返回缓存的结果，而不会再执行方法体。在实际项目中，根据具体需求，你还可以进一步优化缓存策略，提升应用性能。通过以上步骤，你已经成功在 Spring Boot 项目中整合了 Redis，并且可以通过。在与 Redis 交互的过程中，处理可能出现的异常情况，以确保应用程序的稳定性。等注解，方便我们在方法级别上使用缓存。
SpringBoot 3.2.0 结合Redisson接入Redis
大橘的博客
12-25 1774
通过Redisson，轻松实现Redis的高效集成，提升应用程序性能、可用性与扩展性。Redisson简洁的API、丰富的数据结构支持、分布式锁等特性，节省编写重复工具类劳动。
springboot3整合redis
最新发布
2301_77138117的博客
08-09 1479
来源于。
SpringBoot数据访问3.2：SpringBoot整合Redis
qq_48457459的博客
05-10 1232
本文主要内容：如何在springboot项目中，使用Redis数据库对数据进行操作(增删改查的演示)① 先在全局配置文件中，配置Redis数据库连接，②然后定义需要操作的实体类(指明操作实体类对象在redis数据库中的存储位置)③DAO层，编写Repository接口：对数据进行操作的方法。报错解决：Connect to redis server连接不上redis，redis无法添加数据报错MISCONF Redis is configured to save RDB snapshots, but i
关于SpringBoot如何整合Redis
ZhShH0413的博客
11-19 773
Redis诞生于2009年全称是Remote Dictionary Server 远程词典服务器，是一个基于内存的键值型NoSQL数据库。 特征： - 键值（key-value）型，value支持多种不同数据结构，功能丰富 - 单线程，每个命令具备原子性 - 低延迟，速度快（基于内存、IO多路复用、良好的编码）。 - 支持数据持久化 - 支持主从集群、分片集群 - 支持多语言客户端
SpringBoot2.x整合Redis
02-24
最近在学习SpringBoot2.x整合Redis，在这里和大家分享一下，希望对大家有帮助。Redis是开源免费高性能的key-value数据库。有以下的优势（源于Redis官网）：1.性能极高–Redis能读的速度是110000次/s,写的速度是81000...
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
SpringBoot2.X整合redis连接lettuce增强版本，支持多数据库切换，主从集群，哨兵
03-22
基于`SpringBoot2.X + Lettuce`实现Redis集成和多库实时切换是一个非常实用的项目。以下是对该项目的一些重点说明: 1. **项目概述** 该项目的主要目标是在`SpringBoot`应用中集成`Lettuce`作为Redis客户端,实现对...
REDIS学习（3.2）spring boot 使用redis作为缓存
kkgbn的博客
08-03 5423
在3.1的基础上修改RedisConfig @Configuration @EnableCaching public class RedisConfig extends CachingConfigurerSupport { @Bean public KeyGenerator smpkeyGenerator() { return new KeyGenerator() { @Overr
SpringBoot 2.0.3整合Redis 3.2
单身狗的清香
06-23 7056
    在整合之前，我们先在window系统上安装Redis；安装教程如下 https://jingyan.baidu.com/article/0f5fb099045b056d8334ea97.html 转载自百度经验；在安装过程中，大家可以选择 .msi格式的安装包。因为 .msi格式的安装的时候比较方便；不必选择 .zip格式的安装包；大家也可以从网上下载Redis的客户端工具；       ...
SpringBoot 集成redisson
一个写了10年bug的程序员日常笔记。
04-24 969
Redisson是Redis Java客户端和实时数据平台。它提供了使用Redis更方便、更简单的方法。Redisson对象提供了一种关注点分离，使您能够专注于数据建模和应用程序逻辑。Redis中文网redisson maven仓库地址当前最新版本3.29.0，我们用的是3.26.0。
【Redis | 第三篇】Springboot整合Redis
踢桃的成长之路
02-28 1142
Redsi系列第三篇主要介绍了Springboot快速整合Redis，以及常用的数据类型操作，对实战非常有大的帮助
SpringBoot2.X集成Redis3.2 Jedis
热门推荐
小羽毛的博客
07-16 1万+
一、概述 前两三年使用Redis，后面工作中也一直使用。后来由于搭建公司框架，主要是先使用SpringBoot，在SpringBoot的基础上集成Redis。 二、win10下安装Redis3.2 2.1下载Redis3.2 首先下载Redis3.2，目前来讲，3.2是相对稳定且比较新的版本了。下载地址：Redis-64(V3.2)。 2...
SpringBoot集成常用第三方框架-Redis
软件开发实战项目分享
12-23 1183
作者简介：Java领域优质创作者、CSDN博客专家 、CSDN内容合伙人、掘金特邀作者、阿里云博客专家、51CTO特邀作者、多年架构师设计经验、腾讯课堂常驻讲师主要内容：Java项目、Python项目、前端项目、人工智能与大数据、简历模板、学习资料、面试题库、技术互助。
Spring Boot 整合 Redis 超详细教程
weixin_44966143的博客
02-28 4597
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。话不多说直接干货！！！
SpringBoot2.x与Redis深度整合指南
"本文主要介绍了如何在SpringBoot2.x中整合Redis，以及Redis的主要优势和在现代系统中的应用价值。Redis是一种高性能的键值数据库，以其极高的读写速度、丰富的数据类型和原子性操作著称。在分布式系统中，Redis作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值