RedisTemplate

这些是 ValueOperations、HashOperations、ListOperations、SetOperations 和 ZSetOperations 接口的主要方法。每个方法的具体用法可以根据需求查阅官方文档。

ValueOperations

//String类型
public interface ValueOperations<K, V> {
    void set(K key, V value);
    void set(K key, V value, long timeout, TimeUnit unit);
    V get(K key);
    Boolean setIfAbsent(K key, V value);
    Boolean setIfPresent(K key, V value);
    void multiSet(Map<? extends K, ? extends V> map);
    Boolean multiSetIfAbsent(Map<? extends K, ? extends V> map);
    Long increment(K key, long delta);
    Double increment(K key, double delta);
    Long append(K key, String value);
    String getAndSet(K key, V value);
    List<V> multiGet(Collection<K> keys);
    Boolean delete(K key);
    Boolean delete(Collection<K> keys);
    DataType type(K key);
}

HashOperations

//Hash类型
public interface HashOperations<H, HK, HV> {
    void put(H key, HK hashKey, HV value);
    Boolean putIfAbsent(H key, HK hashKey, HV value);
    Long increment(H key, HK hashKey, long delta);
    Double increment(H key, HK hashKey, double delta);
    HV get(H key, Object hashKey);
    List<HV> multiGet(H key, Collection<HK> hashKeys);
    void putAll(H key, Map<? extends HK, ? extends HV> m);
    Map<HK, HV> entries(H key);
    Set<HK> keys(H key);
    List<HV> values(H key);
    Long delete(H key, Object... hashKeys);
    Long size(H key);
    Boolean hasKey(H key, Object hashKey);
    Cursor<Map.Entry<HK, HV>> scan(H key, ScanOptions options);
}

ListOperations

//List类型
public interface ListOperations<K, V> {
    Long leftPush(K key, V value);
    Long leftPushAll(K key, V... values);
    Long leftPushAll(K key, Collection<V> values);
    Long leftPushIfPresent(K key, V value);
    Long leftPush(K key, V pivot, V value);
    Long rightPush(K key, V value);
    Long rightPushAll(K key, V... values);
    Long rightPushAll(K key, Collection<V> values);
    Long rightPushIfPresent(K key, V value);
    Long rightPush(K key, V pivot, V value);
    void set(K key, long index, V value);
    Long remove(K key, long count, Object value);
    V index(K key, long index);
    V leftPop(K key);
    V leftPop(K key, long timeout, TimeUnit unit);
    V rightPop(K key);
    V rightPop(K key, long timeout, TimeUnit unit);
    Long size(K key);
    List<V> range(K key, long start, long end);
    void trim(K key, long start, long end);
}

SetOperations

//Set类型
public interface SetOperations<K, V> {
    Boolean add(K key, V... values);
    Long remove(K key, Object... values);
    V pop(K key);
    Boolean move(K key, V value, K destKey);
    Long size(K key);
    Boolean isMember(K key, Object o);
    Set<V> intersect(K key, K otherKey);
    Set<V> intersect(K key, Collection<K> otherKeys);
    Long intersectAndStore(K key, K otherKey, K destKey);
    Long intersectAndStore(K key, Collection<K> otherKeys, K destKey);
    Set<V> union(K key, K otherKey);
    Set<V> union(K key, Collection<K> otherKeys);
    Long unionAndStore(K key, K otherKey, K destKey);
    Long unionAndStore(K key, Collection<K> otherKeys, K destKey);
    Set<V> difference(K key, K otherKey);
    Set<V> difference(K key, Collection<K> otherKeys);
    Long differenceAndStore(K key, K otherKey, K destKey);
    Long differenceAndStore(K key, Collection<K> otherKeys, K destKey);
    Set<V> members(K key);
    Cursor<V> scan(K key, ScanOptions options);
}

ZSetOperations

//ZSet类型
public interface ZSetOperations<K, V> {
    Boolean add(K key, V value, double score);    
    Long add(K key, Set<TypedTuple<V>> tuples);
    Double incrementScore(K key, V value, double delta);
    Long rank(K key, Object o);
    Long reverseRank(K key, Object o);
    Set<V> range(K key, long start, long end);
    Set<TypedTuple<V>> rangeWithScores(K key, long start, long end);
    Set<V> rangeByScore(K key, double min, double max);
    Set<TypedTuple<V>> rangeByScoreWithScores(K key, double min, double max);
    Set<V> rangeByScore(K key, double min, double max, long offset, long count);
    Set<TypedTuple<V>> rangeByScoreWithScores(K key, double min, double max, long offset, long count);
    Set<V> reverseRange(K key, long start, long end);
    Set<TypedTuple<V>> reverseRangeWithScores(K key, long start, long end);
    Set<V> reverseRangeByScore(K key, double min, double max);
    Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, double min, double max);
    Set<V> reverseRangeByScore(K key, double min, double max, long offset, long count);
    Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, double min, double max, long offset, long count);
    Long count(K key, double min, double max);
    Long size(K key);
    Double score(K key, Object o);
    Long remove(K key, Object... values);
    Long removeRange(K key, long start, long end);
    Long removeRangeByScore(K key, double min, double max);
    Long unionAndStore(K key, K otherKey, K destKey);
    Long unionAndStore(K key, Collection<K> otherKeys, K destKey);
    Long intersectAndStore(K key, K otherKey, K destKey);
    Long intersectAndStore(K key, Collection<K> otherKeys, K destKey);
    Cursor<TypedTuple<V>> scan(K key, ScanOptions options);
}