【SpringBoot】11.SpringBoot整合Redis

最新推荐文章于 2023-06-25 08:43:29 发布
最新推荐文章于 2023-06-25 08:43:29 发布
阅读量199 收藏 1
点赞数
分类专栏： SpringBoot Redis 文章标签： redis spring boot
本文为博主原创文章，未经博主允许，不得以任何方式转载或者演绎，如需转载请联系博主
本文链接：https://blog.csdn.net/Crezfikbd/article/details/126555808
版权

Redis 作为缓存型数据库，在实际开发中用得还是挺多的，下面通过几个简单的步骤实现一下 SpringBoot 与 Redis 的整合。

第 1 部分

SpringBoot 整合 Redis ，并简单进行使用。

step 1

由于是在自己的电脑上操作的，所以第一步是先安装一个 redis 数据库，如下，我是下载了一个免安装版，直接解压即可用。

在这里插入图片描述

step 2

新建一个简单的 SpringBoot 项目，然后在 pom.xml 文件中引入 Redis 的依赖，如下是所有的依赖信息

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/>
    </parent>
    <groupId>com.yuhuofei</groupId>
    <artifactId>springboot-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-redis</name>
    <description>Redis project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--Redis的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

step 3

修改配置文件，如下所示，在 application.properties 文件中加入以下配置

#redis配置
spring.redis.host=127.0.0.1
spring.redis.port=6379

step 4

编写测试类，使用 Redis，如下所示

package com.yuhuofei;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.concurrent.TimeUnit;

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 使用RedisTemplate
     */
    @Test
    void contextLoads() {

        //如果是操作List类型，用opsForList()
        //如果是操作Set类型，用opsForSet()
        //......
        //如果操作字符串类型，用opsForValue

        //设置key
        redisTemplate.opsForValue().set("userName", "yuhuofei");
        String name = (String) redisTemplate.opsForValue().get("userName");
        System.out.println("用户名是：" + name);

        //删除key
        redisTemplate.delete("userName");
    }

    /**
     * 使用StringRedisTemplate
     */
    @Test
    void stringRedisTemplateTest() {
        stringRedisTemplate.opsForValue().set("test", "redis Test");
        String value = stringRedisTemplate.opsForValue().get("test");
        System.out.println("test的值是：" + value);

        //设置test这个key，3秒钟过期
        stringRedisTemplate.expire("test", 3, TimeUnit.SECONDS);
    }
}

启动 Redis 服务器，然后执行上面的测试方法，结果如下

在这里插入图片描述

在这里插入图片描述
至此，第1部分关于 SpringBoot 整合 Redis 并进行简单的使用，结束。

第 2 部分

前面我们用的都是框架自带的模板类，现在自定义一个模板类使用（框架自带的，使用的是 JDK 序列化，在处理对象时，会出现问题）

  • 自定义 RedisTemplate 模板类
package com.yuhuofei.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @Description 自定义一个RedisTemplate
 * @ClassName RedisConfig
 * @Author yuhuofei
 * @Date 2022/8/27 12:08
 * @Version 1.0
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> myRedisTemplate(RedisConnectionFactory connectionFactory) {
        //在企业开发中，为了简化开发 一般自定义template<String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //new 一个Jackson的序列化对象
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        template.setConnectionFactory(connectionFactory);
        //Json序列化设置
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(om);
        //String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value的序列化采用jackson
        template.setValueSerializer(serializer);
        //hash的value也采用jackson的序列化
        template.setHashValueSerializer(serializer);
        return template;
    }
}
  • 测试类
package com.yuhuofei;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import com.yuhuofei.entity.User;

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate myRedisTemplate;

    /**
     * 使用RedisTemplate
     */
    @Test
    void contextLoads() {

        //设置key
        User user = new User("yuhuofei",4);
        myRedisTemplate.opsForValue().set("user", user);
        String name = (String) myRedisTemplate.opsForValue().get("user");
        System.out.println("用户信息是：" + name);

        //删除key
        myRedisTemplate.delete("user");
    }
}

与正常使用，没什么区别，只是在序列化对象时，用了我们自定义的方式。

第 3 部分

在工作中，往往会自定义 Redis 工具类来操作 Redis ，如下所示。

这样的话，业务代码中需要使用 Redis 时，直接用这个工具类操作即可，不必写一堆异常捕获和 redisTemplate.opsForxxx 了。

package com.yuhuofei.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

/**
 * @Description Redis工具类
 * @ClassName RedisUtils
 * @Author yuhuofei
 * @Date 2022/8/27 16:25
 * @Version 1.0
 */
