开源工具（一）Redis事务回滚

已于 2023-12-14 14:46:08 修改
阅读量1.3w 收藏 8
点赞数 6
分类专栏： java redis 文章标签： redis java
于 2022-04-14 10:02:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69270256/article/details/124164125
版权
java 同时被 2 个专栏收录
31 篇文章 3 订阅
订阅专栏
redis
6 篇文章 1 订阅
订阅专栏

一、引言

        github地址：GitHub - SongTing0711/redis-transaction        

        开发过程中redis与db的数据不一致经常令人头痛，因为在Mysql遇到异常回滚之后redis不会变化，对业务功能产生影响，本文基于AOP和栈开发redis的事务回滚机制，保证数据一致性！

        这里有技术人员咨询过博主，为什么不使用异步写的操作，异步写存在延时情况，当业务数据存在强一致性的场景就不适合异步写。

        还有人咨询为什么不使用redis提供的事务命令+管道命令进行一次性发送？

1、这里要知道redis的事务命令是不具备持久性的，其实就是放在入口处的队列命令，在《Redis深度历险》中有详细介绍，所以这种方式和使用本地ThreadLocal的风险是一样的

2、另外这种相当于把压力全部给到了redis，而一个redis集群往往不是只服务于一个系统，很容易导致redis的波动，而且还不能优化，因为压力是来自各方的

3、一串redis操作在最后一起发出，这个非常不利于代码解耦，后续的维护也会困难

        基于以上种种考虑，博主开发了基于补偿回滚策略的redis回滚工具。

二、RedisTransaction组件

1、注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisTransaction {
    //是否自动清除RedisTransactionUtil
    boolean atuoRemove() default false;
    //如果使用RedisTemplate或者StringRedisTemplate操作集合删除，需要设置
    long index() default 0l;
}

2、工具类

①操作类型枚举

        开发项目中对于redis的使用场景基本是存储、查询、删除，对于数据一致性会产生影响的就是存储和删除。

@Getter
public enum RedisOperateTypeEnum {

    STRING_SET("string", "add"),
    STRING_DELETE("string", "delete"),
    LIST_ADD("list", "add"),
    LIST_REMOVE("list", "remove"),
    ;

    private String dataType;
    private String operateType;

    RedisOperateTypeEnum(String key, String value) {
        this.dataType = key;
        this.operateType = value;
    }
}

public enum RedisClientTypeEnum {

    REDISSON("redisson"),
    REDIS_TEMPLATE("redisTemplate"),
    STRING_REDIS_TEMPLATE("stringRedisTemplate"),
    ;

    private String redisClientType;

    RedisClientTypeEnum(String redisClientType) {
        this.redisClientType = redisClientType;
    }
}

②存储实体

@Data
public class RedisOperateUtil<T> {

    private RedisOperateTypeEnum operateTypeEnum;
    private String key;
    private T value;
    private T prevValue;
}

 ③ThreadLocal工具类

public class RedisTransactionUtil {

    static ThreadLocal<Stack> TRANSACTION_QUEUE = new ThreadLocal<Stack>();

    public static void add(RedisOperateUtil redisOperateUtil) {
        if (Objects.isNull(TRANSACTION_QUEUE.get())) {
            Stack stack = new Stack();
            TRANSACTION_QUEUE.set(stack);
        }
        TRANSACTION_QUEUE.get().add(redisOperateUtil);
    }
    public static Stack get() {
        return TRANSACTION_QUEUE.get();
    }
    public static void remove() {
        TRANSACTION_QUEUE.remove();
    }
}

3、切面

        这里展示了String的处理，其他redis数据类型操作原理相同，都是根据栈中存储的redis操作进行逆序反向处理。

package com.core;

import com.annotation.RedisTransaction;
import com.util.RedisTransactionCacheUtils;
import com.util.RedisOperateUtil;
import com.util.RedisTransactionUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Objects;
import java.util.Stack;

/**
 * redis事务，切面处理类
 */
@Slf4j
@Aspect
@Component
public class RedisTransactionAspect {

    @Resource
    private RedisTransactionCacheUtils redisTransactionCacheUtils;

    @Pointcut("@annotation(com.annotation.RedisTransaction)")
    public void transactionPointCut() {
    }

