springboot整合redis使用介绍

已于 2022-06-28 11:52:36 修改
阅读量723 收藏 3
点赞数 1
分类专栏： springboot redis 文章标签： redis spring boot java
于 2022-05-09 17:51:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41307800/article/details/124669915
版权

文章目录

系列文章目录

Springboot集成Netty

Springboot集成Rabbitmq

Springboot集成Retry

springboot集成websocket

Springboot集成Redis

springboot整合rabbitmq使用示例

前言

本文介绍了springboot集成redis需要的一些配置以及常见的redis操作工具类。

提示：以下是本篇文章正文内容，下面案例可供参考

一、redis是什么？

redis是一个高性能、基于内存级别读写的非关系型数据库

二、使用步骤

引入库

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
</dependency>

定义配置类

数据序列化以及反序列化

public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    private Class<T> clazz;

    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (null == t) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (null == bytes || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        //禁用关键字检测
        return JSON.parseObject(str, clazz, Feature.DisableSpecialKeyDetect);
    }
}

属性配置

@Data
@ConfigurationProperties(
        prefix = "spring.myredis"
)
@Component(value = "MyRedisProperties")
public class MyRedisProperties{
    /**备用数据库 */
    private Integer backupdb;
    private int database = 0;
    private String url;
    private String host = "localhost";
    private String username;
    private String password;
    private int port = 6379;
    private boolean ssl;
    private Duration timeout;
    private Duration connectTimeout;
}

主从库配置

@Configuration
@EnableConfigurationProperties
@EnableCaching
public class RedisConfig {
    @Resource
    MyRedisProperties myRedisProperties;

    /**
     * 默认的redis模板类，使用默认数据库访问
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    @Primary
    public RedisTemplate redisTemplateMaster(RedisConnectionFactory redisConnectionFactory){
        // 创建redis序列化器
        RedisTemplate redisTemplate = new RedisTemplate<>();
        FastJsonRedisSerializer<Object> objectFastJson2JsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        redisTemplate.setKeySerializer(objectFastJson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(objectFastJson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(objectFastJson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(objectFastJson2JsonRedisSerializer);
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }

    /**
     * 备用数据库
     * @param connectionFactory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplateSlave(RedisConnectionFactory connectionFactory){
        // 创建redis序列化器
        RedisTemplate redisTemplate = new RedisTemplate<>();
        FastJsonRedisSerializer<Object> objectFastJson2JsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        redisTemplate.setKeySerializer(objectFastJson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(objectFastJson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(objectFastJson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(objectFastJson2JsonRedisSerializer);
        if(connectionFactory instanceof  LettuceConnectionFactory){
            //创建客户端连接
            LettuceConnectionFactory lettuceConnectionFactory =
                    createLettuceConnectionFactory
                            (myRedisProperties.getBackupdb(),myRedisProperties.getHost(),myRedisProperties.getPort(),myRedisProperties.getPassword(),myRedisProperties.getTimeout().getSeconds()*1000);
            redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        }
        return redisTemplate;
    }

    /**
     * 创建lettuce连接工厂
     * @param dbIndex
     * @param hostName
     * @param port
     * @param password
     * @param timeOut
     * @return
     */
    private  LettuceConnectionFactory createLettuceConnectionFactory(
            int dbIndex, String hostName, int port, String password,
            Long timeOut){
        //redis配置
        RedisConfiguration redisConfiguration = new
                RedisStandaloneConfiguration(hostName,port);
        ((RedisStandaloneConfiguration) redisConfiguration).setDatabase(dbIndex);
        ((RedisStandaloneConfiguration) redisConfiguration).setPassword(password);
        //连接池配置
        GenericObjectPoolConfig genericObjectPoolConfig =
                new GenericObjectPoolConfig();
        //redis客户端配置
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
                builder =  LettucePoolingClientConfiguration.builder().
                commandTimeout(Duration.ofMillis(timeOut));
        builder.poolConfig(genericObjectPoolConfig);
        LettuceClientConfiguration lettuceClientConfiguration = builder.build();
        //根据配置和客户端配置创建连接
        LettuceConnectionFactory lettuceConnectionFactory = new
                LettuceConnectionFactory(redisConfiguration,lettuceClientConfiguration);
        lettuceConnectionFactory .afterPropertiesSet();
        return lettuceConnectionFactory;
    }

}

常用操作工具类

public class RedisUtils {
    public RedisTemplate redisTemplate;

