redis整合springboot

springboot项目中如何整合redis做缓存并且实现分布式锁
jdk1.8
maven 3.3.9
redis用什么版本 maven依赖 yml文件

提供参考实例：https://blog.csdn.net/yaxuan88521/article/details/129079136

以下内容部分参考ChatGPT模型：

首先，需要在pom.xml中添加redis和spring-boot-starter-data-redis的依赖：

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

然后，在application.yml中添加redis的配置：

spring:
  redis:
    host: localhost
    port: 6379
    password: 
    timeout: 10000
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0

接下来，可以通过注入RedisTemplate来进行redis的操作，例如：

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void set(String key, Object value) {
    ValueOperations<String, Object> operations = redisTemplate.opsForValue();
    operations.set(key, value);
}

public Object get(String key) {
    ValueOperations<String, Object> operations = redisTemplate.opsForValue();
    return operations.get(key);
}

最后，实现分布式锁可以使用Redisson，首先需要在pom.xml中添加依赖：

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.14.0</version>
</dependency>

然后，在需要加锁的方法中使用Redisson即可：

@Autowired
private RedissonClient redissonClient;

public void doSomething() {
    RLock lock = redissonClient.getLock("myLock");
    try {
        lock.lock();
        // do something
    } finally {
        lock.unlock();
    }
}

以上就是整合redis做缓存并实现分布式锁的思路和代码示例。

如果我的建议对您有帮助、请点击采纳、祝您生活愉快

参考GPT和自己的思路：1. 在pom.xml中添加redis和spring-data-redis的依赖：

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

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.5.3</version>
</dependency>

在application.yml中配置redis的连接信息：

spring:
  redis:
    host: localhost
    port: 6379
    password: xxxxxxxx
    timeout: 5000
    jedis:
      pool:
        max-active: 8
        max-wait: -1s
        max-idle: 8
        min-idle: 0

在代码中注入RedisTemplate：

@Autowired
private RedisTemplate<String, Object> redisTemplate;

使用RedisTemplate操作redis，例如：

redisTemplate.opsForValue().set("key", "value");
redisTemplate.opsForValue().get("key");

实现分布式锁，可以使用Redisson库，具体代码如下：

private RedissonClient redissonClient;

private RLock lock = redissonClient.getLock("lockKey");

try {
    // 在锁定时间到达之前，尝试获取锁
    boolean locked = lock.tryLock(10, TimeUnit.SECONDS);
    if (locked) {
        // 如果成功获取到锁，则执行需要互斥的代码
    } else {
        // 如果获取失败，则执行其他逻辑
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    // 最后一定要释放锁
    lock.unlock();
}

Redis的版本可以根据需求选择，推荐使用较新的版本，如5.x及以上。

要在Spring Boot项目中整合Redis作为缓存，并实现分布式锁，您可以按照以下步骤操作：

添加Maven依赖
在pom.xml文件中添加Spring Boot的Redis依赖：


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

<!-- 如果您需要使用Redisson作为分布式锁实现 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.4</version>
</dependency>

关于Redis的版本，您无需担心，因为spring-boot-starter-data-redis依赖会自动为您选择合适的版本。

配置application.yml
在application.yml文件中，配置Redis的相关信息，例如主机、端口、密码等：

spring:
  redis:
    host: localhost
    port: 6379
    password: your_password_if_needed
    timeout: 5000 # 以毫秒为单位的连接超时时间
    jedis:
      pool:
        max-active: 8 # 连接池最大连接数
        max-idle: 8   # 连接池中的最大空闲连接
        min-idle: 0   # 连接池中的最小空闲连接
        max-wait: -1  # 连接池最大阻塞等待时间（使用负值表示没有限制）

创建Redis配置类
创建一个配置类，用于设置RedisTemplate、RedissonClient等：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

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

        // 使用StringRedisSerializer和GenericJackson2JsonRedisSerializer进行序列化和反序列化
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();

        template.setKeySerializer(stringSerializer);
        template.setValueSerializer(jsonSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setHashValueSerializer(jsonSerializer);

        return template;
    }

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        String redisUrl = "redis://" + host + ":" + port;
        config.useSingleServer().setAddress(redisUrl);

        return Redisson.create(config);
    }
}

使用Redis作为缓存
现在您可以在您的项目中使用RedisTemplate来存储和检索缓存数据。例如：

@Autowired
private RedisTemplate<String, Object> redisTemplate;

