AI 助理
备案控制台
开发者社区 数据库 文章 正文

Redis在数据库事务中的增改操作

2023-08-30 55
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： Redis在数据库事务中的增改操作

数据库事务中的redis增改模板

        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                   //redis增改操作
                }
            });
        } else {
          //redis增改操作
        }

完整的封装代码

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.support.atomic.RedisAtomicLong;
import org.springframework.stereotype.Component;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
 * redis操作工具
 *
 * @author
 */
@Component
@Slf4j
public class RedisUtils {
    @Resource(name = "RedisTemplatePropr")
    private RedisTemplate redisTemplate;
    /**
     * 获取SpringDataRedis访问模板，操作String类型数据
     *
     * @return
     */
    public RedisTemplate<String, String> getRedisTemplateOpsString() {
        return redisTemplate;
    }
    /**
     * 获取SpringDataRedis访问模板，操作任意Object对象类型数据
     *
     * @return
     */
    private RedisTemplate<String, Object> getRedisTemplateOpsObject() {
        return redisTemplate;
    }
    /**
     * 获取SpringDataRedis访问模板，操作Map<String, String>类型数据
     *
     * @return
     */
    private RedisTemplate<String, Map<String, String>> getRedisTemplateOpsMap() {
        return redisTemplate;
    }
    public Cursor scan(String pattern, int limit) {
        ScanOptions options = ScanOptions.scanOptions().match(pattern).count(limit).build();
        RedisSerializer<String> redisSerializer = (RedisSerializer<String>) getRedisTemplateOpsString().getKeySerializer();
        return (Cursor) getRedisTemplateOpsString().executeWithStickyConnection(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return new ConvertingCursor<>(redisConnection.scan(options), redisSerializer::deserialize);
            }
        });
    }
    /**
     * 本地调用，存储String类型数据到缓存服务器，不设置有效期，永久有效
     *
     * @param key
     * @param value
     * @return
     */
    public void setString(String key, String value) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsString().opsForValue().set(key, value);
                }
            });
        } else {
            getRedisTemplateOpsString().opsForValue().set(key, value);
        }
    }
    public boolean setString(String key, String value, long time) {
        try {
            if (TransactionSynchronizationManager.isActualTransactionActive()) {
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                    public void afterCommit() {
                        if (time > 0) {
                            getRedisTemplateOpsString().opsForValue().set(key, value, time, TimeUnit.SECONDS);
                        } else {
                            setString(key, value);
                        }
                    }
                });
            } else {
                if (time > 0) {
                    getRedisTemplateOpsString().opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
                    setString(key, value);
                }
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 本地调用，存储Hash类型数据到缓存服务器，设置有效期
     *
     * @param key
     * @param fieldMap
     * @param timeout
     * @param unit
     */
    public void setHashString(String key, Map<String, Object> fieldMap, long timeout, TimeUnit unit) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsObject().opsForHash().putAll(key, fieldMap);
                    getRedisTemplateOpsObject().expire(key, timeout, unit);
                }
            });
        } else {
            getRedisTemplateOpsObject().opsForHash().putAll(key, fieldMap);
            getRedisTemplateOpsObject().expire(key, timeout, unit);
        }
    }
    /**
     * 本地调用，存储Hash类型数据到缓存服务器，设置有效期
     *
     * @param key
     * @param fieldMap
     */
    public void setHashString(String key, Map<String, Object> fieldMap) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsObject().opsForHash().putAll(key, fieldMap);
                }
            });
        } else {
            getRedisTemplateOpsObject().opsForHash().putAll(key, fieldMap);
        }
    }
    /**
     * 删除存储Hash元素
     *
     * @param key
     * @param mapKey
     */
    public void deleteHashString(String key, String mapKey) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsObject().opsForHash().delete(key, mapKey);
                }
            });
        } else {
            getRedisTemplateOpsObject().opsForHash().delete(key, mapKey);
        }
    }
    /**
     * 本地调用，存储Hash类型部分数据到缓存服务器，设置有效期
     *
     * @param key
     * @param field
     * @param value
     */
    public void setHashPartString(String key, String field, Object value) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsObject().opsForHash().put(key, field, value);
                }
            });
        } else {
            getRedisTemplateOpsObject().opsForHash().put(key, field, value);
        }
    }
    /**
     * 本地调用，存储Hash类型部分数据到缓存服务器，设置有效期
     *
     * @param key
     * @param field
     * @param value
     * @param timeout
     * @param unit
     */
    public void setHashPartString(String key, String field, Object value, long timeout, TimeUnit unit) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsObject().opsForHash().put(key, field, value);
                    getRedisTemplateOpsObject().expire(key, timeout, unit);
                }
            });
        } else {
            getRedisTemplateOpsObject().opsForHash().put(key, field, value);
            getRedisTemplateOpsObject().expire(key, timeout, unit);
        }
    }
    /**
     * 本地调用，根据key查询Hash类型数据
     *
     * @param key
     */
    public Map<String, Object> getHashString(String key) {
        Map<Object, Object> keys = getRedisTemplateOpsObject().opsForHash().entries(key);
        Map<String, Object> resMap = new HashMap<>();
        for (Map.Entry<Object, Object> map : keys.entrySet()) {
            resMap.put((String) map.getKey(), map.getValue());
        }
        return resMap;
    }
    /**
     * 本地调用，存储Map<String, String>类型数据到缓存服务器，不设置有效期，永久有效
     *
     * @param key
     * @param value
     * @return
     */
    public void setMapOfString(String key, Map<String, String> value) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsMap().opsForValue().set(key, value);
                }
            });
        } else {
            getRedisTemplateOpsMap().opsForValue().set(key, value);
        }
    }
    /**
     * 本地调用，存储Map<String, String>类型数据到缓存服务器，设置有效期
     *
     * @param key
     * @param value
     * @param timeout
     * @param unit
     */
    public void setMapOfString(String key, Map<String, String> value, long timeout, TimeUnit unit) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsMap().opsForValue().set(key, value, timeout, unit);
                }
            });
        } else {
            getRedisTemplateOpsMap().opsForValue().set(key, value, timeout, unit);
        }
    }
    /**
     * 本地调用，存储任意对象类型数据到缓存服务器，不设置有效期，永久有效
     *
     * @param key
     * @param value
     * @return
     */
    public void setObject(String key, Object value) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsObject().opsForValue().set(key, value);
                }
            });
        } else {
            getRedisTemplateOpsObject().opsForValue().set(key, value);
        }
    }
    /**
     * 本地调用，存储任意对象类型数据到缓存服务器，设置有效期
     *
     * @param key
     * @param value
     * @param timeout
     * @param unit
     */
    public void setObject(String key, Object value, long timeout, TimeUnit unit) {
        getRedisTemplateOpsObject().opsForValue().set(key, value, timeout, unit);
    }
    /**
     * 本地调用，从缓存服务器获取String类型数据
     *
     * @param key
     * @return
     */
    public String getString(String key) {
        return getRedisTemplateOpsString().opsForValue().get(key);
    }
    /**
     * 本地调用，从缓存服务器获取Map<String, String>类型数据
     *
     * @param key
     * @return
     */
    public Map<String, String> getMapOfString(String key) {
        return getRedisTemplateOpsMap().opsForValue().get(key);
    }
    /**
     * set类型
     * 获取集合剩余元素个数
     *
     * @param key
     * @return size
     */
    public long getSetSize(String key) {
        return getRedisTemplateOpsObject().opsForSet().size(key);
    }
    /**
     * 本地调用，从缓存服务器获取任意Object对象类型数据
     *
     * @param key
     * @return
     */
    public Object getObject(String key) {
        return getRedisTemplateOpsObject().opsForValue().get(key);
    }
    /**
     * 本地调用，从缓存服务器删除数据
     *
     * @param key
     */
    public void delete(String key) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    getRedisTemplateOpsObject().opsForValue().getOperations().delete(key);
                }
            });
        } else {
            getRedisTemplateOpsObject().opsForValue().getOperations().delete(key);
        }
    }
    public void deleteKeys(String key) {
        Set<String> keys = getRedisTemplateOpsObject().opsForValue().getOperations().keys(key);
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    for (String s : keys) {
                        if (!s.contains("sync")) {
                            delete(s);
                        }
                    }
                }
            });
        } else {
            for (String s : keys) {
                if (!s.contains("sync")) {
                    delete(s);
                }
            }
        }
    }
    /**
     * 本地调用，从缓存服务器删除数据
     *
     * @param key
     */
    public void deleteHashKey(String key) {
        Set<Object> keys = getRedisTemplateOpsObject().opsForHash().keys(key);
        if (keys == null || keys.size() == 0) {
            return;
        }
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    for (Object hashKey : keys) {
                        getRedisTemplateOpsObject().opsForHash().delete(key, hashKey);
                    }
                }
            });
        } else {
            for (Object hashKey : keys) {
                getRedisTemplateOpsObject().opsForHash().delete(key, hashKey);
            }
        }
    }
    /**
     * 本地调用，校验数据是否在缓存服务器上已存在
     *
     * @param key
     * @return
     */
    public boolean exists(String key) {
        boolean exists = false;
        long size = getRedisTemplateOpsObject().opsForValue().size(key);
        if (size > 0) {
            exists = true;
        }
        return exists;
    }
    /**
     * 本地调用，校验数据是否在缓存服务器上已存在
     *
     * @param key
     * @return
     */
    public boolean existsKey(String key) {
        return getRedisTemplateOpsObject().hasKey(key);
    }
    /**
     * 本地调用，校验Hash数据是否在缓存服务器上已存在
     *
     * @param key
     * @return
     */
    public boolean existsHashKey(String key) {
        boolean exists = false;
        long size = getRedisTemplateOpsObject().opsForHash().size(key);
        if (size > 0) {
            exists = true;
        }
        return exists;
    }
    /**
     * 获取key的剩余有效时间
     *
     * @param key
     * @param timeUnit
     * @return
     */
    public Long getTTL(String key, TimeUnit timeUnit) {
        return getRedisTemplateOpsObject().getExpire(key, timeUnit);
    }
    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        final long[] result = new long[1];
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    result[0] = getRedisTemplateOpsObject().opsForValue().increment(key, delta);
                }
            });
        } else {
            result[0] = getRedisTemplateOpsObject().opsForValue().increment(key, delta);
        }
        return result[0];
    }
    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        final long[] result = new long[1];
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    result[0] = getRedisTemplateOpsObject().opsForValue().increment(key, delta);
                }
            });
        } else {
            result[0] = getRedisTemplateOpsObject().opsForValue().increment(key, delta);
        }
        return result[0];
    }
    /**
     * 设置key和value值并设置时间如果key已经存在则返回false，如果不存在则返回true
     *
     * @param key
     * @param value
     * @return
     */
    public boolean setIfAbsent(String key, String value, long timeout, TimeUnit unit) {
        final boolean[] result = new boolean[1];
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    result[0] =  getRedisTemplateOpsObject().opsForValue().setIfAbsent(key, value, timeout, unit);
                }
            });
        } else {
            result[0] =  getRedisTemplateOpsObject().opsForValue().setIfAbsent(key, value, timeout, unit);
        }
        return result[0];
    }
    public Boolean unlock(String key, String value) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        Long execute = (Long) redisTemplate.execute(redisScript, Collections.singletonList(key), value);
        // 解锁成功"unlock success"
        return execute != null && execute != 0;
    }
    /**
     * 设置key和value值并设置时间如果key已经存在则返回false，如果不存在则返回true
     *
     * @param key
     * @param value
     * @return
     */
    public boolean setIfAbsent(String key, String value) {
        final boolean[] result = new boolean[1];
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                public void afterCommit() {
                    result[0] =  getRedisTemplateOpsObject().opsForValue().setIfAbsent(key, value);
                }
            });
        } else {
            result[0] = getRedisTemplateOpsObject().opsForValue().setIfAbsent(key, value);
        }
        return result[0] ;
    }
}


