Redis学习笔记(四)——整合SpringBoot

已于 2022-04-04 16:30:57 修改
阅读量1.9k 收藏 1
点赞数
分类专栏： Redis 文章标签： redis spring boot
于 2022-03-13 16:24:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49290171/article/details/123453718
版权

每次学习到新的知识，最期待的一步就是整合SpringBoot，这真的很令人兴奋！废话少说，我们赶快开始进行SpringBoot整合Redis的学习！

SpringBoot整合Redis

Spring整合Redis要借助SpringData，之前使用的是jedis，现在被替换成了lettuce

替换原因：

jedis采用直连方式，多个线程操作的话是不安全的，如果想要避免这个问题，就需要使用连接池技术，可能会发生阻塞(BIO)。

lettuce底层使用netty(异步事件驱动的 NIO 框架)，实例可以在多个线程中共享，不存在线程不安全的情况，可以减少线程，发生阻塞的情况相比于jedis少，性能也就更加优秀。

1.导入依赖

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

        <!-- spring boot 2.x以后 redis客户端默认使用lettuce, lettuce连接池需显示依赖commons-pool2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2.在配置文件中配置Redis连接(两种配置文件选其一，看自己配置文件的尾缀)

在application.properties文件中配置Redis连接

spirng.redis.host=127.0.0.1
spring.redis.port=6379

在application.yml文件中配置

spring:
# redis配置
  redis:
    # 连接主机IP
    host: 127.0.0.1
    # 端口号
    port: 6800
    # 超时时间
    timeout: 3000ms
    # 默认数据库
    database: 0
    # 密码
    password: 123456
    # lettuce连接池
    lettuce:
      pool:
        max-active: 8
        min-idle: 0
        max-idle: 8
        max-wait: -1ms

3.测试连接

package com.test;

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.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class RedisSpringBootApplicationTests {

	@Autowired
	private RedisTemplate redisTemplate;

	@Test
	void contextLoads() {
		// redisTemplate     用来操作不同数据类型，操作方法及释义↓
		// opsForValue       操作字符串
		// opsForList        操作list集合
		// opsForSet         操作set集合
		// opsForHash        操作hash集合
		// opsForZset        操作Zset集合
		// opsForGeo         操作地理位置
		// opsForHyperloglog 操作hyperloglog
		// opsForStream      操作Bitmap
		// opsForCluster     操作集群
		
		//获取Redis数据库连接
		RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
		// 测试数据库连接
		connection.ping();
		// 清空当前数据库
		connection.flushDb();
		// 清空全部数据库
		connection.flushAll();
	}
}

我们连接上了Redis后会有一个问题，就是当前我们连接的Redis是没有序列化的，也就是说我们在Java代码中输入的中文，在Redis服务器上打开会显示乱码，我们需要自己自定义一个配置类来解决这个问题。

并且一般情况下我们不会传Java对象作为value，我们都会先将Java对象转换成JSON字符串后进行传输。

自定义配置类进行序列化

package com.test.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
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;

import java.net.UnknownHostException;

/**
 * @author ME
 * @date 2022/3/13 14:10
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // String序列化配置
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 与 hash类型的key使用String类型的序列化
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);

        // value 与 hash类型的value使用json类型的序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        // 保存修改
        template.afterPropertiesSet();

        return template;
    }
}

最后友情附送一下Redis工具类，对底层常用方法进行封装，手打了一个多小时QAQ

package com.test.util;

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

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

/**
 * @author ME
 * @date 2022/3/13 14:39
 */