    @AfterReturning("transactionPointCut() && @annotation(redisTransaction)")
    public void afterReturning(RedisTransaction redisTransaction) {
        //如果方法注解中开启自动清除，就去除
        if (redisTransaction.atuoRemove()) {
            RedisTransactionUtil.remove();
            log.info("自动清除RedisTransactionUtil:{}", Thread.currentThread().getName());
        }
    }

    @AfterThrowing("transactionPointCut() && @annotation(redisTransaction)")
    public void afterThrowing(RedisTransaction redisTransaction) {
        try {
            Stack<RedisOperateUtil> stack = RedisTransactionUtil.get();
            if (Objects.isNull(stack)) {
                return;
            }
            log.info("redis回滚:{}", stack);
            RedisOperateUtil redisOperateUtil;
            while (!stack.isEmpty()) {
                redisOperateUtil = stack.pop();
                switch (redisOperateUtil.getOperateTypeEnum()) {
                    case STRING_SET:
                        if (Objects.nonNull(redisOperateUtil.getPrevValue())) {
                            redisTransactionCacheUtils.stringAdd(redisOperateUtil.getKey(),redisOperateUtil.getPrevValue());
                            break;
                        }
                        redisTransactionCacheUtils.stringDelete(redisOperateUtil.getKey());
                        break;
                    case STRING_DELETE:
                        redisTransactionCacheUtils.stringAdd(redisOperateUtil.getKey(), redisOperateUtil.getValue());
                        break;
                    case LIST_ADD:
                        redisTransactionCacheUtils.listRemove(redisOperateUtil.getKey(), redisOperateUtil.getValue(),redisTransaction.index());
                        break;
                    case LIST_REMOVE:
                        redisTransactionCacheUtils.listAdd(redisOperateUtil.getKey(), redisOperateUtil.getValue());
                        break;
                    default:
                        break;
                }
            }
        } catch (Exception e) {
            log.error("reidis回滚失败:{}", e);
        } finally {
            //如果方法注解中开启自动清除，就去除
            if (redisTransaction.atuoRemove()) {
                RedisTransactionUtil.remove();
                log.info("自动清除RedisTransactionUtil:{}", Thread.currentThread().getName());
            }
        }
    }

}

4、redis包装

@Slf4j
@Component
public class RedisTransactionCacheUtils<V> {

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private void setRedisTransaction(String k, V v, V prev, RedisOperateTypeEnum redisOperateTypeEnum) {
        RedisOperateUtil redisOperateUtil = new RedisOperateUtil();
        redisOperateUtil.setOperateTypeEnum(redisOperateTypeEnum);
        redisOperateUtil.setKey(k);
        redisOperateUtil.setPrevValue(prev);
        redisOperateUtil.setValue(v);
        RedisTransactionUtil.add(redisOperateUtil);
    }

    /**
     * list
     *
     * @return true 成功 false 失败
     */
    public boolean listAddTransaction(String k, V v) {
        try {
            if (v != null) {
                switch (RedisTransactionCommonUtil.getRedisClient()) {
                    case REDISSON:
                        RList<V> list = redissonClient.getList(k);
                        if (!list.contains(v)) {
                            list.add(v);
                            this.setRedisTransaction(k, v, null, RedisOperateTypeEnum.LIST_ADD);
                        }
                        break;
                    case REDIS_TEMPLATE:
                        redisTemplate.opsForList().rightPush(k, v);
                        this.setRedisTransaction(k, v, null, RedisOperateTypeEnum.LIST_ADD);
                        break;
                    case STRING_REDIS_TEMPLATE:
                        stringRedisTemplate.opsForList().rightPush(k, (String) v);
                        this.setRedisTransaction(k, v, null, RedisOperateTypeEnum.LIST_ADD);
                        break;
                    default:
                        throw new RedisTrancactionException("unknown redis client");
                }
                return true;
            }
            return false;
        } catch (Exception e) {
            log.warn("redis setList fail, key = {}, value = {}, e = {}", k, v, e);
            return false;
        }
    }

    /**
     * list
     *
     * @return true 成功 false 失败
     */
    public boolean listAdd(String k, V v) {
        try {
            if (v != null) {
                switch (RedisTransactionCommonUtil.getRedisClient()) {
                    case REDISSON:
                        RList<V> list = redissonClient.getList(k);
                        if (!list.contains(v)) {
                            list.add(v);
                        }
                        break;
                    case REDIS_TEMPLATE:
                        redisTemplate.opsForList().rightPush(k, v);
                        break;
                    case STRING_REDIS_TEMPLATE:
                        stringRedisTemplate.opsForList().rightPush(k, (String) v);
                        break;
                    default:
                        throw new RedisTrancactionException("unknown redis client");
                }
                return true;
            }
            return false;
        } catch (Exception e) {
            log.warn("redis setList fail, key = {}, value = {}, e = {}", k, v, e);
            return false;
        }
    }


