Spring Boot 集成 Redis：从入门到实战

已于 2025-03-07 16:39:07 修改
阅读量850 收藏 19
点赞数 11
分类专栏： 跟着DeepSeek做项目 文章标签： spring boot redis 后端 java
于 2025-03-07 16:08:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_57300198/article/details/146097840
版权

在现代应用开发中，缓存是提升系统性能的重要手段之一。Redis 作为一种高性能的内存数据存储系统，广泛应用于缓存、消息队列等场景。Spring Boot 提供了对 Redis 的无缝集成，使得开发者可以轻松地在应用中使用 Redis。本文将详细介绍如何在 Spring Boot 项目中集成 Redis，并通过实战示例展示如何使用 Redis 缓存。

目录

  1. Redis 简介
  2. Spring Boot 集成 Redis 的步骤
  3. 使用 Redis 缓存
  4. 高级配置
  5. 总结

Redis 简介

Redis 是一个开源的内存数据存储系统，支持多种数据结构（如字符串、哈希、列表等）。它通常用作缓存、消息队列和分布式锁等场景。Redis 的主要特点包括：

  • 高性能：数据存储在内存中，读写速度极快。
  • 持久化：支持将数据持久化到磁盘。
  • 丰富的数据结构：支持字符串、哈希、列表、集合、有序集合等。

Spring Boot 集成 Redis 的步骤

添加依赖

在 pom.xml 中添加 Spring Data Redis 和 Jedis（或 Lettuce）的依赖：

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

配置 Redis 连接

在 application.properties 或 application.yml 中配置 Redis 连接信息：

# Redis服务器地址
spring.redis.host=localhost
# Redis服务器端口
spring.redis.port=6379
# Redis密码（如果没有密码，可以省略）
spring.redis.password=
# 连接超时时间（毫秒）
spring.redis.timeout=2000
# 连接池配置（可选）
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.min-idle=0

配置 RedisTemplate

Spring Boot 默认提供了 RedisTemplate 和 StringRedisTemplate，但你可以根据需求自定义配置：

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.StringRedisSerializer;

@Configuration
public class RedisConfig {

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

        // 设置Key的序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // 设置Value的序列化器
        template.setValueSerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new StringRedisSerializer());

        return template;
    }
}

使用 RedisTemplate 操作 Redis

在 Service 或 Controller 中注入 RedisTemplate 或 StringRedisTemplate，然后使用它操作 Redis：

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

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 存储数据到Redis
     */
    public void setValue(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 从Redis获取数据
     */
    public Object getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 存储数据到Redis，并设置过期时间
     */
    public void setValueWithExpire(String key, Object value, long timeout) {
        redisTemplate.opsForValue().set(key, value, timeout, java.util.concurrent.TimeUnit.SECONDS);
    }

    /**
     * 删除Redis中的数据
     */
    public void deleteValue(String key) {
        redisTemplate.delete(key);
    }
}

使用 Redis 缓存

启用缓存

在 Spring Boot 应用中，需要在启动类或配置类上添加 @EnableCaching 注解，以启用缓存功能：

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableCaching
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

缓存注解

Spring Cache 提供了一套声明式的缓存注解，可以方便地将缓存逻辑添加到方法上：

  • @Cacheable：将方法的返回值缓存起来。
  • @CachePut：将方法的返回值更新到缓存中。
  • @CacheEvict：从缓存中删除指定的数据。
  • @Caching：组合多个缓存操作。
  • @CacheConfig：在类级别统一配置缓存的公共属性。

示例代码 

import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    /**
     * 根据ID查询用户信息，并缓存结果
     */
    @Cacheable(value = "user", key = "#id")
    public User getUserById(Long id) {
        // 模拟从数据库获取用户
        System.out.println("Fetching user from database: " + id);
        return new User(id, "John");
    }

    /**
     * 更新用户信息，并更新缓存
     */
    @CachePut(value = "user", key = "#user.id")
    public User updateUser(User user) {
        // 模拟更新用户信息
        System.out.println("Updating user: " + user.getId());
        return user;
    }

    /**
     * 删除用户信息，并删除缓存
     */
    @CacheEvict(value = "user", key = "#id")
    public void deleteUser(Long id) {
        // 模拟删除用户信息
        System.out.println("Deleting user: " + id);
    }

	/**
     * 组合多个缓存操作
     * 调用getUserByIdWithCaching(1)时，会缓存结果到user分区，并删除temp分区中键为1的数据。
     */
    @Caching(
        cacheable = @Cacheable(value = "user", key = "#id"),
        evict = @CacheEvict(value = "temp", key = "#id")
    )
    public User getUserByIdWithCaching(Long id) {
        // 模拟从数据库获取用户
        System.out.println("Fetching user from database: " + id);
        return new User(id, "John");
    }
}

@CacheConfig 示例 

import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Caching;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.stereotype.Service;

@Service
@CacheConfig(cacheNames = "user") // 类级别缓存配置
public class UserService {

    /**
     * 根据ID查询用户信息，并缓存结果
     */
    @Cacheable(key = "#id")
    public User getUserById(Long id) {
        // 模拟从数据库获取用户
        System.out.println("Fetching user from database: " + id);
        return new User(id, "John");
    }
}

高级配置

缓存过期时间

在 application.properties 中配置缓存的全局过期时间：

spring.cache.redis.time-to-live=60000

自定义缓存配置

可以通过 RedisCacheManager 自定义缓存配置：

import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import java.time.Duration;

@Configuration
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)); // 设置缓存过期时间为10分钟

        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .build();
    }
}

总结

通过本文的介绍，你已经掌握了如何在 Spring Boot 项目中集成 Redis，并使用 Redis 实现缓存功能。主要步骤包括：

  1. 添加 Redis 依赖。
  2. 配置 Redis 连接信息。
  3. 配置 RedisTemplate。
  4. 使用 RedisTemplate 操作 Redis。
  5. 使用 Spring Cache 注解实现缓存功能。

Redis 的强大功能结合 Spring Boot 的便捷开发，可以显著提升应用性能和开发效率。希望本文对你有所帮助，欢迎在评论区交流讨论！

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值