    public RedisUtils(Boolean isMaster) {
        if (isMaster) {
            redisTemplate = SpringUtil.getBean("redisTemplateMaster");
            return;
        }
        redisTemplate = SpringUtil.getBean("redisTemplateSlave");
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public void setObject(final String key, final Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public  void setObject(final String key, final Object value, final Long timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public Object getObject(final String key) {
        return redisTemplate.opsForValue().get(key);
    }
    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getObject(final String key,final Class<T> clazz) {
        return JSONUtil.toBean(JSONUtil.toJsonStr(redisTemplate.opsForValue().get(key)),clazz);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection) {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public long setList(final String key, final Collection dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public List getList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getList(final String key,final Class<T> clazz) {
        return JSONUtil.toList(JSONUtil.toJsonStr(redisTemplate.opsForList().range(key, 0, -1)),clazz);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public void setSet(final String key, final Set dataSet) {
        redisTemplate.opsForSet().add(key, dataSet);
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public Set getSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public void setMap(final String key, final Map<String, Object> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public Map getMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public void setMap(final String key, final String hKey, final Object value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public Object getMap(final String key, final String hKey) {
        return redisTemplate.opsForHash().get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public List getMap(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }
}

启动配置application.yml

spring:
  myredis:
    database: 0
    backupdb: 1
    host: localhost
    port: 6379
    timeout: 30

运行启动类

@SpringBootTest(classes = SpringBootExampleApplication.class)
@Slf4j
@RunWith(SpringRunner.class)
public class RedisTest {
    /**
     * redis 数据库切换测试
     * 包括主数据库master以及备用数据库slave
     */
    @Test
    public void testRedis(){
        String STRING_KEY = "testString";
        String LIST_KEY = "testList";
        String HASH_KEY = "testHash";
        String SET_KEY = "testSet";
        RedisUtils redisUtils = new RedisUtils(true);
        RedisUtils redisUtilSalve = new RedisUtils(false);

        // string操作
        redisUtils.setObject(STRING_KEY,"test");
        redisUtilSalve.setObject(STRING_KEY,new Student(20,"小明"));
        // list操作
        redisUtils.setList(LIST_KEY, Arrays.asList(1,2));
        redisUtilSalve.setList(LIST_KEY,Arrays.asList(new Student(1,"1"),new Student(2,"2")));
        // map操作
        redisUtils.setMap(HASH_KEY, MapUtil.of(HASH_KEY,"test"));
        redisUtilSalve.setMap(HASH_KEY,MapUtil.of(HASH_KEY,"testSlave"));
        // set 操作
        HashSet hashSet = new HashSet();
        hashSet.add("test");
        hashSet.add("test1");
        redisUtils.setSet(SET_KEY,hashSet);
        hashSet.add("testSalve");
        redisUtilSalve.setSet(SET_KEY,hashSet);

        // 打印展示
        // string打印
        System.out.println(redisUtils.getObject(STRING_KEY));
        Student student = redisUtilSalve.getObject(STRING_KEY, Student.class);
        System.out.println(student);
        // list 打印
        System.out.println(redisUtils.getList(LIST_KEY));
        List<Student> studentList = redisUtilSalve.getList(LIST_KEY,Student.class);
        studentList.stream().forEach(System.out::println);
        // map 打印
        redisUtils.getMap(HASH_KEY).forEach((k,v)->{
            System.out.println(k+":"+v);
        });
        redisUtilSalve.getMap(HASH_KEY).forEach((k,v)->{
            System.out.println(k+":"+v);
        });
        // set 打印
        redisUtils.getSet(SET_KEY).forEach(v->{
            System.out.println(v);
        });
        redisUtilSalve.getSet(SET_KEY).forEach(v->{
            System.out.println(v);
        });
    }
}

打印效果

=======string打印======
test
Student(age=20, name=小明)
=======list打印======
[1, 2]
Student(age=1, name=1)
Student(age=2, name=2)
=======map打印======
testHash:test
testHash:testSlave
=======set打印======
[test, test1]
[test, testSalve, test1]

Another Redis Desktop Manager 工具效果

在这里插入图片描述
在这里插入图片描述

三、总结

以上就是介绍的全部内容，把一些常用便捷的方法封装进去，方便后续二次开发引用。

四、源码地址

测试代码地址在:https://gitee.com/teajoy/springboot-modules/tree/master/springboot-example

https://gitee.com/teajoy/springboot-modules/tree/master/springboot-redis

Martisan_Guo
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
【SpringBoot】36、SpringBoot整合Redis实现发布/订阅
热门推荐
Asurplus
10-23 21万+
一、简介 1、发布订阅 SUBSCRIBE, UNSUBSCRIBE 和 PUBLISH 实现了 发布/订阅消息范例，发送者 (publishers) 不用编程就可以向特定的接受者发送消息 (subscribers). Rather, 发布的消息进入通道，不需要知道有没有订阅者. 订阅者发表感兴趣的一个或多个通道，并且只接受他们感兴趣的消息，不管发布者是不是存在. 发布者和订阅者的解耦可以允许更大的伸缩性和更多动态的网络拓扑。 2、说明 本篇文章是继： 【SpringBoot】三十四、SpringBoot
springBoot整合redis使用介绍（详细案例）
weixin_43811057的博客
09-19 5万+
文章预览：一、创建springboot项目（采用骨架方式）二、配置文件三、使用redis1、添加字符串到redis2、将对象转换成jsonString并存入redis3、将对象集合转换成jsonString，并设置过期时间存入至redis4、获取对象5、获取对象集合6、添加 hash-set7、获取 hash-setvalue 一、创建springboot项目（采用骨架方式） 创建完成； 我们分析下pom文件中内容： 所使用到的关键依赖： <!--springBoot集成redis--&
Redis的哈希操作multiGet()来从Redis中批量获取多个键对应的值
WeiRongQ的博客
06-04 624
总结起来，这段代码的作用是从Redis中获取一组角色对应的菜单权限，并将其转换为一个扁平化的整数列表返回。在上述例子中，返回的结果是包含所有菜单权限的列表。获取当前角色放在缓存的菜单列表。
【六】springboot整合redis
weixin_56995925的博客
09-06 2万+
springboot整合redis
SpringBoot整合redis+lettuce
Venus's Blog
08-22 2万+
Spring Boot提供了与Redis的集成框架，可以使用Lettuce作为Redis客户端来进行整合。
springboot整合redis
lwj_07的博客
08-10 4万+
创建springboot整合redis工程： 首先我们要知道什么是redis： 三个步骤：补充：RedisTemplate对象提供了各种往redis数据库中存储数据的类型： 代码演示如下所示：注意：下面所有的步骤，要保证Redis数据库是开启的状态，要不然肯定连接不上Redis数据库 第一步： 第二步： 第三步： 又因为我们知道Redis数据库支持多种格式的存储数据形式，因此还可以往Redis数据库中存储哈希类型的数据（哈希类型：就类似于一个key里面又放入一个key，value），因此Redis
Springboot整合Redis
weixin_53676834的博客
03-29 1272
首先我们要知道Redis是什么：Redis一个NoSQL数据库，常用作缓存使用( cache )，用户访问应用，如果找数据的话会先访问redis，如果redis中有数据的话就直接返回发给用户，如果redis中没有的话我们再去查数据库，找到了数据之后一方面存到redis中，另一方面再反馈给用户，目的是说如果用户下次再访问类似的数据的话，redis中就有了。Redis如何启动：双击；客户端双击exit就退出了。
SpringBoot整合redis
qi341500的博客
01-03 1368
SpringBoot整合redis 1、集成jedis 2、集成lettuce 3、集成RedisTemplate
Springboot整合Redis（非常详细的springboot整合redis的介绍哦）
qq_39746820的博客
04-19 3190
springboot整合redis
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
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的消息队列，以此来实现实时、高效的异步秒杀...
外卖项目day08---店铺营业状态设置/用到redis
2301_79693537的博客
07-23 229
【代码】外卖项目day08---店铺营业状态设置/用到redis。
Redisson中RQueue的使用场景附一个异步的例子
最新发布
qq_40592590的博客
07-24 953
redis
Redis 7.x 系列【29】集群原理之自动故障转移
记录知识、锤炼自我
07-24 979
当 Redis 集群的某些节点出现故障时，可以自动进行故障转移，地将从节点提升为主节点，保证服务的连续性和数据的可用性。
分布式缓存与Redis
modelsetget的博客
07-24 632
为读者提供对分布式缓存和Redis的深入理解
使用springboot整合redis
06-23
Spring Boot 与 Redis 的集成可以帮助你轻松地在 Spring 应用程序中使用 Redis 数据存储。以下是一般的步骤： 1. 添加依赖：首先，你需要在你的 Maven 或 Gradle 项目中添加 Spring Data Redis 和 Spring Boot ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值