在SpringBoot项目中配置Redis

已于 2023-04-25 23:57:29 修改
阅读量9.4k 收藏 35
点赞数 7
分类专栏： SpringBoot Redis 文章标签： java redis spring boot 数据库 maven
于 2023-04-25 19:45:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63445035/article/details/130342832
版权

目录

一、前言

二、使用步骤

1. 引入start依赖

2. 在application.yml配置文件中做相应配置

3. 配置Redis序列化器

4. 将序列化器配置到redisTemplate中

5. 封装Redis操作工具类

一、前言

我们知道Redis适用于存储频繁使用的数据，因为Redis数据库是基于缓存的非关系数据库，相比较关系型数据库，查询的速度更快，但不适合表示复杂关系，那知道它这一特性，就会明白在实际项目中，会经常使用到Redis，就比如我最近做的博客项目，就是将文章浏览量存储到Redis中，因为每次都从数据库中去查询浏览量，肯定效率就不是很高了，所以我就在最开始就将文章的浏览量数据放到Redis中，每次也是更新的浏览量中的数据，再使用定时框架，定时的更新到数据库即可，另外秒杀的时候也要用到Redis，既然Redis使用这么频繁，那么该怎样使用Java语言操作Redis呢？接下来，我就讲一下在SpringBoot项目中如何配置Redis，下面我就简单说明步骤。

二、使用步骤

其实配置Redis和配置其它东西都差不多，既然使用了SpringBoot，基于自动配置，使用无非就是引依赖、然后在yml配置文件中做相应的配置即可，或者还可以使用配置类进行配置，有个时候可能还要启动一下，在启动类上面加个启动注解，使用Redis不需要这一步。

1. 引入start依赖

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

由于序列化方式依靠的是fastjson序列化框架，因此也要有fastjson依赖，如果没有使用自定义序列化，则这个不是必须的，另外如果基于的是其它第三方序列化框架，则添加对应的依赖即可

 <!--fastjson依赖-->
 <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.76</version>
 </dependency>

2. 在application.yml配置文件中做相应配置

spring:
  redis:
    # Redis本地服务器地址，注意要开启redis服务，即那个redis-server.exe
    host: localhost
    # Redis服务器端口,默认为6379.若有改动按改动后的来
    port: 6379
    #Redis服务器连接密码，默认为空，若有设置按设置的来
    password: 
    lettuce:
      pool:
        # 连接池最大连接数，若为负数则表示没有任何限制
        max-active: 8
        # 连接池最大阻塞等待时间，若为负数则表示没有任何限制
        max-wait: -1
        # 连接池中的最大空闲连接
        max-idle: 8

3. 配置Redis序列化器

public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{
    @SuppressWarnings("unused")
    private ObjectMapper objectMapper = new ObjectMapper();

    //配置序列化与反序列化字符集
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    //开启 fastjson 序列化库的自动类型支持功能，开启后，会在序列化或反序列化过程中自动添加类型信息，确保序列化与反序列化成功
    static
    {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }

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

    //序列化过程，使用fastjson将对象转为字节数组
    @Override
    public byte[] serialize(T t) throws SerializationException
    {
        if (t == null)
        {
            return new byte[0];
        }
        //添加SerializerFeature.WriteClassName可以在序列化时，添加类型信息
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    //反序列化过程，将字节数组转为Java对象
    @Override
    public T deserialize(byte[] bytes) throws SerializationException
    {
        if (bytes == null || bytes.length <= 0)
        {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        //解析为clazz类型的对象
        return JSON.parseObject(str, clazz);
    }

    public void setObjectMapper(ObjectMapper objectMapper)
    {
        Assert.notNull(objectMapper, "'objectMapper' must not be null");
        this.objectMapper = objectMapper;
    }

    protected JavaType getJavaType(Class<?> clazz)
    {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

4. 将序列化器配置到redisTemplate中

@Configuration
public class RedisConfig {

        @Bean
        @SuppressWarnings(value = { "unchecked", "rawtypes" })
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
        {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(connectionFactory);

            FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);

            ObjectMapper mapper = new ObjectMapper();
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
            serializer.setObjectMapper(mapper);

            // 使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(serializer);

            // Hash的key也采用StringRedisSerializer的序列化方式
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(serializer);

            template.afterPropertiesSet();
            return template;
        }
}

5. 封装Redis操作工具类

@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;

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

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer 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 <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @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 <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

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

    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
    {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext())
        {
            setOperation.add(it.next());
        }
        return setOperation;
    }

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

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

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

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

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 删除Hash中的数据
     * 
     * @param key
     * @param hkey
     */
    public void delCacheMapValue(final String key, final String hkey)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(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);
    }

    /**
     * 为Redis中value对应的map增加value
     * @param key 键值
     * @param hKey value-map对应的键值
     * @param v value-map 对应的value值
     */
    public void incrementCacheMapValue(String key,String hKey,int v){
        redisTemplate.boundHashOps(key).increment(hKey, v);
    }
}

如果大家对Redis的序列化还想进一步了解的化，可以参考我的另外一篇文章

https://blog.csdn.net/m0_63445035/article/details/130371592?spm=1001.2014.3001.5502