@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================公共============================

    /**
     * 指定key失效时间
     * @param key key的名称
     * @param time 时间(秒)
     * @return true成功 false 失败
     */
    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 key的名称 不能为null
     * @return 时间(秒) 返回0代表永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key key的名称
     * @return true成功 false 失败
     */
    public boolean hasKey(String key) {
        try{
            return redisTemplate.hasKey(key);
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除key
     * @param key key的名称
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            }else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    // ==============================String====================================================
    /**
     * 获取String类型的值
     * @param key
     * @return
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 保存String类型的键值对
     * @param key 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;
        }
    }

    /**
     * 保存String类型的键值对并设置过期时间
     * @param key key的名称
     * @param value 值的内容
     * @param time 时间(秒) time要大于0，如果小于等于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 key的名称
     * @param delta 增加的数量-步长
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key key的名称
     * @param delta 减少的数量-步长
     */
    public long decr(String key, long delta) {
        if (delta > 0) {
            throw new RuntimeException("递减因子必须小于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ============================Hash==========================================

    /**
     * 获取hash列表中的单个map集合
     * @param key mapName的名称
     * @param item key的名称
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

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

    /**
     * 将元素批量放入hash集合
     * @param key mapName的名称
     * @param map 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;
        }
    }

    /**
     * 将元素批量放入hash集合并设置过期时间
     * @param key mapName的名称
     * @param map 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 mapName的名称
     * @param item key的名称
     * @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 mapName的名称
     * @param item key的名称
     * @param value 值的内容
     * @param time 设置的过期时间(秒)
     * @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 mapName的名称
     * @param item key的名称
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash集合中是否有该值
     * @param key mapName的名称
     * @param item key的名称
     * @return true成功 false失败
     */
    public boolean hHaskey(String key, Object item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增，如果不存在则创建一个，并将创建并新增以后的值返回
     * @param key mapName的名称
     * @param item key的名称
     * @param by 增加的步长
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减，如果不存在则创建一个，并将创建并新增以后的值返回
     * @param key mapName的名称
     * @param item key的名称
     * @param by 减少的步长
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ===============================Set=============================================

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

    /**
     * 查询此值在set集合中是否存在
     * @param key key的名称
     * @param value value的内容
     * @return
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将元素保存到set集合中
     * @param key key的名称
     * @param values 多个value内容
     * @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 key的名称
     * @param time 过期时间(秒)
     * @param values 多个value内容
     * @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 key的名称
     */
    public long sGetSetSize(String key) {
        try{
            return redisTemplate.opsForSet().size(key);
        }catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除Set集合中值为value的元素
     * @param key 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 key的名称
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引获取list集合中的值
     * @param key key的名称
     * @param index 索引下标
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将键值对放入list集合
     * @param key 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 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 key的名称
     * @param values 多个值的内容
     * @return
     */
    public boolean lSet(String key, List<Object> values) {
        try {
            redisTemplate.opsForList().rightPushAll(key, values);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将键值对放入list集合
     * @param key key的名称
     * @param values 多个值的内容
     * @param time 过期时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> values, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list集合中的某条数据
     * @param key 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;
        }
    }

    /**
     * 移除集合中指定value的所有值
     * @param key key的名称
     * @param count 自定义需要移除的个数
     * @param value 值的内容
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long removeCount = redisTemplate.opsForList().remove(key, count, value);
            return removeCount;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

 下一篇请戳↓

Redis学习笔记(五)——持久化及redis.conf配置文件叙述

啥时能挣6000块
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
redis学习笔记+练习springboot-redisdemo
11-10
本资源包包含了关于Redis的学习笔记以及一个基于SpringBoot整合Redis的实战项目——"springboot-redisdemo"，旨在帮助你深入理解和应用Redis。 首先，让我们详细探讨Redis的核心知识点： 1. **Redis的数据类型**：...
Redis学习之旅--与SpringBoot的结合
qq_45661125的博客
01-14 390
Redis学习之旅--SpringBoot整合Jedis概念使用SpringBoot配置文件源码分析：整合测试自己的 RedisTemplete 在学习SpringBoot整合Redis之前我们先来了解一下Jedis。 Jedis 概念 Jedis 是 Redis 官方推荐的 java连接开发工具！ 使用Java 操作Redis 中间件！如果你要使用java操作redis，那么一定要对Jedis 十分的熟悉！ 使用 1、导入对应的依赖 <dependency> &l
redis整合springboot
WangJava_的博客
07-19 186
springboot与jedis的整合 1、创建SpringBoot工程 使用idea自带的Spring Initializr创建一个基本的SpringBoot工程。 ​​ 2、修改POM文件 工程创建成功后，修改pom文件，添加所需的jar包 org.springframework.boot spring-boot-starter-data-redis redis.clients jedis 3.1.0 org.projectlombok
Redis进阶（八）—— Spring Boot整合
baidu_39560928的博客
08-22 802
1、常用的 Redis 客户端介绍 在 Spring Boot 2.x 之后，对Redis连接的支持，默认采用了 lettuce。 ​ Jedis api 在线网址：http://tool.oschina.net/uploads/apidocs/redis/clients/jedis/Jedis.html ​ lettuce 官网地址：https://lettuce.io 概念： Jedis：是老牌的Redis的Java实现客户端，提供了比较全面的Redis命令的支持； Redisson：实现了分布式的
SpringBoot整合Redis Search入门
pengo的博客
12-09 2121
SpringBoot整合redis search进行查询的基础操作
opsForHash() 与 opsForValue 请问有什么区别？
最新发布
weixin_46028606的博客
08-13 791
opsForHash() 与 opsForValue 请问有什么区别？
springboot整合spring-data-redis遇到的坑
08-30
使用springboot整合redis,使用默认的序列化配置,然后使用redis-client去查询时查询不到相应的key.问题出在哪，怎么解决呢？下面小编给大家带来了springboot整合spring-data-redis遇到的坑，需要的的朋友参考下吧
Redis学习笔记.pdf
08-07
Redis学习笔记.pdf 含目录 #资源达人分享计划#
18springboot+Redis学习笔记1
08-08
Spring Boot + Redis 学习笔记 目录 1. Redis 环境准备 2. 了解 Redis 自身的知识体系 3. Spring Boot 集成 Redis（使用 RedisTemplate） 4. Spring Boot 集成 Redis（使用注解） 5. Spring Boot + Redis（使用 ...
RedisTemplate 中 opsForHash()使用
Njy
05-09 5万+
RedisTemplate 中 opsForHash()使用 缓存菜单 public List<Menu> selectMenus() throws Exception { Collection<String> menujsons = redisTemplate.opsForHash().entries("menuList").values(); ...
RedisTemplate最常用方法
何哥的博客
02-20 2956
RedisTemplate常用方法介绍，根据RedisTemplate封装了Redis的一些常用的原生操作RedisUtil工具类
redisTemplate.opsForHash()【redis hash类型缓存类型使用配置】
dreaming9420的博客
12-01 4221
1.hashSet(String key, Object hashKey, Object value) /** * hash类型缓存放入 * * @param key 键 * @param hashKey 哈希键 * @param value 值 * @return true 成功 false 失败 */ public boolean hashSet(String key, Object hashKey, Obj
RedisTemplate.opsForHash()用法简介并举例
一起coding，一起嗨。
08-08 9106
是RedisTemplate类提供的用于操作Hash类型的方法。它可以用于对Redis中的Hash数据结构进行各种操作，如设置字段值、获取字段值、删除字段值等。请注意，示例中的"myhash"是哈希的键名，“field1”、"field2"等是要设置或获取的字段，“value1”、"value2"等是字段对应的值。方法的常见用法，你可以根据具体的业务需求选择适合的方法进行操作。
Redis opsForHash
qq_44499717的博客
04-26 1332
Redis opsForHash 1、put(H key, HK hashKey, HV value) 新增hashMap值。 Java代码 收藏代码 redisTemplate.opsForHash().put(“hashValue”,“map1”,“map1-1”); redisTemplate.opsForHash().put(“hashValue”,“map2”,“map2-2”); 2、values(H key) 获取指定变量中的hashMap值。 Java代码 收藏代码 List has
spring boot 使用redisTemplate连接redis，获取键值信息
weixin_44220858的博客
11-24 2524
连接redis
RedisTemplate常用方法总结
热门推荐
feeling good
04-10 10万+
很多公司都将redisTemplate进行了封装，封装成业务所需要的RedisUtil工具类方便进行调用，本篇文章总结了redisTemplate常用的一些工具类。 Redis最为常用的数据类型： String Hash List Set zSet Sorted set String ...
CollectionUtils集合常用方法
qq_46144673的博客
11-18 1117
CollectionUtils集合工具类常用方法
Springboot中操作redis工具类
m1s2q3l4的博客
01-26 122
package com.example.jedis.util; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Component; import org.springframework.util.CollectionUtils; imp
springboot整合Redis中怎么通过idea创建springboot项目
04-23
你可以按照以下步骤进行： 1. 打开 IntelliJ IDEA，选择 File -> ...7. 在需要使用 Redis 的地方注入 RedisTemplate 或 StringRedisTemplate 进行操作。 以上是一个简单的步骤示例，具体实现还需要根据实际需求调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值