精华内容
下载资源
问答
  • redis 自增和过期时间的使用

    今天碰到了一个业务场景:用户一小时内只允许输错十次登录密码,超过限制后不允许输入,直到下一自然小时才可以再次操作。
    这个可以用redis解决。
    说到底就是如何设置redis的key,以及对其进行增删改查操作的问题。
    前后想了两套方案,第一个方案被吐槽了,在这记录下。

    方案一

    key的定义:用户id+当前是第几个小时的小时数
    when add key: setNX 自增
    when delete key: 当客户输对密码时,根据用户id模糊删除掉该用户的key;
    且,每小时开个定时任务根据上一小时数模糊清除上个小时所有用户的错误次数。

    该方案被diss原因:
    模糊查询性能太差,简单的业务跑定时任务操作太重了

    故大佬建议改成key定时过期的方式实现。

    方案二

    setNX + expireTime

    刚开始担心更新key值会损失过期时间,后面测试过并没有问题
    方案优点:key自动过期、不用自行删除就很香啊

    展开全文
  • redis 自增步数When you have Redis up and running, you can start using it! Redis启动并运行后,就可以开始使用它了! The simplest way is to use redis-cli, an application installed when you install ...

    redis 自增步数

    When you have Redis up and running, you can start using it!

    Redis启动并运行后,就可以开始使用它了!

    The simplest way is to use redis-cli, an application installed when you install Redis.

    最简单的方法是使用redis-cli ,这是在安装Redis时安装的应用程序。

    It’s a built-in way to write commands to Redis without having to set up an application in order to do so.

    这是一种将命令写入Redis的内置方式,而无需为此设置应用程序。

    You can connect to a remote Redis server using redis-cli -h <host> -p <port> -a <password>

    您可以使用redis-cli -h <host> -p <port> -a <password>连接到远程Redis服务器。

    Once you’re in the Redis CLI app, you can start storing data into it.

    进入Redis CLI应用程序后,就可以开始将数据存储到其中了。

    Add a value using the structure SET <key> <value>:

    使用结构SET <key> <value>添加一个值:

    SET name "Flavio"

    检索值 (Retrieve a value)

    Retrieve a value using the structure GET <key>:

    使用结构GET <key>检索值:

    检查密钥是否存在 (Check if a key exists)

    We can also check if a key exists using EXISTS <key>:

    我们还可以使用EXISTS <key>检查密钥是否存在:

    The command returns either 1 (exists) or 0 (does not exist).

    该命令返回1(存在)或0(不存在)。

    设置是否不存在 (Set if not exists)

    A variation of SET allows us to only set a key if it does not exist yet:

    SET一种变体允许我们仅在尚不存在的情况下设置键:

    SETNX name "Roger"

    删除金钥 (Delete a key)

    Delete a key using DEL <key>:

    使用DEL <key>删除DEL <key>

    列出现有密钥 (Listing existing keys)

    You can list all keys inserted using KEYS *

    您可以列出使用KEYS *插入的所有键

    Or you can filter using a pattern like KEYS n* to only list keys starting with n, for example.

    或者,您可以使用类似KEYS n*的模式进行过滤,以仅列出以n开头的键。

    Each value stored can hold up to 512 MB in value.

    每个存储的值最多可容纳512 MB。

    密钥过期 (Expiring keys)

    A key can be temporarily stored, and removed automatically when the timer ends:

    可以将密钥临时存储,并在计时器结束时自动将其删除:

    SETEX <key> <seconds> <value>

    SETEX <key> <seconds> <value>

    You can get the time remaining for a key to be cleared using TTL <key>

    您可以使用TTL <key>清除密钥的剩余时间。

    In this example I set a name key with Flavio as value, and using TTL I can check how much time is left until the key will return the value. Once the timer expires, it results in a null value (nil):

    在此示例中,我设置了一个以Flavio作为值的name键,并使用TTL可以检查剩下多少时间直到该键返回该值。 计时器到期后,将产生一个空值( nil ):

    You can also set an existing key to expire using EXPIRE <key> seconds>.

    您还可以使用EXPIRE <key> seconds>将现有密钥设置为过期。

    递增和递减 (Increment and decrement)

    A numeric value can be incremented using INCR <key> and decremented using DECR <key>. You can also use INCRBY <key> <amount> and DECRBY <key> <amount> to increment a key value by a specific amount:

    数值可以使用INCR <key>递增,也可以使用DECR <key>递减。 您还可以使用INCRBY <key> <amount>DECRBY <key> <amount>将键值增加特定量:

    Those commands are very well suited for high concurrent operations where many clients might interact with the same data, to ensure atomic transactions.

    这些命令非常适合于高并发操作,在该操作中许多客户端可能与同一数据进行交互,以确保原子事务

    The most common example is when 2 different clients try to increment the same number.

    最常见的示例是两个不同的客户端尝试增加相同的数字时。

    On a database like PostgreSQL or MongoDB you first get the number value, you increment it, then you make a request to the server to increment it.

    在PostgreSQL或MongoDB之类的数据库上,您首先要获得数字值,然后对其进行递增,然后向服务器发出请求以使其递增。

    Say the value is 1. If two clients read the value using GET then they call SET to increment it independently, in the end if there is nothing preventing the concurrent change to happen, the result will be 2. Redis prevents this problem at the root.

    说值是1 。 如果两个客户端使用GET读取值,则它们调用SET进行独立递增,最后如果没有什么阻止并发更改发生,则结果将为2 。 Redis从根本上防止了此问题。

    更复杂的数据结构 (More complex data structures)

    So far we’ve worked with simple data types like integers and strings.

    到目前为止,我们已经使用了简单的数据类型,例如整数和字符串。

    Redis can support more complex structures.

    Redis可以支持更复杂的结构。

    Let’s see in the next lessons how to work with:

    让我们在下一课中了解如何使用:

    • Lists

      清单
    • Sets

      套装
    • Sorted sets

      排序集
    • Hashes

      散列

    翻译自: https://flaviocopes.com/redis-first-steps/

    redis 自增步数

    展开全文
  • redis自增id

    2020-09-27 15:49:00
    基本用法 private final RedisTemplate redisTemplate;...//先自增,再获取自增之后的值 Integer code = redisAtomicInteger.incrementAndGet(); //初始化一个值,不初始化默认0,第一次获取永远是1 r

    官网文档 https://docs.spring.io/spring-data/redis/docs/current/api/org/springframework/data/redis/support/atomic/package-summary.html

    基本用法

    private final RedisTemplate redisTemplate;
    ...
    RedisAtomicInteger redisAtomicInteger = new RedisAtomicInteger(key, redisTemplate.getConnectionFactory());
    //先自增,再获取自增之后的值
    Integer code = redisAtomicInteger.incrementAndGet();
    //初始化一个值,不初始化默认0,第一次获取永远是1
    redisAtomicInteger.set(value);
    

    类型也可以是 RedisAtomicDouble,RedisAtomicLong,默认0

    典型应用

    1,生成订单号

    RedisAtomicInteger redisAtomicInteger = new RedisAtomicInteger(key, redisTemplate.getConnectionFactory())
    //每日0点重置单号 
    redisAtomicInteger.set(0);
    //获取自增单号单号,业务标识 + 日期 + 自增数字
    String orderNo = PRE + yyyyMMdd + redisAtomicInteger.incrementAndGet();
    

    2,抢购库存

    RedisAtomicInteger redisAtomicInteger = new RedisAtomicInteger(key, redisTemplate.getConnectionFactory())
    //抢购开始前初始化总库存
    redisAtomicInteger.set(500);
    //活动开始每下一单原子性的-1
    int nowNum = redisAtomicInteger.decrementAndGet();
    if(nowNum<0){return "已经卖完了";}
    

    3,幂等接口控制

    比如用户抢答,或者是提交某些插入操作,只允许一次,需要避免重复操作

    private final IdempotentComponent idempotentComponent;
    ...
    //操作唯一标识
    String lockKey = 操作人+订单类型+店铺编码+日期;
    //11秒内只有第一次提交生效
    boolean check = idempotentComponent.createIdempotentTally(lockKey,11L, TimeUnit.SECONDS);
    if (!check) {
        return Result.failure(ResultCodeEnum.OPERATION_FAILED, "请勿重复执行!!");
    }
    
    import com.joybo.common.entity.IdempotentProperties;
    import org.apache.commons.lang3.StringUtils;
    import org.redisson.api.RAtomicLong;
    import org.redisson.api.RedissonClient;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * @Description 幂等接口/方法
     * 对于⼀个⽅法/接⼝/函数采⽤同⼀个数据请求执⾏任意次数(>=2)⽽对数据只产⽣0次或1次变更。
     * 则认为该接⼝/⽅法/函数具有幂等性
     * @Date 2020/9/21 18:15
     * @Author yule
     */
    @Component
    public class IdempotentComponent {
    
        //只是为了获取应用名,避免多个服务key撞车
        private final IdempotentProperties idempotentProperties;
        private final RedissonClient redissonClient;
    
        private final String IDEMPOTENT_KEY = "idempotent_key:";
    
        public IdempotentComponent(RedissonClient redissonClient, IdempotentProperties idempotentProperties) {
            this.redissonClient = redissonClient;
            this.idempotentProperties = idempotentProperties;
        }
    
        /**
         * redis实现幂等控制
         * @param idempotentKey 幂等键
         * @param idempotentTime 时间
         * @param timeUnit 单位
         * @return
         */
        public boolean createIdempotentTally(String idempotentKey, Long idempotentTime, TimeUnit timeUnit) {
            idempotentKey = StringUtils.join(idempotentProperties.getApplicationName(), IDEMPOTENT_KEY, idempotentKey);
            RAtomicLong atomicLong = redissonClient.getAtomicLong(idempotentKey);
            if (atomicLong.isExists()) {
                return false;
            }
            long idempotentCount = atomicLong.incrementAndGet();
            if (idempotentCount == 1) {
                // 保证过期时间只设置一次,不进行多次续期
                atomicLong.expire(idempotentTime, timeUnit);
                return true;
            }
            return false;
        }
    }
    
    展开全文
  • 分布式redis自增

    2021-04-16 07:06:37
    redis+springboot RedisUtil.java package com.meeno.chemical.common.redis; import java.util.Date; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUni....

    redis+springboot

    RedisUtil.java

    package com.meeno.chemical.common.redis;
    
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    import com.meeno.chemical.extend.account.service.DeviceTokenService;
    import com.meeno.chemical.socket.device.DeviceWebSocket;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.support.atomic.RedisAtomicLong;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    /**
     * @description: redis操作工具类
     * @author: Wzq
     * @create: 2020-05-28 20:19
     */
    @Component
    public class RedisUtil {
    
    
        private static RedisTemplate<String, Object> redisTemplate;
    
        @Autowired
        public void setUserMessageService(RedisTemplate<String, Object> redisTemplate){
            RedisUtil.redisTemplate = redisTemplate;
        }
    
        //=============================common============================
    
        /**
         * 指定缓存失效时间
         *
         * @param key  键
         * @param time 时间(秒)
         * @return
         */
        public static  boolean expire(String key, long time) {
            try {
                if (time > 0) {
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key 获取过期时间
         *
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public static long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /**
         * 判断key是否存在
         *
         * @param key 键
         * @return true 存在 false不存在
         */
        public static boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除缓存
         *
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public static void del(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                }
                else {
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
        /**
         *@Description 模糊查询redis keys的集合
         *@Param [keyStr]
         *@Return java.util.Set<java.lang.String>
         *@Author Wzq
         *@Date 2019/12/24
         *@Time 11:05
         */
        public static Set<String> findKeysByLikeKey(String keyStr){
            Set<String> keys = redisTemplate.keys(keyStr);
            return keys;
        }
    
        //============================String=============================
    
        /**
         * 普通缓存获取
         *
         * @param key 键
         * @return 值
         */
        public static Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true成功 false失败
         */
        public static boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
    
        /**
         * 普通缓存放入并设置时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public static boolean set(String key, Object value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                }
                else {
                    set(key, value);
                }
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 递增
         *
         * @param key 键
         * @param delta  要增加几(大于0)
         * @return
         */
        public static long incr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        /**
         * 递减
         *
         * @param key 键
         * @param delta  要减少几(小于0)
         * @return
         */
        public static long decr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        //================================Map=================================
    
        /**
         * HashGet
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public static Object hget(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         *
         * @param key 键
         * @return 对应的多个键值
         */
        public static Map<Object, Object> hmget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         *
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public static boolean hmset(String key, Map<String, Object> map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * HashSet 并设置时间
         *
         * @param key  键
         * @param map  对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public static boolean hmset(String key, Map<String, Object> map, long time) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false失败
         */
        public static boolean hset(String key, String item, Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public static boolean hset(String key, String item, Object value, long time) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除hash表中的值
         *
         * @param key  键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public static void hdel(String key, Object... item) {
            redisTemplate.opsForHash().delete(key, item);
        }
    
        /**
         * 判断hash表中是否有该项的值
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public static boolean hHasKey(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   要增加几(大于0)
         * @return
         */
        public static double hincr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /**
         * hash递减
         *
         * @param key  键
         * @param item 项
         * @param by   要减少记(小于0)
         * @return
         */
        public static double hdecr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
        //============================set=============================
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key 键
         * @return
         */
        public static Set<Object> sGet(String key) {
            try {
                return redisTemplate.opsForSet().members(key);
            }
            catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 根据value从一个set中查询,是否存在
         *
         * @param key   键
         * @param value 值
         * @return true 存在 false不存在
         */
        public static boolean sHasKey(String key, Object value) {
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将数据放入set缓存
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public static long sSet(String key, Object... values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            }
            catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 将set数据放入缓存
         *
         * @param key    键
         * @param time   时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public static long sSetAndTime(String key, long time, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0) expire(key, time);
                return count;
            }
            catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 获取set缓存的长度
         *
         * @param key 键
         * @return
         */
        public static long sGetSetSize(String key) {
            try {
                return redisTemplate.opsForSet().size(key);
            }
            catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 移除值为value的
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public static long setRemove(String key, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            }
            catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        //===============================list=================================
    
        /**
         * 获取list缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束  0 到 -1代表所有值
         * @return
         */
        public static List<Object> lGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            }
            catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 获取list缓存的长度
         *
         * @param key 键
         * @return
         */
        public static long lGetListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            }
            catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 通过索引 获取list中的值
         *
         * @param key   键
         * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @return
         */
        public static Object lGetIndex(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            }
            catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public static boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public static boolean lSet(String key, Object value, long time) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0) expire(key, time);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public static boolean lSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public static boolean lSet(String key, List<Object> value, long time) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0) expire(key, time);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据索引修改list中的某条数据
         *
         * @param key   键
         * @param index 索引
         * @param value 值
         * @return
         */
        public static boolean lUpdateIndex(String key, long index, Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            }
            catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 移除N个值为value
         *
         * @param key   键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        public static long lRemove(String key, long count, Object value) {
            try {
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            }
            catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * @param key
         * @return
         * @Title: generate
         * @Description: Atomically increments by one the current value.
         */
        public static long generate(String key) {
            RedisAtomicLong counter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
            return counter.incrementAndGet();
        }
    
        /**
         * @param key
         * @return
         * @Title: generate
         * @Description: Atomically increments by one the current value.
         */
        public static long generate(String key, Date expireTime) {
            RedisAtomicLong counter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
            counter.expireAt(expireTime);
            return counter.incrementAndGet();
        }
    
        /**
         * @param key
         * @param increment
         * @return
         * @Title: generate
         * @Description: Atomically adds the given value to the current value.
         */
        public static long generate(String key, int increment) {
            RedisAtomicLong counter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
            return counter.addAndGet(increment);
        }
    
        /**
         * @param key
         * @param increment
         * @param expireTime
         * @return
         * @Title: generate
         * @Description: Atomically adds the given value to the current value.
         */
        public static long generate(String key, int increment, Date expireTime) {
            RedisAtomicLong counter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
            counter.expireAt(expireTime);
            return counter.addAndGet(increment);
        }
    
    }

    使用

    RedisUtil.del("wzq");
    
    
            //物料编号
            long wzq = RedisUtil.generate("wzq",1);
            log.info("wzq:" + wzq);
    
            Thread thread1 = new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    long j = RedisUtil.generate("materialGenerate");
                    log.info(""+j);
                }
            });
    
            Thread thread2 = new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    long j = RedisUtil.generate("wzq");
                    log.info(""+j);
                }
            });
    
            Thread thread3 = new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    long j = RedisUtil.generate("wzq");
                    log.info(""+j);
                }
            });
    
            thread1.start();
            thread2.start();
            thread3.start();
    展开全文
  • redis-生成redis自增id

    2019-12-04 18:14:36
    sequenceUtil工具类 ...import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.support.atomic.RedisAtomicLong; import org.springframework.stereotype...
  • Redis自增计数

    万次阅读 2018-04-09 14:49:37
    INCR key将 key 中储存的数字值增一。如果 key 不存在,那么 key 的值会先被...这是一个针对字符串的操作,因为 Redis 没有专用的整数类型,所以 key 内储存的字符串被解释为十进制 64 位有符号整数来执行 ...
  • 思路:用RedisAtomicLong获取自增数,然而在redis服务关闭重启后,自增序列又会从之前的数据开始计算,导致自增数重复,这和我之前写的一篇文章:redis重启后 删除的key值又恢复了情况 非常像,其实是文件还没开始...
  • Redis自增序列

    千次阅读 2016-05-17 17:09:43
    小Z正在开发基于Redis缓存层的一个应用,以下代码是在Redis数据库中产生一个自增序列Key,每次返回新增1的数值,并且设置了70秒失效
  • Redis自增自减计数

    2020-12-05 18:06:16
    将 key 中存储的数字自增 1 。 如果 key 不存在,那么 key 的值会被初始化为 0 ,然后自增 1 。 DECR key 将 key 中存储的数字自减 1 。 如果 key 不存在,那么 key 的值会被初始化为 0,然后自减 1 。 INCRBY ...
  • * @param key redis key * @return 自增序列值 */ public Long getIncreaseSeq(String key) { Long currentValue = valueOperations.increment(key); if (currentValue == null) { synchronized (this) { ...
  • 每次请求都会重置过期时间为当前时间10秒后; 也就是说每次自增都会把过期时间重置;... public String redisTest() { Long test = redisTemplate.boundValueOps("test").increment(1); Long timeout =
  • 1. 背景 在分布式系统中,不可避免的...我们这里采取分布式中间件Redis自增函数,实现分布式单号的生成。 2. 业务要求 分布式的单号生成组件,需要根据不同的业务要求生成不同规则的业务单号,并且在高并发的场景...
  • Redis自增实现计数

    万次阅读 2015-09-09 14:42:44
    INCR key 将 key 中储存的数字值增一。 如果 key 不存在,那么 key 的值会先被初始化为 0 ,然后再执行 INCR ...这是一个针对字符串的操作,因为 Redis 没有专用的整数类型,所以 key 内储存的字符串被
  • 编辑Mycat的配置文件sequence_db_conf.properties 重启Mycat 二、Redis生成主键 redis服务器创建一个序列变量 springboot方式获取自增序列 依赖引入 <dependency> <groupId>org.springframework.boot</groupId> ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,171
精华内容 468
关键字:

redis自增

redis 订阅