渣瓦攻城狮
关注
  • 7
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot+mybatis+redis源码示例
11-19
该示例集合了springboot+mybatis+redis。并包含了mysql脚本。 演示了mybatis从mysql数据库查询到数据并将数据存入到redis缓存的过程。 程序启动后，请在浏览器访问：ip:port/redis/test?id=10001(查询的数据ID) 该示例是纯净的，只引入了需要的架包。 注意：使用时，请在application.properties文件中配置你的mysql信息和redis信息。
SpringBoot项目+MybatisPlus使用+Redis缓存
02-15
SpringBoot项目+MybatisPlus使用+Redis缓存
Spring Boot 整合 Redis 全面教程：从配置到使用
weixin_43749805的博客
06-26 2万+
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。
Spring Boot 整合 Redis 超详细教程
weixin_44966143的博客
02-28 1441
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。话不多说直接干货！！！
SpringBoot集成Redis应用配置（附完整配置文件）
01-20
SpringBoot集成Redis应用配置（附完整配置文件）
Redis的基本使用和SpringBoot集成Redis
y516369的博客
09-18 2107
Redis的基本使用和SpringBoot集成Redis
springboot整合redis配置
qq_19891197的博客
02-08 1万+
springboot整合redis配置
SpringBoot中Redis配置
ahwangzc的博客
05-24 7030
#连接池最大阻塞等待时间（使用负值表示没有限制）# 连接池的最大数据库连接数。# 连接池中的最小空闲连接。# 连接池中的最大空闲连接。2、配置application.yml。# 端口，默认为6379。5、Service文件中使用。4、Redis工具类。3、Redis配置类。
【突破舒适圈】在SpringBoot中配置Redis
热门推荐
qq_41997592的博客
02-10 2万+
首次尝试Springboot中配置Redis，初探一下。
快速入门 - Spring Boot 集成 Redis 配置及使用
CYK_byte的博客
03-27 6473
Spring Boot 集成 Redis 配置及使用 （代码+详细注释）
Redis的两个常用工具类
Hexialin的博客
08-26 701
1.RedisConfig配置类 启用Spring对Redis缓存支持，把Redis放入到Spring容器中 package com.example.ctrip.config; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccesso...
springboot集成redis集群,redis安装包配置
09-02
springboot集成redis集群,redis安装包配置，参考文章：https://blog.csdn.net/zhizhuodewo6/article/details/82316164
application.yml
03-28
标题：学习如何在Java中连接和使用Redis：安装和配置指南 ### 引言 Redis 是一个流行的开源内存数据库，它提供了快速、可扩展和灵活的键值存储。本文将介绍如何在Java应用程序中连接和使用Redis。我们将首先讨论如何安装和配置Redis服务器，然后演示如何在Java中使用Redis客户端库来进行基本的操作。 ### 步骤一：安装和配置Redis 1. **下载和安装**：访问 Redis 官方网站（https://redis.io/download）并下载最新的稳定版本。按照官方文档中的指南安装 Redis。 2. **启动 Redis 服务器**：启动 Redis 服务器并确保它正在运行。你可以通过运行 `redis-server` 命令来启动。 ### 步骤二：在Java中连接Redis 1. **选择一个Java Redis客户端**：在 Java 中有多个可用的 Redis 客户端库，比如 Jedis 和 Lettuce。这里我们将使用 Jedis 作为示例。 2. **添加依赖**：在你的 Java 项目中添加 Jedis 依赖。如果是使用 Maven，可
springboot+jpa(hibernate配置redis为二级缓存) springboot2.1.4
04-23
基于springboot最新版本2.1.4.RELEASE，采用jpa为dao层框架，配置redis（redisson）为hibernate的二级缓存。
基于springboot+mybatis+redis+es+bootstrap的搜索实战项目
07-10
技术选型 springboot + mybatis + bootstrap + jqgrid + ajax + elasticsearch(用到在整合) + redis(用到在整合) 项目编码: UTF-8 项目名称: poem 数据库名称: poem 项目中包结构: src/main/java com.baizh.xxx .util 工具包 .entity 实体类 .dao dao包 .service 业务包 .controller 控制器 .elasticsearch.dao esDAO接口包 .config 项目配置包 ..... src/main/resources application.properties springboot配置文件 com/baizhi/mapper/*.xml mapper配置文件 webapp boot bootstrap相关css index.jsp 前台搜索 back.jsp 后台管理 需求: 1.前台搜索 (根据输入条件进行分词查询 同时检索结果必须存在高亮处理) 2.后台功能 a.jqgrid中分页展示古诗词数据(数据库 mysql) 增删改查 b.基于数据库中数据重建es索引库 c.删除所有文档 d.关键词记录 e.远程词典操作
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
Seckill:基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统
03-11
1，启动前，请配置application.properties中相关的redis，mysql，rabbitmq地址。 2，登录地址： 3，商品秒杀列表地址： 其他说明 1，数据库共有一千个用户左右（手机号：从18077200000〜18077200998密码为：...
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 451
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1532
c++中string的模拟实现，面试必会知识点
编写在springboot项目中的redis配置类
09-07
在Spring Boot项目中，可以使用RedisTemplate来配置Redis。RedisTemplate提供了一些常用的方法，可以用来存储和获取键值对、列表、集合和有序集合等类型的数据。可以通过配置RedisTemplate来实现Redis的连接，从而实现在Spring Boot项目中使用Redis的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值