文章标签：
云数据库 Tair（兼容 Redis）
NoSQL
Redis
数据库
关键词：
数据库事务
云数据库 Tair（兼容 Redis）事务
云数据库 Tair（兼容 Redis）操作
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
数据与后端架构提升之路
目录
相关文章
听白
|
28天前
|
缓存 NoSQL Redis
Redis 事务
10月更文挑战第18天
听白
25 1
八百标兵奔北坡
|
1月前
|
SQL 关系型数据库 MySQL
乐观锁在分布式数据库中如何与事务隔离级别结合使用
乐观锁在分布式数据库中如何与事务隔离级别结合使用
八百标兵奔北坡
43 2
程序员小海绵
|
2月前
|
canal 缓存 NoSQL
Redis缓存与数据库如何保证一致性？同步删除+延时双删+异步监听+多重保障方案
根据对一致性的要求程度，提出多种解决方案：同步删除、同步删除+可靠消息、延时双删、异步监听+可靠消息、多重保障方案
程序员小海绵
426 5
Redis缓存与数据库如何保证一致性？同步删除+延时双删+异步监听+多重保障方案
跃@sir
|
25天前
|
数据库
什么是数据库的事务隔离级别,有什么作用
【10月更文挑战第21】什么是数据库的事务隔离级别,有什么作用
跃@sir
13 3
跃@sir
|
25天前
|
存储 关系型数据库 数据挖掘
什么是数据库的事务隔离级别
【10月更文挑战第21】什么是数据库的事务隔离级别
跃@sir
18 1
代码bug生产队
|
1月前
|
存储 数据库 数据库管理
数据库事务安全性控制如何实现呢
【10月更文挑战第15天】数据库事务安全性控制如何实现呢
代码bug生产队
25 3
代码bug生产队
|
1月前
|
存储 数据库 数据库管理
什么是数据库事务安全性控制
【10月更文挑战第15天】什么是数据库事务安全性控制
代码bug生产队
25 3
代码bug生产队
|
1月前
|
供应链 数据库
数据库事务安全性控制有什么应用场景吗
【10月更文挑战第15天】数据库事务安全性控制有什么应用场景吗
代码bug生产队
35 2
跃@sir
|
1月前
|
存储 关系型数据库 MySQL
数据库的事务控制
【10月更文挑战第15天】数据库的事务控制
跃@sir
23 2
跃@sir
|
1月前
|
SQL 关系型数据库 数据库
如何在数据库中实现事务控制呢
【10月更文挑战第15天】如何在数据库中实现事务控制呢
跃@sir
16 1