@Service
public class RedisUtils {


    @Autowired
    private RedisTemplate<String, Object> myRedisTemplate;

    // =============================common============================

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                myRedisTemplate.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 myRedisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return myRedisTemplate.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) {
                myRedisTemplate.delete(key[0]);
            } else {
                myRedisTemplate.delete(String.valueOf(CollectionUtils.arrayToList(key)));
            }
        }
    }


    // ============================String=============================

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

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */

    public boolean set(String key, Object value) {
        try {
            myRedisTemplate.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) {
                myRedisTemplate.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)
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return myRedisTemplate.opsForValue().increment(key, delta);
    }


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


    // ================================Map=================================

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

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

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            myRedisTemplate.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 {
            myRedisTemplate.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 {
            myRedisTemplate.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 {
            myRedisTemplate.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) {
        myRedisTemplate.opsForHash().delete(key, item);
    }


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


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


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


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     */
    public Set<Object> sGet(String key) {
        try {
            return myRedisTemplate.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 myRedisTemplate.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 myRedisTemplate.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 = myRedisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 获取set缓存的长度
     *
     * @param key 键
     */
    public long sGetSetSize(String key) {
        try {
            return myRedisTemplate.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 = myRedisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================

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


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


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


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


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            myRedisTemplate.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 {
            myRedisTemplate.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 {
            myRedisTemplate.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 {
            myRedisTemplate.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 = myRedisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
yuhuofei2021
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot2.x整合Redis
02-24
最近在学习SpringBoot2.x整合Redis，在这里和大家分享一下，希望对大家有帮助。Redis是开源免费高性能的key-value数据库。有以下的优势（源于Redis官网）：1.性能极高–Redis能读的速度是110000次/s,写的速度是81000...
SpringBoot2.X整合redis连接lettuce增强版本，支持多数据库切换，主从集群，哨兵
最新发布
03-22
基于`SpringBoot2.X + Lettuce`实现Redis集成和多库实时切换是一个非常实用的项目。以下是对该项目的一些重点说明: 1. **项目概述** 该项目的主要目标是在`SpringBoot`应用中集成`Lettuce`作为Redis客户端,实现对...
SpringBoot集成Redis报non null key required(已解决)
weixin_44190513的博客
09-03 1万+
SpringBoot集成Redis报non null key required(已解决) 注意是不是给的key值或传过来的值是不是空的，如果是空的就会报这个错 接下来将流程走下去： 1、创建SpringBoot项目，将必要的包创建好 2、创建application.yml进行相关配置 server: port: 8080 servlet: context-path: /redis #mybatis配置 mybatis-plus: configuration: map-un
关于Redis缓存“non null key required”的问题
qq_34617629的博客
08-23 1万+
1、错误详情，如下图所示： 2、错误分析：出现这样的问题，说明我们的在操作Redis的时候，key值为空了，所以导致出现这样的错误异常。 String key = student.getID(); redisTemplate.delete(key); 类似与上面的代码，如果key为空的时候，就会报“non null key required”异常 3、解决方案：在使用Redis的key值以前，先做判断。如下图所示 String key = student.getID(); if (key.
java.lang.IllegalArgumentException: non null key required
qq_40051434的博客
09-07 3万+
redis缓存数据时报过这个错误，我的错误原因是存是数据是空，存之前加个非空判断就可以了
springboot2.X+mybatis+redis
03-23
通过这个"springBoot2.X_MyBatis_Redis_demo"项目，你可以实践如何在Spring Boot中整合MyBatis和Redis，了解它们如何协同工作以提高应用的性能和响应速度。此外，这个项目也可以作为一个基础模板，帮助你快速开发...
springboot2.x整合redis做mybatis的二级缓存
07-18
本篇文章将深入探讨如何在Spring Boot 2.x项目中整合Redis作为MyBatis的二级缓存，并实现自定义键、自定义过期时间和自定义序列化方式。 首先，让我们了解什么是二级缓存。在MyBatis中，一级缓存是基于SqlSession的...
vue购物车报non null key required
百度一下 猎人社区
06-25 843
这个错误通常是由于在Vue中使用v-for指令迭代列表时，没有给每个列表项提供唯一的键（key）属性所引起的。通过为每个循环项提供一个唯一键属性，你就可以解决“non-null key required”的错误，并确保Vue能够准确地追踪和更新列表项。解决方案：为了解决“non-null key required”的错误，你需要在使用v-for指令迭代列表时，为每个循环项提供一个唯一的键属性。2.2 使用索引作为键：如果你的数据源没有唯一标识符，你可以使用循环项在列表中的索引作为键。
redis：non null hash key required
qq_27081511的博客
09-25 1万+
从redis获取数据时报：non null hash key required 错误，检查后发现是获取方法中传入的key值有问题，传入的是null
non null hash key required bug 处理：方法切面监听的 拦截的判null处理
qq_25881443的博客
09-14 1862
@Around("@annotation(com.vcloud.wsi.common.CardResetDetect)") public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature(); CardResetDetect annot
Java IllegalArgumentException: non null key required问题解决
旭东怪的博客
02-22 1万+
问题描述： java.lang.IllegalArgumentException: non null key required 问题分析： 1、redis保存数据时，key为空导致的报错。 问题解决：保存之前先判断key是否为null或''。
报错：java.lang.IllegalArgumentException: non null key required 错误
ABCAA1024的博客
09-01 2751
这个一般是Redis返回的错误，就是代码里面保存redis数据时空值造成的，比如下面： redisTemplate.opsForValue().set(user.getUserId(),s.getOrgId()); 若user.getUserId()是空时，也就是key值是空时，就会报上面的错。 ...
postman的使用（传入不同参数，不同参数个数，不同请求方式）&报错non null key required解决&postman发送put请求
m0_45899013的博客
06-27 4783
1.只传入一个参数时 //获取商品信息 @RequestMapping(value = "/v/queryGoodsId",method = RequestMethod.POST) public ReturnResult queryGoodsById(String id) throws Exception { return localGoodsService.queryGoodsById(id); }
解决问题：java.lang.IllegalArgumentException: non null key required 错误： cannot find local variable ‘e‘
Miraitowa_Neo的博客
10-16 8158
使用iJava连接redis成功之后对实体对象进行操作的时候出现的错误（页面返回false --说明设置key值不成功..） debug调试之后： 刚开始是提示（错误：cannot find local variable 'e'）然后我把这个提示直接“-”删了 然后就提示错误：（java.lang.IllegalArgumentException: non null key required ） 通过一步步查看整个执行过程，最后发现是因为返回值的方法里key为空的原因 方法set...
java报错系列：java.lang.IllegalArgumentException: non null key required
阿咚do懂的博客
01-04 993
redis 取值需要非空键。
2020-11-02问题记录
CodersCoder的博客
11-02 766
背景 前端有调整，修复问题，提交前端代码后，后端没有提交任何代码和操作，仅重启一下服务，原有RedisUtil报错，导致后端和Redis有关服务全部不可用，报错信息大致如下： java.lang.IllegalArgumentException: non null hash key required at org.springframework.util.Assert.notNull(Assert.java:115) 根据不同的get或者是set方法报错不同，但是可以确定时redis问题，不过暂时没有解决
RedisTemplate的key默认序列化器问题
热门推荐
skymouse2002的专栏
06-19 3万+
redis的客户端换成了spring-boot-starter-data-redis，碰到了一个奇怪的问题，在同一个方法中1.先hset，再hget，正常获得数据。在不同的方法中 先hset，再hget获取不到数据，通过redis的monitor监控发现了命令的问题：实际我的key为JK_HASH:csrk，hashkey为user，但是根据上图所示，实际执行的命令多了好多其他字符，这是什么原因呢...
springboot2.x 整合jedis
04-04
Spring Boot 2.x 可以使用 Jedis 作为 Redis 客户端，下面是整合步骤： 1. 添加依赖 在 pom.xml 中添加 Jedis 依赖： ```xml <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.6.1</version> </dependency> ``` 2. 配置 Redis 在 application.properties 中配置 Redis： ```properties spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password= ``` 3. 创建 RedisTemplate ```java @Configuration public class RedisConfig { @Autowired private JedisConnectionFactory jedisConnectionFactory; @Bean public RedisTemplate<String, Object> redisTemplate() { RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(jedisConnectionFactory); redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); redisTemplate.setHashKeySerializer(new StringRedisSerializer()); redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); return redisTemplate; } } ``` 4. 使用 RedisTemplate 进行操作 ```java @Autowired private RedisTemplate<String, Object> redisTemplate; public void setValue(String key, Object value) { redisTemplate.opsForValue().set(key, value); } public Object getValue(String key) { return redisTemplate.opsForValue().get(key); } ``` 以上就是 Spring Boot 2.x 整合 Jedis 的步骤。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值