    /**
     * list
     *
     * @return true 成功 false 失败
     */
    public boolean listRemoveTransaction(String k, V v, Long index) {
        try {
            if (v != null) {
                switch (RedisTransactionCommonUtil.getRedisClient()) {
                    case REDISSON:
                        RList<V> list = redissonClient.getList(k);
                        if (!list.contains(v)) {
                            list.remove(v);
                            this.setRedisTransaction(k, v, null, RedisOperateTypeEnum.LIST_REMOVE);
                        }
                        break;
                    case REDIS_TEMPLATE:
                        redisTemplate.opsForList().remove(k, index, v);
                        this.setRedisTransaction(k, v, null, RedisOperateTypeEnum.LIST_REMOVE);
                        break;
                    case STRING_REDIS_TEMPLATE:
                        stringRedisTemplate.opsForList().rightPush(k, (String) v);
                        this.setRedisTransaction(k, v, null, RedisOperateTypeEnum.LIST_REMOVE);
                        break;
                    default:
                        throw new RedisTrancactionException("unknown redis client");
                }
                return true;
            }
            return false;
        } catch (Exception e) {
            log.warn("redis deleteFromList fail, key = {}, value = {}, e = {}", k, v, e);
            return false;
        }
    }

    /**
     * list
     *
     * @return true 成功 false 失败
     */
    public boolean listRemove(String k, V v, Long index) {
        try {
            if (v != null) {
                switch (RedisTransactionCommonUtil.getRedisClient()) {
                    case REDISSON:
                        RList<V> list = redissonClient.getList(k);
                        if (!list.contains(v)) {
                            list.remove(v);
                        }
                        break;
                    case REDIS_TEMPLATE:
                        redisTemplate.opsForList().remove(k, index, v);
                        break;
                    case STRING_REDIS_TEMPLATE:
                        stringRedisTemplate.opsForList().rightPush(k, (String) v);
                        break;
                    default:
                        throw new RedisTrancactionException("unknown redis client");
                }
                return true;
            }
            return false;
        } catch (Exception e) {
            log.warn("redis deleteFromList fail, key = {}, value = {}, e = {}", k, v, e);
            return false;
        }
    }

    /**
     * list
     *
     * @return true 成功 false 失败
     */
    public boolean stringSetExpireTransaction(String k, V v, Long timeOut, TimeUnit timeUnit) {
        try {
            if (v == null) {
                return false;
            }
            V prev = null;
            switch (RedisTransactionCommonUtil.getRedisClient()) {
                case REDISSON:
                    RBucket<V> bucket = redissonClient.getBucket(k);
                    if (RedisTransactionCommonUtil.getQueryPrev()) {
                        prev = bucket.get();
                    }
                    bucket.set(v);
                    bucket.expire(timeOut, timeUnit);
                    break;
                case REDIS_TEMPLATE:
                    if (RedisTransactionCommonUtil.getQueryPrev()) {
                        prev = (V) redisTemplate.opsForValue().get(k);
                    }
                    redisTemplate.opsForValue().set(k, v);
                    break;
                case STRING_REDIS_TEMPLATE:
                    if (RedisTransactionCommonUtil.getQueryPrev()) {
                        prev = (V) stringRedisTemplate.opsForValue().get(k);
                    }
                    stringRedisTemplate.opsForValue().set(k, (String) v);
                    break;
                default:
                    throw new RedisTrancactionException("unknown redis client");
            }
            this.setRedisTransaction(k, v, prev, RedisOperateTypeEnum.STRING_SET);
            return true;
        } catch (Exception e) {
            log.warn("redis setListExpire fail, key = {}, value = {}, e = {}", k, v, e);
            return false;
        }
    }