热门文章

最新文章

  • 1
    Redis 从入门到精通之内存和CPU配置优化
  • 2
    redis 配置文件翻译
  • 3
    Redis入门实战（四）Redis 配置文件redis.conf详解
  • 4
    fpm 打包redis3.0.7
  • 5
    php-redis扩展模块安装记录
  • 6
    【Docker系列】docker-compose安装redis
  • 7
    Oracle查询结果集无法被redis缓存序列化问题
  • 8
    第九章：Redis replication 主从复制
  • 9
    使用 Redis 实现一个轻量级的搜索引擎，牛逼！
  • 10
    【Redis】redis安装与客户端redis-cli的使用(批量操作)
  • 1
    关系型数据库Oracle并行查询的实现方式
    305
  • 2
    关系型数据库Oracle并行查询的应用场景
    78
  • 3
    关系型数据库Oracle并行查询的基本概念
    106
  • 4
    现代数据库系统的性能优化策略与实践
    85
  • 5
    关系型数据库Oracle并行执行
    91
  • 6
    关系型数据库Oracle并行度（Degree of Parallelism, DOP）
    179
  • 7
    关系型数据库Oracle并行查询
    111
  • 8
    高并发场景下，到底先更新缓存还是先更新数据库？
    67
  • 9
    【最佳实践】MySQL数据库迁移到PXC集群
    98
  • 10
    关系型数据库Oracle GoldenGate
    39

    • 相关课程

    更多
  • 数据库的前世今生
  • 数据库核心概念
  • 从传统数据库到云数据库演进
  • 数据库常见问题排查
  • 数据库及SQL/MySQL基础
  • 高校精品课-西安交通大学 -数据库理论与技术

    • 相关电子书

    更多
  • DTCC 2022大会集锦《云原生一站式数据库技术与实践》
  • 阿里云瑶池数据库精要2022版
  • 2022 DTCC-阿里云一站式数据库上云最佳实践

    • 相关实验场景

    更多
  • 数据库实验室挑战任务-高级任务
  • 数据库实验室挑战任务-中级任务
  • 数据库实验室挑战任务-初级任务
  • 阿里云数据库产品实验室
  • MongoDB数据库入门
  • 使用DAS实现数据库自动扩容和回缩
    • 下一篇
    阿里云OSS设置跨域访问