Springboot-Redis - 11.Redis 事务

👀Redis 事务

确实，Redis 的事务行为与传统的关系数据库事务有所不同。在关系数据库中，如果事务的一部分失败，整个事务通常会被回滚，保证数据的完整性。但在 Redis 中，情况并不完全如此。

✌ Redis 事务的特点：

✍1. 命令队列：

当你在 Redis 中启动一个事务（使用 MULTI），事务中的命令不会立即执行，而是被放入一个队列。当你发出 EXEC 命令时，所有队列中的命令才会按顺序执行。

✍2. 无回滚：

如果事务块中的某个命令失败，Redis 不会回滚其他命令。它会继续执行队列中的其他命令。例如，如果事务中有五个命令，其中第三个命令由于某种原因失败了，第四和第五个命令仍然会被执行。

✍3. 错误报告：

如果事务中的一个命令失败，当 EXEC 被调用时，Redis 会返回一个错误列表，显示事务中每个命令的结果。成功的命令会返回其结果，而失败的命令会返回一个错误消息。

• 假设我们有一个简单的场景，我们想在 Redis 中设置两个键。第一个键是正常的，但第二个键由于某种原因导致了错误（例如，使用了错误的命令或参数）。

redisTemplate.multi();
redisTemplate.opsForValue().set("key1", "value1");
redisTemplate.opsForList().leftPush("key2", "value2", "extraArgCausingError");
List<Object> results = redisTemplate.exec();

• 在上面的示例中，我们首先调用 multi() 开始一个事务。然后，我们尝试设置两个键。第二个命令故意制造了一个错误。最后，我们调用 exec() 执行事务。

• 尽管第二个命令失败了，但事务仍然会继续，key1 会被设置，但 key2 不会。results 列表将包含每个命令的结果，其中失败的命令将返回一个错误消息。

• 当在 Redis 中使用事务时，你必须非常小心。确保你理解 Redis 的事务模型和其与传统关系数据库的不同之处。特别是，你应该为可能的命令错误做好准备，并确保你的应用程序可以适当地处理这些错误，而不是简单地假设整个事务都会回滚。

✌ 基本命令：

• MULTI：标记事务块的开始。
• EXEC：执行所有事务块内的命令。
• DISCARD：取消事务。
• WATCH：监视一个或多个键，如果在事务执行之前这些键被其他客户端修改，则事务会被中断。

✌ 作用：

确保一系列命令的原子性执行。

✌ 使用场景：

• 当你需要确保一系列操作都成功执行或都不执行时，例如，在更新多个相关的数据项时。
• 在需要检测数据在事务开始后是否被其他客户端修改的场景中使用 WATCH。

✌ 优点：

• 保证了命令序列的原子性。
• 提供了一种方式来检测和响应外部对正在修改的数据的更改。

✌ 缺点：

• Redis 的事务不像关系数据库的事务那样提供完全的 ACID 保证。
• 如果事务中的命令导致错误，事务仍然会继续执行，而不是回滚。

✌ 示例代码：

在 Spring Boot 中使用 Spring Data Redis 进行事务处理：

✍1. 配置：首先确保 RedisTemplate 有启用事务功能：

@Configuration
public class RedisConfig {

    @Autowired
    private RedisConnectionFactory connectionFactory;

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

✍2. 使用 SessionCallback：

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void executeTransaction() {
    redisTemplate.execute(new SessionCallback<Object>() {
        @Override
        public Object execute(RedisOperations operations) throws DataAccessException {
            operations.multi();
            operations.opsForValue().set("key1", "value1");
            operations.opsForValue().set("key2", "value2");
            // ... other operations
            return operations.exec();
        }
    });
}

✍3. 使用 multi 和 exec：

public void executeTransactionUsingMultiExec() {
    redisTemplate.multi();
    redisTemplate.opsForValue().set("key1", "value1");
    redisTemplate.opsForValue().set("key2", "value2");
    // ... other operations
    redisTemplate.exec();
}

✌ @Transactional 的支持和 RedisTemplate 事务

在 Spring Framework 中，@Transactional 注解用于声明事务的边界，将一系列操作作为一个事务进行管理。然而，默认情况下，RedisTemplate 并不会参与 Spring 的事务管理。如果你希望在使用 @Transactional 或 TransactionTemplate 时利用 Redis 事务，你可以通过设置 setEnableTransactionSupport(true) 来为每个 RedisTemplate 启用事务支持。

✍作用：

• 在 Spring 事务中使用 Redis 事务，实现多个数据库操作的一致性。
• 提供更强大的数据一致性和事务隔离级别。

✍使用场景：

• 当你需要在一个事务中同时操作关系数据库和 Redis 数据库时，可以使用事务支持来确保数据一致性。
• 在处理复杂的业务逻辑时，可能需要对多个操作进行事务管理，以保证业务操作的原子性。

✍优缺点：

优点：

• 数据一致性：通过将 Redis 操作纳入 Spring 事务管理，可以确保关系数据库和 Redis 数据库的一致性。
• 原子性：使用事务支持可以确保 Redis 操作和关系数据库操作都要么全部成功，要么全部失败。

缺点：

• 性能：事务会引入额外的性能开销，特别是在高并发场景下可能会影响性能。
• 复杂性：事务管理可能增加代码的复杂性，特别是在多个数据源和操作中。

✍示例代码：

假设你正在开发一个 Spring Boot 应用，该应用需要在一个事务中同时更新关系数据库和 Redis 数据库。

🎷1. 添加 Spring Data Redis 和 Spring Data JPA 依赖：

在 build.gradle 或 pom.xml 中添加 Spring Data Redis 和 Spring Data JPA 依赖。

🎷2. 创建一个 Service 类来演示在事务中操作关系数据库和 Redis 数据库：

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

@Service
public class TransactionalService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Transactional
    public void updateUserAndRedis(String userId, String newUsername) {
        // 更新关系数据库
        User user = userRepository.findById(userId).orElse(null);
        if (user != null) {
            user.setUsername(newUsername);
            userRepository.save(user);
        }

        // 更新 Redis
        redisTemplate.opsForValue().set(userId, newUsername);
    }
}

🎷3. 配置事务管理器：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "com.example.repository")
public class TransactionConfig implements TransactionManagementConfigurer {

    @Bean
    public PlatformTransactionManager transactionManager() {
        // 配置 JPA 事务管理器
    }

    @Override
    public PlatformTransactionManager annotationDrivenTransactionManager() {
        return transactionManager();
    }
}

在上述示例中，TransactionalService 类中的 updateUserAndRedis 方法使用了 @Transactional 注解，使得其中的关系数据库更新和 Redis 更新操作都在同一个事务中进行。这样，如果任何一个操作失败，整个事务都会回滚。

请注意，实际应用中需要根据项目的需求进行适当的配置和调整，确保事务的一致性和正确性。