    /**
     * v
     *
     * @return true 成功 false 失败
     */
    public boolean stringSetTransaction(String k, V v) {
        try {
            if (v == null) {
                return false;
            }
            V prev = null;
            switch (RedisTransactionCommonUtil.getRedisClient()) {
                case REDISSON:
                    RBucket<V> bucket = redissonClient.getBucket(k);
                    if (RedisTransactionCommonUtil.getQueryPrev()) {
                        prev = bucket.get();
                    }
                    bucket.set(v);
                    break;
                case REDIS_TEMPLATE:
                    if (RedisTransactionCommonUtil.getQueryPrev()) {
                        prev = (V) redisTemplate.opsForValue().get(k);
                    }
                    redisTemplate.opsForValue().set(k, v);
                    break;
                case STRING_REDIS_TEMPLATE:
                    if (RedisTransactionCommonUtil.getQueryPrev()) {
                        prev = (V) stringRedisTemplate.opsForValue().get(k);
                    }
                    stringRedisTemplate.opsForValue().set(k, (String) v);
                    break;
                default:
                    throw new RedisTrancactionException("unknown redis client");
            }
            this.setRedisTransaction(k, v, prev, RedisOperateTypeEnum.STRING_SET);
            return true;
        } catch (Exception e) {
            log.warn("redis setValue fail, key = {}, value = {}, e = {}", k, v, e);
            return false;
        }
    }

    /**
     * v
     *
     * @return true 成功 false 失败
     */
    public boolean stringAdd(String k, V v) {
        try {
            if (v == null) {
                return false;
            }
            switch (RedisTransactionCommonUtil.getRedisClient()) {
                case REDISSON:
                    RBucket<V> bucket = redissonClient.getBucket(k);
                    bucket.set(v);
                    break;
                case REDIS_TEMPLATE:
                    redisTemplate.opsForValue().set(k, v);
                    break;
                case STRING_REDIS_TEMPLATE:
                    stringRedisTemplate.opsForValue().set(k, (String) v);
                    break;
                default:
                    throw new RedisTrancactionException("unknown redis client");
            }
            return true;
        } catch (Exception e) {
            log.warn("redis setValue fail, key = {}, value = {}, e = {}", k, v, e);
            return false;
        }
    }

    /**
     * v
     *
     * @return true 成功 false 失败
     */
    public boolean stringDeleteTransaction(String k, V v) {
        try {
            switch (RedisTransactionCommonUtil.getRedisClient()) {
                case REDISSON:
                    RBucket<V> bucket = redissonClient.getBucket(k);
                    if (bucket.isExists()) {
                        bucket.delete();
                    }
                    break;
                case REDIS_TEMPLATE:
                    redisTemplate.opsForValue().getAndDelete(k);
                    break;
                case STRING_REDIS_TEMPLATE:
                    stringRedisTemplate.opsForValue().getAndDelete(k);
                    break;
                default:
                    throw new RedisTrancactionException("unknown redis client");
            }
            this.setRedisTransaction(k, v, null, RedisOperateTypeEnum.STRING_DELETE);
            return true;
        } catch (Exception e) {
            log.warn("redis deleteValue fail, key = {}, value = {}, e = {}", k, e);
            return false;
        }
    }

    /**
     * v
     *
     * @return true 成功 false 失败
     */
    public boolean stringDelete(String k) {
        try {
            switch (RedisTransactionCommonUtil.getRedisClient()) {
                case REDISSON:
                    RBucket<V> bucket = redissonClient.getBucket(k);
                    if (bucket.isExists()) {
                        bucket.delete();
                    }
                    break;
                case REDIS_TEMPLATE:
                    redisTemplate.opsForValue().getAndDelete(k);
                    break;
                case STRING_REDIS_TEMPLATE:
                    stringRedisTemplate.opsForValue().getAndDelete(k);
                    break;
                default:
                    throw new RedisTrancactionException("unknown redis client");
            }
            return true;
        } catch (Exception e) {
            log.warn("redis deleteValue fail, key = {}, value = {}, e = {}", k, e);
            return false;
        }
    }

}

 三、使用

1、目前支持链接redis的工具主要是Redisson、RedisTemplate、StringRedisTemplate，默认Redisson

2、进行回滚时需要考虑是否要进行查询前镜像，可以通过设置RedisTransactionCommonUtil的QUERY_PREV属性

3、需要使用RedisTransactionCacheUtils操作需要回滚的redis数据，此时加入threadlocal
@Resource
private RedisTransactionCacheUtils redisTransactionCacheUtils;

@RedisTransaction(atuoRemove = true)
public void shopAdd(ShopOnlineDTO request) {
    //业务处理
    redisTransactionCacheUtils.stringSetTransaction(request.getShopId(),request.getPrice());
    //业务处理
    redisTransactionCacheUtils.stringSetTransaction(request.getShopId(),request.getLocation());
    //业务处理
}

