¶Ô±ÈÐÂÎļþ |
| | |
| | | /* |
| | | * Copyright (c) 2018-2028, DreamLu All rights reserved. |
| | | * |
| | | * Redistribution and use in source and binary forms, with or without |
| | | * modification, are permitted provided that the following conditions are met: |
| | | * |
| | | * Redistributions of source code must retain the above copyright notice, |
| | | * this list of conditions and the following disclaimer. |
| | | * Redistributions in binary form must reproduce the above copyright |
| | | * notice, this list of conditions and the following disclaimer in the |
| | | * documentation and/or other materials provided with the distribution. |
| | | * Neither the name of the dreamlu.net developer nor the names of its |
| | | * contributors may be used to endorse or promote products derived from |
| | | * this software without specific prior written permission. |
| | | * Author: DreamLu 墿¥æ¢¦ (596392912@qq.com) |
| | | */ |
| | | |
| | | package org.springblade.core.redis.cache; |
| | | |
| | | import lombok.Getter; |
| | | import org.springblade.core.tool.utils.CollectionUtil; |
| | | import org.springframework.data.redis.core.*; |
| | | import org.springframework.lang.Nullable; |
| | | import org.springframework.util.Assert; |
| | | |
| | | import java.time.Duration; |
| | | import java.util.*; |
| | | import java.util.concurrent.TimeUnit; |
| | | import java.util.function.Supplier; |
| | | |
| | | /** |
| | | * redis å·¥å
· |
| | | * |
| | | * @author L.cm |
| | | */ |
| | | @Getter |
| | | @SuppressWarnings("unchecked") |
| | | public class BladeRedis { |
| | | private final RedisTemplate<String, Object> redisTemplate; |
| | | private final StringRedisTemplate stringRedisTemplate; |
| | | private final ValueOperations<String, Object> valueOps; |
| | | private final HashOperations<String, Object, Object> hashOps; |
| | | private final ListOperations<String, Object> listOps; |
| | | private final SetOperations<String, Object> setOps; |
| | | private final ZSetOperations<String, Object> zSetOps; |
| | | |
| | | public BladeRedis(RedisTemplate<String, Object> redisTemplate, StringRedisTemplate stringRedisTemplate) { |
| | | this.redisTemplate = redisTemplate; |
| | | this.stringRedisTemplate = stringRedisTemplate; |
| | | Assert.notNull(redisTemplate, "redisTemplate is null"); |
| | | valueOps = redisTemplate.opsForValue(); |
| | | hashOps = redisTemplate.opsForHash(); |
| | | listOps = redisTemplate.opsForList(); |
| | | setOps = redisTemplate.opsForSet(); |
| | | zSetOps = redisTemplate.opsForZSet(); |
| | | } |
| | | |
| | | /** |
| | | * 设置ç¼å |
| | | * |
| | | * @param cacheKey ç¼åkey |
| | | * @param value ç¼åvalue |
| | | */ |
| | | public void set(CacheKey cacheKey, Object value) { |
| | | String key = cacheKey.getKey(); |
| | | Duration expire = cacheKey.getExpire(); |
| | | if (expire == null) { |
| | | set(key, value); |
| | | } else { |
| | | setEx(key, value, expire); |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * åæ¾ key value å¯¹å° redisã |
| | | */ |
| | | public void set(String key, Object value) { |
| | | valueOps.set(key, value); |
| | | } |
| | | |
| | | /** |
| | | * åæ¾ key value å¯¹å° redisï¼å¹¶å° key ççåæ¶é´è®¾ä¸º seconds (以ç§ä¸ºåä½)ã |
| | | * 妿 key å·²ç»åå¨ï¼ SETEX å½ä»¤å°è¦åæ§å¼ã |
| | | */ |
| | | public void setEx(String key, Object value, Duration timeout) { |
| | | valueOps.set(key, value, timeout); |
| | | } |
| | | |
| | | /** |
| | | * åæ¾ key value å¯¹å° redisï¼å¹¶å° key ççåæ¶é´è®¾ä¸º seconds (以ç§ä¸ºåä½)ã |
| | | * 妿 key å·²ç»åå¨ï¼ SETEX å½ä»¤å°è¦åæ§å¼ã |
| | | */ |
| | | public void setEx(String key, Object value, Long seconds) { |
| | | valueOps.set(key, value, seconds, TimeUnit.SECONDS); |
| | | } |
| | | |
| | | /** |
| | | * è¿å key æå
³èç value å¼ |
| | | * 妿 key ä¸åå¨é£ä¹è¿åç¹æ®å¼ nil ã |
| | | */ |
| | | @Nullable |
| | | public <T> T get(String key) { |
| | | return (T) valueOps.get(key); |
| | | } |
| | | |
| | | /** |
| | | * è·åcache 为 null æ¶ä½¿ç¨å è½½å¨ï¼ç¶å设置ç¼å |
| | | * |
| | | * @param key cacheKey |
| | | * @param loader cache loader |
| | | * @param <T> æ³å |
| | | * @return ç»æ |
| | | */ |
| | | @Nullable |
| | | public <T> T get(String key, Supplier<T> loader) { |
| | | T value = this.get(key); |
| | | if (value != null) { |
| | | return value; |
| | | } |
| | | value = loader.get(); |
| | | if (value == null) { |
| | | return null; |
| | | } |
| | | this.set(key, value); |
| | | return value; |
| | | } |
| | | |
| | | /** |
| | | * è¿å key æå
³èç value å¼ |
| | | * 妿 key ä¸åå¨é£ä¹è¿åç¹æ®å¼ nil ã |
| | | */ |
| | | @Nullable |
| | | public <T> T get(CacheKey cacheKey) { |
| | | return (T) valueOps.get(cacheKey.getKey()); |
| | | } |
| | | |
| | | /** |
| | | * è·åcache 为 null æ¶ä½¿ç¨å è½½å¨ï¼ç¶å设置ç¼å |
| | | * |
| | | * @param cacheKey cacheKey |
| | | * @param loader cache loader |
| | | * @param <T> æ³å |
| | | * @return ç»æ |
| | | */ |
| | | @Nullable |
| | | public <T> T get(CacheKey cacheKey, Supplier<T> loader) { |
| | | String key = cacheKey.getKey(); |
| | | T value = this.get(key); |
| | | if (value != null) { |
| | | return value; |
| | | } |
| | | value = loader.get(); |
| | | if (value == null) { |
| | | return null; |
| | | } |
| | | this.set(cacheKey, value); |
| | | return value; |
| | | } |
| | | |
| | | /** |
| | | * å é¤ç»å®çä¸ä¸ª key |
| | | * ä¸åå¨ç key ä¼è¢«å¿½ç¥ã |
| | | */ |
| | | public Boolean del(String key) { |
| | | return redisTemplate.delete(key); |
| | | } |
| | | |
| | | /** |
| | | * å é¤ç»å®çä¸ä¸ª key |
| | | * ä¸åå¨ç key ä¼è¢«å¿½ç¥ã |
| | | */ |
| | | public Boolean del(CacheKey key) { |
| | | return redisTemplate.delete(key.getKey()); |
| | | } |
| | | |
| | | /** |
| | | * å é¤ç»å®çå¤ä¸ª key |
| | | * ä¸åå¨ç key ä¼è¢«å¿½ç¥ã |
| | | */ |
| | | public Long del(String... keys) { |
| | | return del(Arrays.asList(keys)); |
| | | } |
| | | |
| | | /** |
| | | * å é¤ç»å®çå¤ä¸ª key |
| | | * ä¸åå¨ç key ä¼è¢«å¿½ç¥ã |
| | | */ |
| | | public Long del(Collection<String> keys) { |
| | | return redisTemplate.delete(keys); |
| | | } |
| | | |
| | | /** |
| | | * æ¥æ¾ææç¬¦åç»å®æ¨¡å¼ pattern ç key ã |
| | | * KEYS * å¹é
æ°æ®åºä¸ææ key ã |
| | | * KEYS h?llo å¹é
hello ï¼ hallo å hxllo çã |
| | | * KEYS h*llo å¹é
hllo å heeeeello çã |
| | | * KEYS h[ae]llo å¹é
hello å hallo ï¼ä½ä¸å¹é
hillo ã |
| | | * ç¹æ®ç¬¦å·ç¨ \ éå¼ |
| | | */ |
| | | public Set<String> keys(String pattern) { |
| | | return redisTemplate.keys(pattern); |
| | | } |
| | | |
| | | /** |
| | | * åæ¶è®¾ç½®ä¸ä¸ªæå¤ä¸ª key-value 对ã |
| | | * 妿æä¸ªç»å® key å·²ç»åå¨ï¼é£ä¹ MSET ä¼ç¨æ°å¼è¦çåæ¥çæ§å¼ï¼å¦æè¿ä¸æ¯ä½ æå¸æçææï¼è¯·èèä½¿ç¨ MSETNX å½ä»¤ï¼å®åªä¼å¨ææç»å® key é½ä¸åå¨çæ
åµä¸è¿è¡è®¾ç½®æä½ã |
| | | * MSET æ¯ä¸ä¸ªååæ§(atomic)æä½ï¼ææç»å® key é½ä¼å¨å䏿¶é´å
è¢«è®¾ç½®ï¼æäºç»å® key è¢«æ´æ°èå¦ä¸äºç»å® key æ²¡ææ¹åçæ
åµï¼ä¸å¯è½åçã |
| | | * <pre> |
| | | * ä¾åï¼ |
| | | * Cache cache = RedisKit.use(); // ä½¿ç¨ Redis ç cache |
| | | * cache.mset("k1", "v1", "k2", "v2"); // æ¾å
¥å¤ä¸ª key value é®å¼å¯¹ |
| | | * List list = cache.mget("k1", "k2"); // å©ç¨å¤ä¸ªé®å¼å¾å°ä¸é¢ä»£ç æ¾å
¥çå¼ |
| | | * </pre> |
| | | */ |
| | | public void mSet(Object... keysValues) { |
| | | valueOps.multiSet(CollectionUtil.toMap(keysValues)); |
| | | } |
| | | |
| | | /** |
| | | * è¿åææ(ä¸ä¸ªæå¤ä¸ª)ç»å® key çå¼ã |
| | | * 妿ç»å®ç key éé¢ï¼ææä¸ª key ä¸åå¨ï¼é£ä¹è¿ä¸ª key è¿åç¹æ®å¼ nil ãå æ¤ï¼è¯¥å½ä»¤æ°¸ä¸å¤±è´¥ã |
| | | */ |
| | | public List<Object> mGet(String... keys) { |
| | | return mGet(Arrays.asList(keys)); |
| | | } |
| | | |
| | | /** |
| | | * è¿åææ(ä¸ä¸ªæå¤ä¸ª)ç»å® key çå¼ã |
| | | * 妿ç»å®ç key éé¢ï¼ææä¸ª key ä¸åå¨ï¼é£ä¹è¿ä¸ª key è¿åç¹æ®å¼ nil ãå æ¤ï¼è¯¥å½ä»¤æ°¸ä¸å¤±è´¥ã |
| | | */ |
| | | public List<Object> mGet(Collection<String> keys) { |
| | | return valueOps.multiGet(keys); |
| | | } |
| | | |
| | | /** |
| | | * å° key ä¸å¨åçæ°åå¼åä¸ã |
| | | * 妿 key ä¸åå¨ï¼é£ä¹ key çå¼ä¼å
被åå§å为 0 ï¼ç¶ååæ§è¡ DECR æä½ã |
| | | * 妿å¼å
å«é误çç±»åï¼æå符串类åçå¼ä¸è½è¡¨ç¤ºä¸ºæ°åï¼é£ä¹è¿åä¸ä¸ªé误ã |
| | | * æ¬æä½çå¼éå¶å¨ 64 ä½(bit)æç¬¦å·æ°å表示ä¹å
ã |
| | | * å
³äºéå¢(increment) / éå(decrement)æä½çæ´å¤ä¿¡æ¯ï¼è¯·åè§ INCR å½ä»¤ã |
| | | */ |
| | | public Long decr(String key) { |
| | | return stringRedisTemplate.opsForValue().decrement(key); |
| | | } |
| | | |
| | | /** |
| | | * å° key æå¨åçå¼åå»åé decrement ã |
| | | * 妿 key ä¸åå¨ï¼é£ä¹ key çå¼ä¼å
被åå§å为 0 ï¼ç¶ååæ§è¡ DECRBY æä½ã |
| | | * 妿å¼å
å«é误çç±»åï¼æå符串类åçå¼ä¸è½è¡¨ç¤ºä¸ºæ°åï¼é£ä¹è¿åä¸ä¸ªé误ã |
| | | * æ¬æä½çå¼éå¶å¨ 64 ä½(bit)æç¬¦å·æ°å表示ä¹å
ã |
| | | * å
³äºæ´å¤éå¢(increment) / éå(decrement)æä½çæ´å¤ä¿¡æ¯ï¼è¯·åè§ INCR å½ä»¤ã |
| | | */ |
| | | public Long decrBy(String key, long longValue) { |
| | | return stringRedisTemplate.opsForValue().decrement(key, longValue); |
| | | } |
| | | |
| | | /** |
| | | * å° key ä¸å¨åçæ°åå¼å¢ä¸ã |
| | | * 妿 key ä¸åå¨ï¼é£ä¹ key çå¼ä¼å
被åå§å为 0 ï¼ç¶ååæ§è¡ INCR æä½ã |
| | | * 妿å¼å
å«é误çç±»åï¼æå符串类åçå¼ä¸è½è¡¨ç¤ºä¸ºæ°åï¼é£ä¹è¿åä¸ä¸ªé误ã |
| | | * æ¬æä½çå¼éå¶å¨ 64 ä½(bit)æç¬¦å·æ°å表示ä¹å
ã |
| | | */ |
| | | public Long incr(String key) { |
| | | return stringRedisTemplate.opsForValue().increment(key); |
| | | } |
| | | |
| | | /** |
| | | * å° key æå¨åçå¼å ä¸å¢é increment ã |
| | | * 妿 key ä¸åå¨ï¼é£ä¹ key çå¼ä¼å
被åå§å为 0 ï¼ç¶ååæ§è¡ INCRBY å½ä»¤ã |
| | | * 妿å¼å
å«é误çç±»åï¼æå符串类åçå¼ä¸è½è¡¨ç¤ºä¸ºæ°åï¼é£ä¹è¿åä¸ä¸ªé误ã |
| | | * æ¬æä½çå¼éå¶å¨ 64 ä½(bit)æç¬¦å·æ°å表示ä¹å
ã |
| | | * å
³äºéå¢(increment) / éå(decrement)æä½çæ´å¤ä¿¡æ¯ï¼åè§ INCR å½ä»¤ã |
| | | */ |
| | | public Long incrBy(String key, long longValue) { |
| | | return stringRedisTemplate.opsForValue().increment(key, longValue); |
| | | } |
| | | |
| | | /** |
| | | * è·åè®°æ°å¨çå¼ |
| | | */ |
| | | public Long getCounter(String key) { |
| | | return Long.valueOf(String.valueOf(valueOps.get(key))); |
| | | } |
| | | |
| | | /** |
| | | * æ£æ¥ç»å® key æ¯å¦åå¨ã |
| | | */ |
| | | public Boolean exists(String key) { |
| | | return redisTemplate.hasKey(key); |
| | | } |
| | | |
| | | /** |
| | | * ä»å½åæ°æ®åºä¸éæºè¿å(ä¸å é¤)ä¸ä¸ª key ã |
| | | */ |
| | | public String randomKey() { |
| | | return redisTemplate.randomKey(); |
| | | } |
| | | |
| | | /** |
| | | * å° key æ¹å为 newkey ã |
| | | * å½ key å newkey ç¸åï¼æè
key ä¸å卿¶ï¼è¿åä¸ä¸ªé误ã |
| | | * å½ newkey å·²ç»å卿¶ï¼ RENAME å½ä»¤å°è¦çæ§å¼ã |
| | | */ |
| | | public void rename(String oldkey, String newkey) { |
| | | redisTemplate.rename(oldkey, newkey); |
| | | } |
| | | |
| | | /** |
| | | * å°å½åæ°æ®åºç key ç§»å¨å°ç»å®çæ°æ®åº db å½ä¸ã |
| | | * 妿å½åæ°æ®åº(æºæ°æ®åº)åç»å®æ°æ®åº(ç®æ æ°æ®åº)æç¸åååçç»å® key ï¼æè
key ä¸åå¨äºå½åæ°æ®åºï¼é£ä¹ MOVE 没æä»»ä½ææã |
| | | * å æ¤ï¼ä¹å¯ä»¥å©ç¨è¿ä¸ç¹æ§ï¼å° MOVE å½ä½é(locking)åè¯(primitive)ã |
| | | */ |
| | | public Boolean move(String key, int dbIndex) { |
| | | return redisTemplate.move(key, dbIndex); |
| | | } |
| | | |
| | | /** |
| | | * 为ç»å® key 设置çåæ¶é´ï¼å½ key è¿ææ¶(çåæ¶é´ä¸º 0 )ï¼å®ä¼è¢«èªå¨å é¤ã |
| | | * å¨ Redis ä¸ï¼å¸¦æçåæ¶é´ç key 被称为ãæå¤±çã(volatile)ã |
| | | */ |
| | | public Boolean expire(String key, long seconds) { |
| | | return redisTemplate.expire(key, seconds, TimeUnit.SECONDS); |
| | | } |
| | | |
| | | /** |
| | | * 为ç»å® key 设置çåæ¶é´ï¼å½ key è¿ææ¶(çåæ¶é´ä¸º 0 )ï¼å®ä¼è¢«èªå¨å é¤ã |
| | | * å¨ Redis ä¸ï¼å¸¦æçåæ¶é´ç key 被称为ãæå¤±çã(volatile)ã |
| | | */ |
| | | public Boolean expire(String key, Duration timeout) { |
| | | return expire(key, timeout.getSeconds()); |
| | | } |
| | | |
| | | /** |
| | | * EXPIREAT çä½ç¨å EXPIRE 类似ï¼é½ç¨äºä¸º key 设置çåæ¶é´ãä¸åå¨äº EXPIREAT å½ä»¤æ¥åçæ¶é´åæ°æ¯ UNIX æ¶é´æ³(unix timestamp)ã |
| | | */ |
| | | public Boolean expireAt(String key, Date date) { |
| | | return redisTemplate.expireAt(key, date); |
| | | } |
| | | |
| | | /** |
| | | * EXPIREAT çä½ç¨å EXPIRE 类似ï¼é½ç¨äºä¸º key 设置çåæ¶é´ãä¸åå¨äº EXPIREAT å½ä»¤æ¥åçæ¶é´åæ°æ¯ UNIX æ¶é´æ³(unix timestamp)ã |
| | | */ |
| | | public Boolean expireAt(String key, long unixTime) { |
| | | return expireAt(key, new Date(unixTime)); |
| | | } |
| | | |
| | | /** |
| | | * è¿ä¸ªå½ä»¤å EXPIRE å½ä»¤çä½ç¨ç±»ä¼¼ï¼ä½æ¯å®ä»¥æ¯«ç§ä¸ºåä½è®¾ç½® key ççåæ¶é´ï¼èä¸å EXPIRE å½ä»¤é£æ ·ï¼ä»¥ç§ä¸ºåä½ã |
| | | */ |
| | | public Boolean pexpire(String key, long milliseconds) { |
| | | return redisTemplate.expire(key, milliseconds, TimeUnit.MILLISECONDS); |
| | | } |
| | | |
| | | /** |
| | | * å°ç»å® key çå¼è®¾ä¸º value ï¼å¹¶è¿å key çæ§å¼(old value)ã |
| | | * å½ key åå¨ä½ä¸æ¯åç¬¦ä¸²ç±»åæ¶ï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public <T> T getSet(String key, Object value) { |
| | | return (T) valueOps.getAndSet(key, value); |
| | | } |
| | | |
| | | /** |
| | | * ç§»é¤ç»å® key ççåæ¶é´ï¼å°è¿ä¸ª key ä»ãæå¤±çã(带çåæ¶é´ key )è½¬æ¢æãæä¹
çã(ä¸ä¸ªä¸å¸¦çåæ¶é´ãæ°¸ä¸è¿æç key )ã |
| | | */ |
| | | public Boolean persist(String key) { |
| | | return redisTemplate.persist(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿å key æå¨åçå¼çç±»åã |
| | | */ |
| | | public String type(String key) { |
| | | return redisTemplate.type(key).code(); |
| | | } |
| | | |
| | | /** |
| | | * 以ç§ä¸ºåä½ï¼è¿åç»å® key çå©ä½çåæ¶é´(TTL, time to live)ã |
| | | */ |
| | | public Long ttl(String key) { |
| | | return redisTemplate.getExpire(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿ä¸ªå½ä»¤ç±»ä¼¼äº TTL å½ä»¤ï¼ä½å®ä»¥æ¯«ç§ä¸ºåä½è¿å key çå©ä½çåæ¶é´ï¼è䏿¯å TTL å½ä»¤é£æ ·ï¼ä»¥ç§ä¸ºåä½ã |
| | | */ |
| | | public Long pttl(String key) { |
| | | return redisTemplate.getExpire(key, TimeUnit.MILLISECONDS); |
| | | } |
| | | |
| | | /** |
| | | * å°åå¸è¡¨ key ä¸çå field çå¼è®¾ä¸º value ã |
| | | * 妿 key ä¸åå¨ï¼ä¸ä¸ªæ°çåå¸è¡¨è¢«å建并è¿è¡ HSET æä½ã |
| | | * 妿å field å·²ç»åå¨äºåå¸è¡¨ä¸ï¼æ§å¼å°è¢«è¦çã |
| | | */ |
| | | public void hSet(String key, Object field, Object value) { |
| | | hashOps.put(key, field, value); |
| | | } |
| | | |
| | | /** |
| | | * åæ¶å°å¤ä¸ª field-value (å-å¼)对设置å°åå¸è¡¨ key ä¸ã |
| | | * æ¤å½ä»¤ä¼è¦çåå¸è¡¨ä¸å·²åå¨çåã |
| | | * 妿 key ä¸åå¨ï¼ä¸ä¸ªç©ºåå¸è¡¨è¢«å建并æ§è¡ HMSET æä½ã |
| | | */ |
| | | public void hMset(String key, Map<Object, Object> hash) { |
| | | hashOps.putAll(key, hash); |
| | | } |
| | | |
| | | /** |
| | | * è¿ååå¸è¡¨ key ä¸ç»å®å field çå¼ã |
| | | */ |
| | | public <T> T hGet(String key, Object field) { |
| | | return (T) hashOps.get(key, field); |
| | | } |
| | | |
| | | /** |
| | | * è¿ååå¸è¡¨ key ä¸ï¼ä¸ä¸ªæå¤ä¸ªç»å®åçå¼ã |
| | | * 妿ç»å®çåä¸åå¨äºåå¸è¡¨ï¼é£ä¹è¿åä¸ä¸ª nil å¼ã |
| | | * å 为ä¸åå¨ç key 被å½ä½ä¸ä¸ªç©ºåå¸è¡¨æ¥å¤çï¼æä»¥å¯¹ä¸ä¸ªä¸åå¨ç key è¿è¡ HMGET æä½å°è¿åä¸ä¸ªåªå¸¦æ nil å¼ç表ã |
| | | */ |
| | | public List hmGet(String key, Object... fields) { |
| | | return hmGet(key, Arrays.asList(fields)); |
| | | } |
| | | |
| | | /** |
| | | * è¿ååå¸è¡¨ key ä¸ï¼ä¸ä¸ªæå¤ä¸ªç»å®åçå¼ã |
| | | * 妿ç»å®çåä¸åå¨äºåå¸è¡¨ï¼é£ä¹è¿åä¸ä¸ª nil å¼ã |
| | | * å 为ä¸åå¨ç key 被å½ä½ä¸ä¸ªç©ºåå¸è¡¨æ¥å¤çï¼æä»¥å¯¹ä¸ä¸ªä¸åå¨ç key è¿è¡ HMGET æä½å°è¿åä¸ä¸ªåªå¸¦æ nil å¼ç表ã |
| | | */ |
| | | public List hmGet(String key, Collection<Object> hashKeys) { |
| | | return hashOps.multiGet(key, hashKeys); |
| | | } |
| | | |
| | | /** |
| | | * å é¤åå¸è¡¨ key ä¸çä¸ä¸ªæå¤ä¸ªæå®åï¼ä¸åå¨çåå°è¢«å¿½ç¥ã |
| | | */ |
| | | public Long hDel(String key, Object... fields) { |
| | | return hashOps.delete(key, fields); |
| | | } |
| | | |
| | | /** |
| | | * æ¥çåå¸è¡¨ key ä¸ï¼ç»å®å field æ¯å¦åå¨ã |
| | | */ |
| | | public Boolean hExists(String key, Object field) { |
| | | return hashOps.hasKey(key, field); |
| | | } |
| | | |
| | | /** |
| | | * è¿ååå¸è¡¨ key ä¸ï¼ææçååå¼ã |
| | | * å¨è¿åå¼éï¼ç´§è·æ¯ä¸ªåå(field name)ä¹åæ¯åçå¼(value)ï¼æä»¥è¿åå¼çé¿åº¦æ¯åå¸è¡¨å¤§å°ç两åã |
| | | */ |
| | | public Map hGetAll(String key) { |
| | | return hashOps.entries(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿ååå¸è¡¨ key 䏿æåçå¼ã |
| | | */ |
| | | public List hVals(String key) { |
| | | return hashOps.values(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿ååå¸è¡¨ key ä¸çææåã |
| | | * åºå±å®ç°æ¤æ¹æ³åå为 hfields æ´ä¸ºåéï¼å¨æ¤ä»
为ä¸åºå±ä¿æä¸è´ |
| | | */ |
| | | public Set<Object> hKeys(String key) { |
| | | return hashOps.keys(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿ååå¸è¡¨ key ä¸åçæ°éã |
| | | */ |
| | | public Long hLen(String key) { |
| | | return hashOps.size(key); |
| | | } |
| | | |
| | | /** |
| | | * 为åå¸è¡¨ key ä¸çå field çå¼å ä¸å¢é increment ã |
| | | * å¢éä¹å¯ä»¥ä¸ºè´æ°ï¼ç¸å½äºå¯¹ç»å®åè¿è¡åæ³æä½ã |
| | | * 妿 key ä¸åå¨ï¼ä¸ä¸ªæ°çåå¸è¡¨è¢«å建并æ§è¡ HINCRBY å½ä»¤ã |
| | | * 妿å field ä¸åå¨ï¼é£ä¹å¨æ§è¡å½ä»¤åï¼åçå¼è¢«åå§å为 0 ã |
| | | * 对ä¸ä¸ªå¨åå符串å¼çå field æ§è¡ HINCRBY å½ä»¤å°é æä¸ä¸ªé误ã |
| | | * æ¬æä½çå¼è¢«éå¶å¨ 64 ä½(bit)æç¬¦å·æ°å表示ä¹å
ã |
| | | */ |
| | | public Long hIncrBy(String key, Object field, long value) { |
| | | return hashOps.increment(key, field, value); |
| | | } |
| | | |
| | | /** |
| | | * 为åå¸è¡¨ key ä¸çå field å 䏿µ®ç¹æ°å¢é increment ã |
| | | * 妿åå¸è¡¨ä¸æ²¡æå field ï¼é£ä¹ HINCRBYFLOAT ä¼å
å°å field çå¼è®¾ä¸º 0 ï¼ç¶ååæ§è¡å æ³æä½ã |
| | | * å¦æé® key ä¸åå¨ï¼é£ä¹ HINCRBYFLOAT ä¼å
å建ä¸ä¸ªåå¸è¡¨ï¼åå建å field ï¼æååæ§è¡å æ³æä½ã |
| | | * å½ä»¥ä¸ä»»æä¸ä¸ªæ¡ä»¶åçæ¶ï¼è¿åä¸ä¸ªéè¯¯ï¼ |
| | | * 1:å field çå¼ä¸æ¯å符串类å(å 为 redis ä¸çæ°ååæµ®ç¹æ°é½ä»¥å符串çå½¢å¼ä¿åï¼æä»¥å®ä»¬é½å±äºå符串类åï¼ |
| | | * 2:å field å½åç弿ç»å®çå¢é increment ä¸è½è§£é(parse)为åç²¾åº¦æµ®ç¹æ°(double precision floating point number) |
| | | * HINCRBYFLOAT å½ä»¤ç详ç»åè½å INCRBYFLOAT å½ä»¤ç±»ä¼¼ï¼è¯·æ¥ç INCRBYFLOAT å½ä»¤è·åæ´å¤ç¸å
³ä¿¡æ¯ã |
| | | */ |
| | | public Double hIncrByFloat(String key, Object field, double value) { |
| | | return hashOps.increment(key, field, value); |
| | | } |
| | | |
| | | /** |
| | | * è¿åå表 key ä¸ï¼ä¸æ 为 index çå
ç´ ã |
| | | * 䏿 (index)åæ° start å stop é½ä»¥ 0 为åºï¼ä¹å°±æ¯è¯´ï¼ä»¥ 0 表示å表ç第ä¸ä¸ªå
ç´ ï¼ |
| | | * 以 1 表示å表ç第äºä¸ªå
ç´ ï¼ä»¥æ¤ç±»æ¨ã |
| | | * ä½ ä¹å¯ä»¥ä½¿ç¨è´æ°ä¸æ ï¼ä»¥ -1 表示å表çæåä¸ä¸ªå
ç´ ï¼ -2 表示å表çåæ°ç¬¬äºä¸ªå
ç´ ï¼ä»¥æ¤ç±»æ¨ã |
| | | * 妿 key 䏿¯å表类åï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public <T> T lIndex(String key, long index) { |
| | | return (T) listOps.index(key, index); |
| | | } |
| | | |
| | | /** |
| | | * è¿åå表 key çé¿åº¦ã |
| | | * 妿 key ä¸åå¨ï¼å key 被解é为ä¸ä¸ªç©ºå表ï¼è¿å 0 . |
| | | * 妿 key 䏿¯å表类åï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public Long lLen(String key) { |
| | | return listOps.size(key); |
| | | } |
| | | |
| | | /** |
| | | * ç§»é¤å¹¶è¿åå表 key ç头å
ç´ ã |
| | | */ |
| | | public <T> T lPop(String key) { |
| | | return (T) listOps.leftPop(key); |
| | | } |
| | | |
| | | /** |
| | | * å°ä¸ä¸ªæå¤ä¸ªå¼ value æå
¥å°å表 key ç表头 |
| | | * 妿æå¤ä¸ª value å¼ï¼é£ä¹å个 value 弿ä»å·¦å°å³ç顺åºä¾æ¬¡æå
¥å°è¡¨å¤´ï¼ æ¯å¦è¯´ï¼ |
| | | * 对空å表 mylist æ§è¡å½ä»¤ LPUSH mylist a b c ï¼å表çå¼å°æ¯ c b a ï¼ |
| | | * è¿çåäºååæ§å°æ§è¡ LPUSH mylist a ã LPUSH mylist b å LPUSH mylist c ä¸ä¸ªå½ä»¤ã |
| | | * 妿 key ä¸åå¨ï¼ä¸ä¸ªç©ºå表ä¼è¢«å建并æ§è¡ LPUSH æä½ã |
| | | * å½ key åå¨ä½ä¸æ¯åè¡¨ç±»åæ¶ï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public Long lPush(String key, Object... values) { |
| | | return listOps.leftPush(key, values); |
| | | } |
| | | |
| | | /** |
| | | * å°å表 key 䏿 为 index çå
ç´ çå¼è®¾ç½®ä¸º value ã |
| | | * å½ index åæ°è¶
åºèå´ï¼æå¯¹ä¸ä¸ªç©ºå表( key ä¸åå¨)è¿è¡ LSET æ¶ï¼è¿åä¸ä¸ªé误ã |
| | | * å
³äºåè¡¨ä¸æ çæ´å¤ä¿¡æ¯ï¼è¯·åè LINDEX å½ä»¤ã |
| | | */ |
| | | public void lSet(String key, long index, Object value) { |
| | | listOps.set(key, index, value); |
| | | } |
| | | |
| | | /** |
| | | * æ ¹æ®åæ° count çå¼ï¼ç§»é¤å表ä¸ä¸åæ° value ç¸ççå
ç´ ã |
| | | * count çå¼å¯ä»¥æ¯ä»¥ä¸å ç§ï¼ |
| | | * count > 0 : ä»è¡¨å¤´å¼å§å表尾æç´¢ï¼ç§»é¤ä¸ value ç¸ççå
ç´ ï¼æ°é为 count ã |
| | | * count < 0 : ä»è¡¨å°¾å¼å§å表头æç´¢ï¼ç§»é¤ä¸ value ç¸ççå
ç´ ï¼æ°é为 count çç»å¯¹å¼ã |
| | | * count = 0 : ç§»é¤è¡¨ä¸ææä¸ value ç¸ççå¼ã |
| | | */ |
| | | public Long lRem(String key, long count, Object value) { |
| | | return listOps.remove(key, count, value); |
| | | } |
| | | |
| | | /** |
| | | * è¿åå表 key 䏿å®åºé´å
çå
ç´ ï¼åºé´ä»¥åç§»é start å stop æå®ã |
| | | * 䏿 (index)åæ° start å stop é½ä»¥ 0 为åºï¼ä¹å°±æ¯è¯´ï¼ä»¥ 0 表示å表ç第ä¸ä¸ªå
ç´ ï¼ä»¥ 1 表示å表ç第äºä¸ªå
ç´ ï¼ä»¥æ¤ç±»æ¨ã |
| | | * ä½ ä¹å¯ä»¥ä½¿ç¨è´æ°ä¸æ ï¼ä»¥ -1 表示å表çæåä¸ä¸ªå
ç´ ï¼ -2 表示å表çåæ°ç¬¬äºä¸ªå
ç´ ï¼ä»¥æ¤ç±»æ¨ã |
| | | * <pre> |
| | | * ä¾åï¼ |
| | | * è·å list ä¸æææ°æ®ï¼cache.lrange(listKey, 0, -1); |
| | | * è·å list ä¸ä¸æ 1 å° 3 çæ°æ®ï¼ cache.lrange(listKey, 1, 3); |
| | | * </pre> |
| | | */ |
| | | public List lRange(String key, long start, long end) { |
| | | return listOps.range(key, start, end); |
| | | } |
| | | |
| | | /** |
| | | * 对ä¸ä¸ªå表è¿è¡ä¿®åª(trim)ï¼å°±æ¯è¯´ï¼è®©å表åªä¿çæå®åºé´å
çå
ç´ ï¼ä¸å¨æå®åºé´ä¹å
çå
ç´ é½å°è¢«å é¤ã |
| | | * 举个ä¾åï¼æ§è¡å½ä»¤ LTRIM list 0 2 ï¼è¡¨ç¤ºåªä¿çå表 list çåä¸ä¸ªå
ç´ ï¼å
¶ä½å
ç´ å
¨é¨å é¤ã |
| | | * 䏿 (index)åæ° start å stop é½ä»¥ 0 为åºï¼ä¹å°±æ¯è¯´ï¼ä»¥ 0 表示å表ç第ä¸ä¸ªå
ç´ ï¼ä»¥ 1 表示å表ç第äºä¸ªå
ç´ ï¼ä»¥æ¤ç±»æ¨ã |
| | | * ä½ ä¹å¯ä»¥ä½¿ç¨è´æ°ä¸æ ï¼ä»¥ -1 表示å表çæåä¸ä¸ªå
ç´ ï¼ -2 表示å表çåæ°ç¬¬äºä¸ªå
ç´ ï¼ä»¥æ¤ç±»æ¨ã |
| | | * å½ key 䏿¯åè¡¨ç±»åæ¶ï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public void lTrim(String key, long start, long end) { |
| | | listOps.trim(key, start, end); |
| | | } |
| | | |
| | | /** |
| | | * ç§»é¤å¹¶è¿åå表 key çå°¾å
ç´ ã |
| | | */ |
| | | public <T> T rPop(String key) { |
| | | return (T) listOps.rightPop(key); |
| | | } |
| | | |
| | | /** |
| | | * å°ä¸ä¸ªæå¤ä¸ªå¼ value æå
¥å°å表 key ç表尾(æå³è¾¹)ã |
| | | * 妿æå¤ä¸ª value å¼ï¼é£ä¹å个 value 弿ä»å·¦å°å³ç顺åºä¾æ¬¡æå
¥å°è¡¨å°¾ï¼æ¯å¦ |
| | | * 对ä¸ä¸ªç©ºå表 mylist æ§è¡ RPUSH mylist a b c ï¼å¾åºçç»æå表为 a b c ï¼ |
| | | * çåäºæ§è¡å½ä»¤ RPUSH mylist a ã RPUSH mylist b ã RPUSH mylist c ã |
| | | * 妿 key ä¸åå¨ï¼ä¸ä¸ªç©ºå表ä¼è¢«å建并æ§è¡ RPUSH æä½ã |
| | | * å½ key åå¨ä½ä¸æ¯åè¡¨ç±»åæ¶ï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public Long rPush(String key, Object... values) { |
| | | return listOps.rightPush(key, values); |
| | | } |
| | | |
| | | /** |
| | | * å½ä»¤ RPOPLPUSH å¨ä¸ä¸ªååæ¶é´å
ï¼æ§è¡ä»¥ä¸ä¸¤ä¸ªå¨ä½ï¼ |
| | | * å°å表 source ä¸çæåä¸ä¸ªå
ç´ (å°¾å
ç´ )å¼¹åºï¼å¹¶è¿åç»å®¢æ·ç«¯ã |
| | | * å° source å¼¹åºçå
ç´ æå
¥å°å表 destination ï¼ä½ä¸º destination å表çç头å
ç´ ã |
| | | */ |
| | | public <T> T rPopLPush(String srcKey, String dstKey) { |
| | | return (T) listOps.rightPopAndLeftPush(srcKey, dstKey); |
| | | } |
| | | |
| | | /** |
| | | * å°ä¸ä¸ªæå¤ä¸ª member å
ç´ å å
¥å°éå key å½ä¸ï¼å·²ç»åå¨äºéåç member å
ç´ å°è¢«å¿½ç¥ã |
| | | * åå¦ key ä¸åå¨ï¼åå建ä¸ä¸ªåªå
å« member å
ç´ ä½æåçéåã |
| | | * å½ key 䏿¯éåç±»åæ¶ï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public Long sAdd(String key, Object... members) { |
| | | return setOps.add(key, members); |
| | | } |
| | | |
| | | /** |
| | | * ç§»é¤å¹¶è¿åéåä¸çä¸ä¸ªéæºå
ç´ ã |
| | | * å¦æåªæ³è·åä¸ä¸ªéæºå
ç´ ï¼ä½ä¸æ³è¯¥å
ç´ ä»éåä¸è¢«ç§»é¤çè¯ï¼å¯ä»¥ä½¿ç¨ SRANDMEMBER å½ä»¤ã |
| | | */ |
| | | public <T> T sPop(String key) { |
| | | return (T) setOps.pop(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿åéå key ä¸çæææåã |
| | | * ä¸åå¨ç key 被è§ä¸ºç©ºéåã |
| | | */ |
| | | public Set sMembers(String key) { |
| | | return setOps.members(key); |
| | | } |
| | | |
| | | /** |
| | | * 夿 member å
ç´ æ¯å¦éå key çæåã |
| | | */ |
| | | public boolean sIsMember(String key, Object member) { |
| | | return setOps.isMember(key, member); |
| | | } |
| | | |
| | | /** |
| | | * è¿åå¤ä¸ªéåç交éï¼å¤ä¸ªéåç± keys æå® |
| | | */ |
| | | public Set sInter(String key, String otherKey) { |
| | | return setOps.intersect(key, otherKey); |
| | | } |
| | | |
| | | /** |
| | | * è¿åå¤ä¸ªéåç交éï¼å¤ä¸ªéåç± keys æå® |
| | | */ |
| | | public Set sInter(String key, Collection<String> otherKeys) { |
| | | return setOps.intersect(key, otherKeys); |
| | | } |
| | | |
| | | /** |
| | | * è¿åéåä¸çä¸ä¸ªéæºå
ç´ ã |
| | | */ |
| | | public <T> T sRandMember(String key) { |
| | | return (T) setOps.randomMember(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿åéåä¸ç count ä¸ªéæºå
ç´ ã |
| | | * ä» Redis 2.6 çæ¬å¼å§ï¼ SRANDMEMBER å½ä»¤æ¥åå¯éç count åæ°ï¼ |
| | | * 妿 count ä¸ºæ£æ°ï¼ä¸å°äºéååºæ°ï¼é£ä¹å½ä»¤è¿åä¸ä¸ªå
å« count 个å
ç´ çæ°ç»ï¼æ°ç»ä¸çå
ç´ åä¸ç¸åã |
| | | * 妿 count 大äºçäºéååºæ°ï¼é£ä¹è¿åæ´ä¸ªéåã |
| | | * 妿 count ä¸ºè´æ°ï¼é£ä¹å½ä»¤è¿åä¸ä¸ªæ°ç»ï¼æ°ç»ä¸çå
ç´ å¯è½ä¼éå¤åºç°å¤æ¬¡ï¼èæ°ç»çé¿åº¦ä¸º count çç»å¯¹å¼ã |
| | | * 该æä½å SPOP ç¸ä¼¼ï¼ä½ SPOP å°éæºå
ç´ ä»éåä¸ç§»é¤å¹¶è¿åï¼è SRANDMEMBER åä»
ä»
è¿åéæºå
ç´ ï¼èä¸å¯¹éåè¿è¡ä»»ä½æ¹å¨ã |
| | | */ |
| | | public List sRandMember(String key, int count) { |
| | | return setOps.randomMembers(key, count); |
| | | } |
| | | |
| | | /** |
| | | * ç§»é¤éå key ä¸çä¸ä¸ªæå¤ä¸ª member å
ç´ ï¼ä¸åå¨ç member å
ç´ ä¼è¢«å¿½ç¥ã |
| | | */ |
| | | public Long sRem(String key, Object... members) { |
| | | return setOps.remove(key, members); |
| | | } |
| | | |
| | | /** |
| | | * è¿åå¤ä¸ªéåçå¹¶éï¼å¤ä¸ªéåç± keys æå® |
| | | * ä¸åå¨ç key 被è§ä¸ºç©ºéã |
| | | */ |
| | | public Set sUnion(String key, String otherKey) { |
| | | return setOps.union(key, otherKey); |
| | | } |
| | | |
| | | /** |
| | | * è¿åå¤ä¸ªéåçå¹¶éï¼å¤ä¸ªéåç± keys æå® |
| | | * ä¸åå¨ç key 被è§ä¸ºç©ºéã |
| | | */ |
| | | public Set sUnion(String key, Collection<String> otherKeys) { |
| | | return setOps.union(key, otherKeys); |
| | | } |
| | | |
| | | /** |
| | | * è¿åä¸ä¸ªéåçå
¨é¨æåï¼è¯¥é忝ææç»å®éåä¹é´çå·®éã |
| | | * ä¸åå¨ç key 被è§ä¸ºç©ºéã |
| | | */ |
| | | public Set sDiff(String key, String otherKey) { |
| | | return setOps.difference(key, otherKey); |
| | | } |
| | | |
| | | /** |
| | | * è¿åä¸ä¸ªéåçå
¨é¨æåï¼è¯¥é忝ææç»å®éåä¹é´çå·®éã |
| | | * ä¸åå¨ç key 被è§ä¸ºç©ºéã |
| | | */ |
| | | public Set sDiff(String key, Collection<String> otherKeys) { |
| | | return setOps.difference(key, otherKeys); |
| | | } |
| | | |
| | | /** |
| | | * å°ä¸ä¸ªæå¤ä¸ª member å
ç´ åå
¶ score å¼å å
¥å°æåºé key å½ä¸ã |
| | | * 妿æä¸ª member å·²ç»æ¯æåºéçæåï¼é£ä¹æ´æ°è¿ä¸ª member ç score å¼ï¼ |
| | | * å¹¶éè¿éæ°æå
¥è¿ä¸ª member å
ç´ ï¼æ¥ä¿è¯è¯¥ member 卿£ç¡®çä½ç½®ä¸ã |
| | | */ |
| | | public Boolean zAdd(String key, Object member, double score) { |
| | | return zSetOps.add(key, member, score); |
| | | } |
| | | |
| | | /** |
| | | * å°ä¸ä¸ªæå¤ä¸ª member å
ç´ åå
¶ score å¼å å
¥å°æåºé key å½ä¸ã |
| | | * 妿æä¸ª member å·²ç»æ¯æåºéçæåï¼é£ä¹æ´æ°è¿ä¸ª member ç score å¼ï¼ |
| | | * å¹¶éè¿éæ°æå
¥è¿ä¸ª member å
ç´ ï¼æ¥ä¿è¯è¯¥ member 卿£ç¡®çä½ç½®ä¸ã |
| | | */ |
| | | public Long zAdd(String key, Map<Object, Double> scoreMembers) { |
| | | Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>(); |
| | | scoreMembers.forEach((k, v) -> { |
| | | tuples.add(new DefaultTypedTuple<>(k, v)); |
| | | }); |
| | | return zSetOps.add(key, tuples); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key çåºæ°ã |
| | | */ |
| | | public Long zCard(String key) { |
| | | return zSetOps.zCard(key); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key ä¸ï¼ score å¼å¨ min å max ä¹é´(é»è®¤å
æ¬ score å¼çäº min æ max )çæåçæ°éã |
| | | * å
³äºåæ° min å max ç详ç»ä½¿ç¨æ¹æ³ï¼è¯·åè ZRANGEBYSCORE å½ä»¤ã |
| | | */ |
| | | public Long zCount(String key, double min, double max) { |
| | | return zSetOps.count(key, min, max); |
| | | } |
| | | |
| | | /** |
| | | * 为æåºé key çæå member ç score å¼å ä¸å¢é increment ã |
| | | */ |
| | | public Double zIncrBy(String key, Object member, double score) { |
| | | return zSetOps.incrementScore(key, member, score); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key ä¸ï¼æå®åºé´å
çæåã |
| | | * å
¶ä¸æåçä½ç½®æ score å¼éå¢(ä»å°å°å¤§)æ¥æåºã |
| | | * å
·æç¸å score å¼çæåæåå
¸åº(lexicographical order )æ¥æåã |
| | | * å¦æä½ éè¦æåæ score å¼éå(ä»å¤§å°å°)æ¥æåï¼è¯·ä½¿ç¨ ZREVRANGE å½ä»¤ã |
| | | */ |
| | | public Set zRange(String key, long start, long end) { |
| | | return zSetOps.range(key, start, end); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key ä¸ï¼æå®åºé´å
çæåã |
| | | * å
¶ä¸æåçä½ç½®æ score å¼éå(ä»å¤§å°å°)æ¥æåã |
| | | * å
·æç¸å score å¼çæåæåå
¸åºçéåº(reverse lexicographical order)æåã |
| | | * é¤äºæåæ score å¼éåçæ¬¡åºæåè¿ä¸ç¹å¤ï¼ ZREVRANGE å½ä»¤çå
¶ä»æ¹é¢å ZRANGE å½ä»¤ä¸æ ·ã |
| | | */ |
| | | public Set zRevrange(String key, long start, long end) { |
| | | return zSetOps.reverseRange(key, start, end); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key ä¸ï¼ææ score å¼ä»äº min å max ä¹é´(å
æ¬çäº min æ max )çæåã |
| | | * æåºéæåæ score å¼éå¢(ä»å°å°å¤§)æ¬¡åºæåã |
| | | */ |
| | | public Set zRangeByScore(String key, double min, double max) { |
| | | return zSetOps.rangeByScore(key, min, max); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key 䏿å member çæåãå
¶ä¸æåºéæåæ score å¼éå¢(ä»å°å°å¤§)é¡ºåºæåã |
| | | * æå以 0 为åºï¼ä¹å°±æ¯è¯´ï¼ score 弿å°çæåæå为 0 ã |
| | | * ä½¿ç¨ ZREVRANK å½ä»¤å¯ä»¥è·å¾æåæ score å¼éå(ä»å¤§å°å°)æåçæåã |
| | | */ |
| | | public Long zRank(String key, Object member) { |
| | | return zSetOps.rank(key, member); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key 䏿å member çæåãå
¶ä¸æåºéæåæ score å¼éå(ä»å¤§å°å°)æåºã |
| | | * æå以 0 为åºï¼ä¹å°±æ¯è¯´ï¼ score 弿大çæåæå为 0 ã |
| | | * ä½¿ç¨ ZRANK å½ä»¤å¯ä»¥è·å¾æåæ score å¼éå¢(ä»å°å°å¤§)æåçæåã |
| | | */ |
| | | public Long zRevrank(String key, Object member) { |
| | | return zSetOps.reverseRank(key, member); |
| | | } |
| | | |
| | | /** |
| | | * ç§»é¤æåºé key ä¸çä¸ä¸ªæå¤ä¸ªæåï¼ä¸åå¨çæåå°è¢«å¿½ç¥ã |
| | | * å½ key åå¨ä½ä¸æ¯æåºéç±»åæ¶ï¼è¿åä¸ä¸ªé误ã |
| | | */ |
| | | public Long zRem(String key, Object... members) { |
| | | return zSetOps.remove(key, members); |
| | | } |
| | | |
| | | /** |
| | | * è¿åæåºé key ä¸ï¼æå member ç score å¼ã |
| | | * 妿 member å
ç´ ä¸æ¯æåºé key çæåï¼æ key ä¸åå¨ï¼è¿å nil ã |
| | | */ |
| | | public Double zScore(String key, Object member) { |
| | | return zSetOps.score(key, member); |
| | | } |
| | | |
| | | } |