接下来，以一个简化的用户服务为例，我们希望根据用户ID来获取用户信息，并将这些信息缓存在Redis中。

首先，创建一个User实体类：

public class User {
    private Long id;
    private String name;
    private String email;
    // getter和setter方法
}

创建一个UserService类，用于处理用户数据的获取和缓存：

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

@Service
public class UserService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public User getUserById(Long id) {
        String key = "user:" + id;

        // 尝试从Redis中获取数据
        User user = (User) redisTemplate.opsForValue().get(key);

        if (user == null) {
            // 如果Redis中没有数据，则从数据库或其他数据源获取
            user = fetchUserByIdFromDatabase(id);

            // 将数据缓存在Redis中
            redisTemplate.opsForValue().set(key, user);
        }

        return user;
    }

    private User fetchUserByIdFromDatabase(Long id) {
        // 在这里实现从数据库中获取用户数据的逻辑
    }
}

使用Redisson实现分布式锁
首先，需要在需要使用分布式锁的方法上添加@Autowired注解，注入RedissonClient实例。然后，您可以使用RedissonClient创建一个分布式锁，并在需要的地方上锁和解锁。以下是一个示例：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class DistributedLockService {

    @Autowired
    private RedissonClient redissonClient;

    public void executeSynchronizedTask(String lockName) {
        RLock lock = redissonClient.getLock(lockName);
        try {
            // 尝试在10秒内获取锁，锁的持有时间为60秒
            if (lock.tryLock(10, 60, TimeUnit.SECONDS)) {
                try {
                    // 在这里执行需要同步的任务
                } finally {
                    lock.unlock();
                }
            } else {
                // 无法获取锁，处理相应的逻辑
            }
        } catch (InterruptedException e) {
            // 处理异常
        }
    }
}

```
在上述示例中，您可以使用executeSynchronizedTask方法在分布式环境中执行需要同步的任务。RedissonClient会确保在同一时间只有一个进程能够执行该任务。

请看👉 ：Springboot 2.6集成redis maven报错的坑
除此之外, 这篇博客: Spring Boot 整合 Redis（使用 redisTemplate）中的 1.添加 redis Maven依赖 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

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

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
整合Redis缓存的步骤：

1.添加Redis的Maven依赖

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

2.配置Redis连接

在application.yml中添加Redis的相关配置信息：

spring:
  redis:
    host: 127.0.0.1  # Redis服务地址
    port: 6379  # Redis服务端口
    database: 0  # Redis使用的数据库编号，默认是0
    password:  # Redis服务密码，如果有的话需要配置

3.使用Redis缓存

在需要使用Redis缓存的Service或Repository中添加注解@Cacheable、@CacheEvict或@CachePut即可：

@Service
public class UserService {
 
    @Autowired
    private UserRepository userRepository;
 
    @Cacheable(value = "userCache", key = "#id")
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
 
    @CacheEvict(value = "userCache", key = "#id")
    public void deleteUserById(Long id) {
        userRepository.deleteById(id);
    }
 
    @CachePut(value = "userCache", key = "#user.id")
    public User saveUser(User user) {
        return userRepository.save(user);
    }
 
}

4.实现分布式锁

Redis可以使用setnx命令实现分布式锁，具体的实现可以借助Redis的Template来完成，代码如下：

@Service
public class DistributedLockService {
 
    private static final String LOCK_KEY = "DISTRIBUTED_LOCK_KEY";  // 锁的key值
    private static final int LOCK_EXPIRE_TIME = 10000;  // 锁定超时时间
    private static final int SLEEP_TIME = 500;  // 获取锁时重试的间隔（毫秒）
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public boolean acquireLock() {
        boolean success = false;
        while (!success) {
            Boolean result = redisTemplate.opsForValue().setIfAbsent(LOCK_KEY, "LOCK_VALUE", LOCK_EXPIRE_TIME, TimeUnit.MILLISECONDS);
            if (result != null && result) {
                success = true;  // 获取锁成功
            } else {
                try {
                    Thread.sleep(SLEEP_TIME);  // 休眠后重试获取锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        return true;
    }
 
    public boolean releaseLock() {
        Boolean result = redisTemplate.delete(LOCK_KEY);
        return result != null && result;
    }
 
}

以上就是整合Redis缓存和实现分布式锁的步骤和代码，希望对你有所帮助。
如果我的回答解决了您的问题，请采纳！