设置redis客户端为RedisTemplate
RedisTransactionCommonUtil.setRedisClient(RedisClientTypeEnum.REDIS_TEMPLATE);

设置查询前镜像
RedisTransactionCommonUtil.setQueryPrev(true);

四、总结

        作者在线上使用过程中避免了不少数据不一致，感兴趣的小伙伴可以试试。

胖当当技术
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Springboot-Redis - 11.Redis 事务
yueerba126的博客
09-06 314
确实，Redis 的事务行为与传统的关系数据库事务有所不同。在关系数据库中，如果事务的一部分失败，整个事务通常会被回滚，保证数据的完整性。但在 Redis 中，情况并不完全如此。
回顾：数据库操作和redis缓存中的事务回滚问题
weixin_54401017的博客
03-22 1608
注：@Transactional只会回滚MySQL的异常，其后发生的Redis异常并不会让其回滚数据库。Redis也不会回滚（这个和Redis采用的设计策略有关：不对回滚支持，保证操作的简单快速）但是MySQL操作成功，而Redis异常，此时缓存数据不一致，如何回滚Mysql操作又是一个问题。2、Redis的事务并不支持回滚功能，Redis命令在事务处理期间发生错误，原先的操作并不会回滚。1、数据库开启事务，即可在操作失误时，回滚之前的已经做过的操作，保证操作原子性。
16.Redis之Redis事务
最新发布
m0_47017197的博客
05-30 1037
原子性: 把多个操作,打包成一个整体了一致性: 事务执行之前,和之后,数据都不能离谱~持久性: 事务中做出的修改都会存硬盘隔离性: 事务并发执行,涉及到的一些问题~~
Redis--事务回滚
吴声子夜歌的博客
11-15 5011
Redis事务回滚 对于 Redis 而言，不单单需要注意其事务处理的过程，其回滚的能力也和数据库不太一样，这也是需要特别注意的一个问题——Redis 事务遇到的命令格式正确而数据类型不符合，如图 1 所示。 从图 1 中可知，我们将 key1 设置为字符串，而使用命令 incr 对其自增，但是命令只会进入事务队列，而没有被执行，所以它不会有任何的错误发生，而是等待 exec 命令的执行。 当 ...
Redis详细总结笔记
⛄沉淀分享成长--长久的沉淀势必会收获到你想要的，那些旅途上的果实
03-11 2896
一、NoSQL NoSQL是Not only SQL的缩写，大意为“不只是SQL”，说明这项技术是传统关系型数据库的补充而非替代。在整个NoSQL技术栈中MemCache、Redis、MongoDB被称为NoSQL三剑客。那么时代为什么需要NoSQL数据库呢？我们来做个对比： 关系型数据库 NoSQL数据库 数据存储位置 硬盘 内存 数据结构 高度组织化结构化数据 没有预定义的模式 数据操作方式 SQL 所有数据都是键值对，没有声明性查询语言
springboot操作redis事务
csdn1234564的博客
02-28 345
springboot操作redis事务 在之前的springboot整合redis的项目基础上进行改造，service层改为： private void setString(String key, Object object) { String value = (String)object; // 开启redis事务 stringRedisTemplate.setEnableTransactionSupport(true); stringRed
redis工具类
shifch的博客
08-02 405
import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisKe...
基于RabbitMQ+Redis的分布式事务框架
05-10
当一个事务开始时，可以在Redis中设置一个锁，事务完成后释放锁，确保同一时间只有一个事务对资源进行操作。此外，Redis还可以作为临时存储，保存那些未确认的事务状态，直到事务完成。 AOP（面向切面编程）是一种...
RedisStudio redis可视化工具
05-22
1. **Redis 简介**：Redis 是一个开源的、基于内存的数据结构存储系统，支持数据类型包括字符串、哈希、列表、集合和有序集合。它可以用作数据库、缓存和消息中间件，具备高速读写性能和丰富的数据操作命令。 2. **...
cpp-Redis分布式事务
08-16
Redis是一款开源的、基于键值对的数据存储系统，常用于缓存、消息队列以及分布式场景中。在大型游戏中，由于数据分布广泛、玩家交互频繁，分布式事务的管理变得至关重要，以确保数据的一致性和完整性。 描述中提到...
RedisDesktopManager.rar
10-30
RedisDesktopManager是一款强大的开源Redis数据库管理工具，专为简化Redis数据操作而设计。它提供了直观的图形用户界面，使得在本地或远程服务器上管理和操作Redis数据库变得轻而易举。这款应用支持多种操作系统，...
redis-desktop-manager.zip
06-05
9. **事务处理**：支持Redis事务，允许用户在一个操作序列中执行多条命令，确保数据一致性。 10. **安全性**：支持SSL/TLS加密连接，保证数据在传输过程中的安全。 11. **自定义快捷键**：允许用户根据个人习惯...
Redis操作工具类
liwenyang1992的专栏
01-18 9351
核心Redis操作工具类RedisOperateUtil如下，主要包括Redis键（Key）、字符串（String）、哈希（Hash）、列表（List）、集合（Set）等常用的操作。
Redis编程--RedisTemplate与StringRedisTemplate
IT利刃出鞘的博客
08-25 1330
其他网址 SpringBoot 整合 Redis 使用详解（StringRedisTemplate 和 RedisTemplate 对比分析）_Abysscarry的博客-CSDN博客 简介 关系：StringRedisTemplate继承RedisTemplate。数据不共通：StringRedisTemplate只能管理StringRedisTemplate的数据，RedisTemplate只能管理RedisTemplate的数据。区别 RedisTemplate使用JdkSe...
一头坑进Redis之事务
googleoyyp的博客
08-21 3870
一.是什么 可以一次执行多个命令，本质是一组命令的集合。
redis队列回滚_【死磕 Redis】 事务
weixin_42117485的博客
01-29 428
这是 Java 技术驿站第102篇原创-------------Redis 通过 MULTI、 EXEC、 DISCARD、 WATCH 、 UNWATCH 来实现事务功能，Redis 事务具备如下几个特性Redis 会将事务中的多个命令一次性、按顺序一次执行，在执行期间可以保证不会中断事务去执行其他命令Redis 的事务机制是不能保证原子性的，它只保证隔离性和一致性。Redis 事...
Redis-10Redis的事务回滚
热门推荐
小工匠
09-27 1万+
文章目录概述场景一: 命令格正确,数据类型错误场景二：命令格式错误 概述 对于 Redis 而言，不单单需要注意其事务处理的过程，其回滚的能力也和数据库不太一样，这也是需要特别注意的一个问题一Redis 事务遇到的命令格式正确而数据类型不符合 ，如下所示。 场景一: 命令格正确,数据类型错误 127.0.0.1:6379&amp;gt; FLUSHDB OK 127.0.0.1:6379&amp;gt; MULT...
Redis 事务
iteye_2022的博客
10-28 301
Redis 提供的事务机制与传统的数据库事务有些不同，传统数据库事务必须维护以下特性：原子性(Atomicity), 一致性(Consistency), 隔离性(Isolation), 持久性(Durability)，简称ACID。 我们逐项考察下 Redis 在事务的 ACID 上做出的权衡与取舍： 原子性(Atomicity) 原子意味着操作的不可再分，要么执行要么不执行。...
Redis事务详解，Redis事务不支持回滚吗？
weixin_41282397的博客
02-18 5840
Redis事务提供2个重要保证 MULTI, EXEC, DISCARD 和WATCH命令是Redis事务操作的基础 。他们可以让Redis在一个步骤里执行一组命令，且能做到如下2个重要保证: 事务中的所有命令都是序列化且都是按顺序执行的。在一个客户端执行Redis事务的过程中，不会接收其他任何客户端对它发出的请求。这保证了这些命令是作为一个单独的独立操作执行的。所有的命令要么都被一起处理，要...
redis支持事务回滚吗？
05-09
是的，Redis支持事务回滚。Redis的事务是通过MULTI、EXEC、WATCH和DISCARD等命令实现的。当客户端使用MULTI命令开启一个事务后，所有执行的命令都会被暂存到一个队列中。当客户端使用EXEC命令执行这个事务时，Redis会执行所有暂存的命令。如果事务中的某个命令执行失败，则整个事务都会回滚，即之前执行的所有命令都会被撤销。如果客户端使用DISCARD命令放弃执行这个事务，则事务中所有的命令都会被清除。如果使用WATCH命令监控某个键，当这个键被其他客户端修改时，事务就会被中断，并且所有的命令都不会执行。总之，Redis的事务支持回滚，可以保证事务的原子性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

胖当当技术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值