Package org.redisson.spring.data.connection

Class RedissonConnection

java.lang.Object
org.springframework.data.redis.connection.AbstractRedisConnection
org.redisson.spring.data.connection.RedissonConnection
All Implemented Interfaces:
AutoCloseable, org.springframework.data.redis.connection.DefaultedRedisConnection, org.springframework.data.redis.connection.RedisCommands, org.springframework.data.redis.connection.RedisCommandsProvider, org.springframework.data.redis.connection.RedisConnection, org.springframework.data.redis.connection.RedisConnectionCommands, org.springframework.data.redis.connection.RedisGeoCommands, org.springframework.data.redis.connection.RedisHashCommands, org.springframework.data.redis.connection.RedisHyperLogLogCommands, org.springframework.data.redis.connection.RedisKeyCommands, org.springframework.data.redis.connection.RedisListCommands, org.springframework.data.redis.connection.RedisPubSubCommands, org.springframework.data.redis.connection.RedisScriptingCommands, org.springframework.data.redis.connection.RedisServerCommands, org.springframework.data.redis.connection.RedisSetCommands, org.springframework.data.redis.connection.RedisStreamCommands, org.springframework.data.redis.connection.RedisStringCommands, org.springframework.data.redis.connection.RedisTxCommands, org.springframework.data.redis.connection.RedisZSetCommands
Direct Known Subclasses:
RedissonClusterConnection
public class RedissonConnection extends org.springframework.data.redis.connection.AbstractRedisConnection
Redisson connection
Author:
Nikita Koksharov

  • Nested Class Summary

    Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisGeoCommands

    org.springframework.data.redis.connection.RedisGeoCommands.DistanceUnit, org.springframework.data.redis.connection.RedisGeoCommands.GeoCommandArgs, org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<T>, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs, org.springframework.data.redis.connection.RedisGeoCommands.GeoSearchCommandArgs, org.springframework.data.redis.connection.RedisGeoCommands.GeoSearchStoreCommandArgs

    Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands

    org.springframework.data.redis.connection.RedisListCommands.Direction, org.springframework.data.redis.connection.RedisListCommands.Position

    Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisServerCommands

    org.springframework.data.redis.connection.RedisServerCommands.FlushOption, org.springframework.data.redis.connection.RedisServerCommands.MigrateOption, org.springframework.data.redis.connection.RedisServerCommands.ShutdownOption

    Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStreamCommands

    org.springframework.data.redis.connection.RedisStreamCommands.XAddOptions, org.springframework.data.redis.connection.RedisStreamCommands.XClaimOptions, org.springframework.data.redis.connection.RedisStreamCommands.XPendingOptions

    Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands

    org.springframework.data.redis.connection.RedisStringCommands.BitOperation, org.springframework.data.redis.connection.RedisStringCommands.SetOption

    Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands

    org.springframework.data.redis.connection.RedisZSetCommands.Limit, org.springframework.data.redis.connection.RedisZSetCommands.Range, org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    protected final Redisson
    redisson
     
    static final RedisCommand<Long>
    ZRANGESTORE
     

  • Constructor Summary

    Constructors
    Constructor
    Description
    RedissonConnection(RedissonClient redisson)
     
    RedissonConnection(RedissonClient redisson, boolean filterOkResponses)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    Long
    append(byte[] key, byte[] value)
     
    void
    bgReWriteAof()
     
    void
    bgSave()
     
    Long
    bitCount(byte[] key)
     
    Long
    bitCount(byte[] key, long begin, long end)
     
    List<Long>
    bitField(byte[] key, org.springframework.data.redis.connection.BitFieldSubCommands subCommands)
     
    Long
    bitOp(org.springframework.data.redis.connection.RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)
     
    Long
    bitPos(byte[] key, boolean bit, org.springframework.data.domain.Range<Long> range)
     
    byte[]
    bLMove(byte[] sourceKey, byte[] destinationKey, org.springframework.data.redis.connection.RedisListCommands.Direction from, org.springframework.data.redis.connection.RedisListCommands.Direction to, double timeout)
     
    List<byte[]>
    bLPop(int timeout, byte[]... keys)
     
    List<byte[]>
    bRPop(int timeout, byte[]... keys)
     
    byte[]
    bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)
     
    org.springframework.data.redis.connection.zset.Tuple
    bZPopMax(byte[] key, long timeout, TimeUnit unit)
     
    org.springframework.data.redis.connection.zset.Tuple
    bZPopMin(byte[] key, long timeout, TimeUnit unit)
     
    void
    close()
     
    List<Object>
    closePipeline()
     
    org.springframework.data.redis.connection.RedisCommands
    commands()
     
    protected List<byte[]>
    convert(Map<byte[],byte[]> tuple)
     
    Boolean
    copy(byte[] sourceKey, byte[] targetKey, boolean replace)
     
    Long
    dbSize()
     
    Long
    decr(byte[] key)
     
    Long
    decrBy(byte[] key, long value)
     
    Long
    del(byte[]... keys)
     
    void
    discard()
     
    byte[]
    dump(byte[] key)
     
    byte[]
    echo(byte[] message)
     
    org.springframework.data.redis.connection.ValueEncoding
    encodingOf(byte[] key)
     
    <T> T
    eval(byte[] script, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)
     
    <T> T
    evalSha(byte[] scriptSha, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)
     
    <T> T
    evalSha(String scriptSha, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)
     
    List<Object>
    exec()
     
    Object
    execute(String command, byte[]... args)
     
    Boolean
    exists(byte[] key)
     
    Long
    exists(byte[]... keys)
     
    Boolean
    expire(byte[] key, long seconds)
     
    Boolean
    expire(byte[] key, long seconds, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)
     
    Boolean
    expireAt(byte[] key, long unixTime)
     
    Boolean
    expireAt(byte[] key, long unixTime, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)
     
    protected void
    filterResults(BatchResult<?> result)
     
    void
    flushAll()
     
    void
    flushAll(org.springframework.data.redis.connection.RedisServerCommands.FlushOption option)
     
    void
    flushDb()
     
    void
    flushDb(org.springframework.data.redis.connection.RedisServerCommands.FlushOption option)
     
    Long
    geoAdd(byte[] key, Iterable<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> locations)
     
    Long
    geoAdd(byte[] key, Map<byte[],org.springframework.data.geo.Point> memberCoordinateMap)
     
    Long
    geoAdd(byte[] key, org.springframework.data.geo.Point point, byte[] member)
     
    Long
    geoAdd(byte[] key, org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]> location)
     
    org.springframework.data.redis.connection.RedisGeoCommands
    geoCommands()
     
    org.springframework.data.geo.Distance
    geoDist(byte[] key, byte[] member1, byte[] member2)
     
    org.springframework.data.geo.Distance
    geoDist(byte[] key, byte[] member1, byte[] member2, org.springframework.data.geo.Metric metric)
     
    List<String>
    geoHash(byte[] key, byte[]... members)
     
    List<org.springframework.data.geo.Point>
    geoPos(byte[] key, byte[]... members)
     
    org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>
    geoRadius(byte[] key, org.springframework.data.geo.Circle within)
     
    org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>
    geoRadius(byte[] key, org.springframework.data.geo.Circle within, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)
     
    org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>
    geoRadiusByMember(byte[] key, byte[] member, double radius)
     
    org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>
    geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius)
     
    org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>
    geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)
     
    Long
    geoRemove(byte[] key, byte[]... members)
     
    org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>
    geoSearch(byte[] key, org.springframework.data.redis.domain.geo.GeoReference<byte[]> reference, org.springframework.data.redis.domain.geo.GeoShape predicate, org.springframework.data.redis.connection.RedisGeoCommands.GeoSearchCommandArgs args)
     
    Long
    geoSearchStore(byte[] destKey, byte[] key, org.springframework.data.redis.domain.geo.GeoReference<byte[]> reference, org.springframework.data.redis.domain.geo.GeoShape predicate, org.springframework.data.redis.connection.RedisGeoCommands.GeoSearchStoreCommandArgs args)
     
    byte[]
    get(byte[] key)
     
    Boolean
    getBit(byte[] key, long offset)
     
    List<org.springframework.data.redis.core.types.RedisClientInfo>
    getClientList()
     
    String
    getClientName()
     
    Properties
    getConfig(String pattern)
     
    byte[]
    getDel(byte[] key)
     
    byte[]
    getEx(byte[] key, org.springframework.data.redis.core.types.Expiration expiration)
     
    Object
    getNativeConnection()
     
    byte[]
    getRange(byte[] key, long begin, long end)
     
    byte[]
    getSet(byte[] key, byte[] value)
     
    org.springframework.data.redis.connection.Subscription
    getSubscription()
     
    org.springframework.data.redis.connection.RedisHashCommands
    hashCommands()
     
    Long
    hDel(byte[] key, byte[]... fields)
     
    Boolean
    hExists(byte[] key, byte[] field)
     
    List<Long>
    hExpire(byte[] key, long seconds, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)
     
    List<Long>
    hExpireAt(byte[] key, long unixTime, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)
     
    byte[]
    hGet(byte[] key, byte[] field)
     
    Map<byte[],byte[]>
    hGetAll(byte[] key)
     
    Double
    hIncrBy(byte[] key, byte[] field, double delta)
     
    Long
    hIncrBy(byte[] key, byte[] field, long delta)
     
    Set<byte[]>
    hKeys(byte[] key)
     
    Long
    hLen(byte[] key)
     
    List<byte[]>
    hMGet(byte[] key, byte[]... fields)
     
    void
    hMSet(byte[] key, Map<byte[],byte[]> hashes)
     
    List<Long>
    hPersist(byte[] key, byte[]... fields)
     
    List<Long>
    hpExpire(byte[] key, long millis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)
     
    List<Long>
    hpExpireAt(byte[] key, long unixTimeInMillis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)
     
    List<Long>
    hpTtl(byte[] key, byte[]... fields)
     
    byte[]
    hRandField(byte[] key)
     
    List<byte[]>
    hRandField(byte[] key, long count)
     
    Map.Entry<byte[],byte[]>
    hRandFieldWithValues(byte[] key)
     
    List<Map.Entry<byte[],byte[]>>
    hRandFieldWithValues(byte[] key, long count)
     
    org.springframework.data.redis.core.Cursor<Map.Entry<byte[],byte[]>>
    hScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)
     
    Boolean
    hSet(byte[] key, byte[] field, byte[] value)
     
    Boolean
    hSetNX(byte[] key, byte[] field, byte[] value)
     
    Long
    hStrLen(byte[] key, byte[] field)
     
    List<Long>
    hTtl(byte[] key, byte[]... fields)
     
    List<Long>
    hTtl(byte[] key, TimeUnit timeUnit, byte[]... fields)
     
    List<byte[]>
    hVals(byte[] key)
     
    org.springframework.data.redis.connection.RedisHyperLogLogCommands
    hyperLogLogCommands()
     
    Duration
    idletime(byte[] key)
     
    Long
    incr(byte[] key)
     
    Double
    incrBy(byte[] key, double value)
     
    Long
    incrBy(byte[] key, long value)
     
    protected void
    indexCommand(RedisCommand<?> command)
     
    Properties
    info()
     
    Properties
    info(String section)
     
    boolean
    isClosed()
     
    boolean
    isFilterOkResponses()
     
    boolean
    isPipelined()
     
    boolean
    isPipelinedAtomic()
     
    boolean
    isQueueing()
     
    boolean
    isSubscribed()
     
    org.springframework.data.redis.connection.RedisKeyCommands
    keyCommands()
     
    Set<byte[]>
    keys(byte[] pattern)
     
    void
    killClient(String host, int port)
     
    Long
    lastSave()
     
    byte[]
    lIndex(byte[] key, long index)
     
    Long
    lInsert(byte[] key, org.springframework.data.redis.connection.RedisListCommands.Position where, byte[] pivot, byte[] value)
     
    org.springframework.data.redis.connection.RedisListCommands
    listCommands()
     
    Long
    lLen(byte[] key)
     
    byte[]
    lMove(byte[] sourceKey, byte[] destinationKey, org.springframework.data.redis.connection.RedisListCommands.Direction from, org.springframework.data.redis.connection.RedisListCommands.Direction to)
     
    byte[]
    lPop(byte[] key)
     
    List<byte[]>
    lPop(byte[] key, long count)
     
    List<Long>
    lPos(byte[] key, byte[] element, Integer rank, Integer count)
     
    Long
    lPush(byte[] key, byte[]... values)
     
    Long
    lPushX(byte[] key, byte[] value)
     
    List<byte[]>
    lRange(byte[] key, long start, long end)
     
    Long
    lRem(byte[] key, long count, byte[] value)
     
    void
    lSet(byte[] key, long index, byte[] value)
     
    void
    lTrim(byte[] key, long start, long end)
     
    List<byte[]>
    mGet(byte[]... keys)
     
    void
    migrate(byte[] key, org.springframework.data.redis.connection.RedisNode target, int dbIndex, org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option)
     
    void
    migrate(byte[] key, org.springframework.data.redis.connection.RedisNode target, int dbIndex, org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option, long timeout)
     
    Boolean
    move(byte[] key, int dbIndex)
     
    Boolean
    mSet(Map<byte[],byte[]> tuple)
     
    Boolean
    mSetNX(Map<byte[],byte[]> tuple)
     
    void
    multi()
     
    void
    openPipeline()
     
    Boolean
    persist(byte[] key)
     
    Boolean
    pExpire(byte[] key, long millis)
     
    Boolean
    pExpire(byte[] key, long millis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)
     
    Boolean
    pExpireAt(byte[] key, long unixTimeInMillis)
     
    Boolean
    pExpireAt(byte[] key, long unixTimeInMillis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)
     
    Long
    pfAdd(byte[] key, byte[]... values)
     
    Long
    pfCount(byte[]... keys)
     
    void
    pfMerge(byte[] destinationKey, byte[]... sourceKeys)
     
    String
    ping()
     
    Boolean
    pSetEx(byte[] key, long milliseconds, byte[] value)
     
    void
    pSubscribe(org.springframework.data.redis.connection.MessageListener listener, byte[]... patterns)
     
    Long
    pTtl(byte[] key)
     
    Long
    pTtl(byte[] key, TimeUnit timeUnit)
     
    Long
    publish(byte[] channel, byte[] message)
     
    byte[]
    randomKey()
     
    Long
    refcount(byte[] key)
     
    void
    rename(byte[] oldName, byte[] newName)
     
    Boolean
    renameNX(byte[] oldName, byte[] newName)
     
    void
    replicaOf(String host, int port)
     
    void
    replicaOfNoOne()
     
    void
    resetConfigStats()
     
    protected void
    resetConnection()
     
    void
    restore(byte[] key, long ttlInMillis, byte[] serializedValue)
     
    void
    restore(byte[] key, long ttlInMillis, byte[] serializedValue, boolean replace)
     
    void
    rewriteConfig()
     
    byte[]
    rPop(byte[] key)
     
    List<byte[]>
    rPop(byte[] key, long count)
     
    byte[]
    rPopLPush(byte[] srcKey, byte[] dstKey)
     
    Long
    rPush(byte[] key, byte[]... values)
     
    Long
    rPushX(byte[] key, byte[] value)
     
    Long
    sAdd(byte[] key, byte[]... values)
     
    void
    save()
     
    org.springframework.data.redis.core.Cursor<byte[]>
    scan(org.springframework.data.redis.core.ScanOptions options)
     
    Long
    sCard(byte[] key)
     
    List<Boolean>
    scriptExists(String... scriptShas)
     
    void
    scriptFlush()
     
    org.springframework.data.redis.connection.RedisScriptingCommands
    scriptingCommands()
     
    void
    scriptKill()
     
    String
    scriptLoad(byte[] script)
     
    Set<byte[]>
    sDiff(byte[]... keys)
     
    Long
    sDiffStore(byte[] destKey, byte[]... keys)
     
    void
    select(int dbIndex)
     
    org.springframework.data.redis.connection.RedisServerCommands
    serverCommands()
     
    Boolean
    set(byte[] key, byte[] value)
     
    Boolean
    set(byte[] key, byte[] value, org.springframework.data.redis.core.types.Expiration expiration, org.springframework.data.redis.connection.RedisStringCommands.SetOption option)
     
    Boolean
    setBit(byte[] key, long offset, boolean value)
     
    void
    setClientName(byte[] name)
     
    org.springframework.data.redis.connection.RedisSetCommands
    setCommands()
     
    void
    setConfig(String param, String value)
     
    Boolean
    setEx(byte[] key, long seconds, byte[] value)
     
    void
    setFilterOkResponses(boolean filterOkResponses)
     
    byte[]
    setGet(byte[] key, byte[] value, org.springframework.data.redis.core.types.Expiration expiration, org.springframework.data.redis.connection.RedisStringCommands.SetOption option)
     
    Boolean
    setNX(byte[] key, byte[] value)
     
    void
    setRange(byte[] key, byte[] value, long offset)
     
    void
    shutdown()
     
    void
    shutdown(org.springframework.data.redis.connection.RedisServerCommands.ShutdownOption option)
     
    Set<byte[]>
    sInter(byte[]... keys)
     
    Long
    sInterStore(byte[] destKey, byte[]... keys)
     
    Boolean
    sIsMember(byte[] key, byte[] value)
     
    Set<byte[]>
    sMembers(byte[] key)
     
    List<Boolean>
    sMIsMember(byte[] key, byte[]... value)
     
    Boolean
    sMove(byte[] srcKey, byte[] destKey, byte[] value)
     
    List<byte[]>
    sort(byte[] key, org.springframework.data.redis.connection.SortParameters sortParams)
     
    Long
    sort(byte[] key, org.springframework.data.redis.connection.SortParameters sortParams, byte[] storeKey)
     
    byte[]
    sPop(byte[] key)
     
    List<byte[]>
    sPop(byte[] key, long count)
     
    byte[]
    sRandMember(byte[] key)
     
    List<byte[]>
    sRandMember(byte[] key, long count)
     
    Long
    sRem(byte[] key, byte[]... values)
     
    org.springframework.data.redis.core.Cursor<byte[]>
    sScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)
     
    org.springframework.data.redis.connection.RedisStreamCommands
    streamCommands()
     
    org.springframework.data.redis.connection.RedisStringCommands
    stringCommands()
     
    Long
    strLen(byte[] key)
     
    void
    subscribe(org.springframework.data.redis.connection.MessageListener listener, byte[]... channels)
     
    Set<byte[]>
    sUnion(byte[]... keys)
     
    Long
    sUnionStore(byte[] destKey, byte[]... keys)
     
    protected <T> T
    sync(RFuture<T> f)
     
    Long
    time(TimeUnit timeUnit)
     
    protected RedisCommand<?>
    toCommand(org.springframework.data.redis.connection.ReturnType returnType, String name)
     
    Long
    touch(byte[]... keys)
     
    protected RuntimeException
    transform(Exception ex)
     
    Long
    ttl(byte[] key)
     
    Long
    ttl(byte[] key, TimeUnit timeUnit)
     
    org.springframework.data.redis.connection.DataType
    type(byte[] key)
     
    Long
    unlink(byte[]... keys)
     
    void
    unwatch()
     
    void
    watch(byte[]... keys)
     
    Boolean
    zAdd(byte[] key, double score, byte[] value, org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs args)
     
    Long
    zAdd(byte[] key, Set<org.springframework.data.redis.connection.zset.Tuple> tuples, org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs args)
     
    Long
    zCard(byte[] key)
     
    Long
    zCount(byte[] key, double min, double max)
     
    Long
    zCount(byte[] key, org.springframework.data.domain.Range range)
     
    Set<byte[]>
    zDiff(byte[]... sets)
     
    Long
    zDiffStore(byte[] destKey, byte[]... sets)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zDiffWithScores(byte[]... sets)
     
    Double
    zIncrBy(byte[] key, double increment, byte[] value)
     
    Set<byte[]>
    zInter(byte[]... sets)
     
    Long
    zInterStore(byte[] destKey, byte[]... sets)
     
    Long
    zInterStore(byte[] destKey, org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zInterWithScores(byte[]... sets)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zInterWithScores(org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)
     
    Long
    zLexCount(byte[] key, org.springframework.data.domain.Range range)
     
    List<Double>
    zMScore(byte[] key, byte[]... values)
     
    org.springframework.data.redis.connection.zset.Tuple
    zPopMax(byte[] key)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zPopMax(byte[] key, long count)
     
    org.springframework.data.redis.connection.zset.Tuple
    zPopMin(byte[] key)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zPopMin(byte[] key, long count)
     
    byte[]
    zRandMember(byte[] key)
     
    List<byte[]>
    zRandMember(byte[] key, long count)
     
    org.springframework.data.redis.connection.zset.Tuple
    zRandMemberWithScore(byte[] key)
     
    List<org.springframework.data.redis.connection.zset.Tuple>
    zRandMemberWithScore(byte[] key, long count)
     
    Set<byte[]>
    zRange(byte[] key, long start, long end)
     
    Set<byte[]>
    zRangeByLex(byte[] key, org.springframework.data.domain.Range<byte[]> range, org.springframework.data.redis.connection.Limit limit)
     
    Set<byte[]>
    zRangeByScore(byte[] key, String min, String max)
     
    Set<byte[]>
    zRangeByScore(byte[] key, String min, String max, long offset, long count)
     
    Set<byte[]>
    zRangeByScore(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)
     
    Long
    zRangeStoreByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<byte[]> range, org.springframework.data.redis.connection.Limit limit)
     
    Long
    zRangeStoreByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<? extends Number> range, org.springframework.data.redis.connection.Limit limit)
     
    Long
    zRangeStoreRevByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<byte[]> range, org.springframework.data.redis.connection.Limit limit)
     
    Long
    zRangeStoreRevByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<? extends Number> range, org.springframework.data.redis.connection.Limit limit)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zRangeWithScores(byte[] key, long start, long end)
     
    Long
    zRank(byte[] key, byte[] value)
     
    Long
    zRem(byte[] key, byte[]... values)
     
    Long
    zRemRange(byte[] key, long start, long end)
     
    Long
    zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range)
     
    Long
    zRemRangeByScore(byte[] key, double min, double max)
     
    Long
    zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range)
     
    Set<byte[]>
    zRevRange(byte[] key, long start, long end)
     
    Set<byte[]>
    zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)
     
    Set<byte[]>
    zRevRangeByScore(byte[] key, double min, double max)
     
    Set<byte[]>
    zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zRevRangeWithScores(byte[] key, long start, long end)
     
    Long
    zRevRank(byte[] key, byte[] value)
     
    org.springframework.data.redis.core.Cursor<org.springframework.data.redis.connection.zset.Tuple>
    zScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)
     
    Double
    zScore(byte[] key, byte[] value)
     
    org.springframework.data.redis.connection.RedisZSetCommands
    zSetCommands()
     
    Set<byte[]>
    zUnion(byte[]... sets)
     
    Long
    zUnionStore(byte[] destKey, byte[]... sets)
     
    Long
    zUnionStore(byte[] destKey, org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zUnionWithScores(byte[]... sets)
     
    Set<org.springframework.data.redis.connection.zset.Tuple>
    zUnionWithScores(org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)
     

    Methods inherited from class org.springframework.data.redis.connection.AbstractRedisConnection

    getSentinelConnection, getSentinelConnection, hasRedisSentinelConfigured, isActive, setSentinelConfiguration

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    Methods inherited from interface org.springframework.data.redis.connection.DefaultedRedisConnection

    applyHashFieldExpiration, hExpire, hExpireAt, hpExpire, hpExpireAt, time, xAck, xAdd, xClaim, xClaimJustId, xDel, xGroupCreate, xGroupCreate, xGroupDelConsumer, xGroupDestroy, xInfo, xInfoConsumers, xInfoGroups, xLen, xPending, xPending, xRange, xRange, xRead, xRead, xReadGroup, xReadGroup, xRevRange, xRevRange, xTrim, xTrim, zInterStore, zInterWithScores, zUnionStore, zUnionWithScores

    Methods inherited from interface org.springframework.data.redis.connection.RedisHashCommands

    applyHashFieldExpiration, hExpire, hpExpire

    Methods inherited from interface org.springframework.data.redis.connection.RedisKeyCommands

    applyExpiration, expire, expireAt, pExpire, pExpireAt, scan

    Methods inherited from interface org.springframework.data.redis.connection.RedisListCommands

    lPos

    Methods inherited from interface org.springframework.data.redis.connection.RedisStreamCommands

    xAck, xAdd, xAdd, xClaim, xDel, xGroupDelConsumer, xPending, xPending, xPending, xPending, xPending

    Methods inherited from interface org.springframework.data.redis.connection.RedisStringCommands

    bitPos

    Methods inherited from interface org.springframework.data.redis.connection.RedisZSetCommands

    zAdd, zAdd, zRangeByLex, zRangeByLex, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeStoreByLex, zRangeStoreByScore, zRangeStoreRevByLex, zRangeStoreRevByScore, zRevRangeByLex, zRevRangeByLex, zRevRangeByScore, zRevRangeByScore, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores

  • Field Details

  • Constructor Details

    • RedissonConnection

      public RedissonConnection(RedissonClient redisson)

    • RedissonConnection

      public RedissonConnection(RedissonClient redisson, boolean filterOkResponses)

  • Method Details

    • isFilterOkResponses

      public boolean isFilterOkResponses()

    • setFilterOkResponses

      public void setFilterOkResponses(boolean filterOkResponses)

    • close

      public void close() throws org.springframework.dao.DataAccessException
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface org.springframework.data.redis.connection.RedisConnection
      Overrides:
      close in class org.springframework.data.redis.connection.AbstractRedisConnection
      Throws:
      org.springframework.dao.DataAccessException

    • isClosed

      public boolean isClosed()

    • getNativeConnection

      public Object getNativeConnection()

    • isQueueing

      public boolean isQueueing()

    • isPipelined

      public boolean isPipelined()

    • isPipelinedAtomic

      public boolean isPipelinedAtomic()

    • openPipeline

      public void openPipeline()

    • closePipeline

      public List<Object> closePipeline() throws org.springframework.data.redis.connection.RedisPipelineException
      Throws:
      org.springframework.data.redis.connection.RedisPipelineException

    • execute

      public Object execute(String command, byte[]... args)

    • transform

      protected RuntimeException transform(Exception ex)

    • exists

      public Boolean exists(byte[] key)

    • del

      public Long del(byte[]... keys)

    • unlink

      public Long unlink(byte[]... keys)

    • type

      public org.springframework.data.redis.connection.DataType type(byte[] key)

    • keys

      public Set<byte[]> keys(byte[] pattern)

    • scan

      public org.springframework.data.redis.core.Cursor<byte[]> scan(org.springframework.data.redis.core.ScanOptions options)

    • randomKey

      public byte[] randomKey()

    • rename

      public void rename(byte[] oldName, byte[] newName)

    • renameNX

      public Boolean renameNX(byte[] oldName, byte[] newName)

    • expire

      public Boolean expire(byte[] key, long seconds)

    • pExpire

      public Boolean pExpire(byte[] key, long millis)

    • expireAt

      public Boolean expireAt(byte[] key, long unixTime)

    • pExpireAt

      public Boolean pExpireAt(byte[] key, long unixTimeInMillis)

    • persist

      public Boolean persist(byte[] key)

    • move

      public Boolean move(byte[] key, int dbIndex)

    • ttl

      public Long ttl(byte[] key)

    • sync

      protected <T> T sync(RFuture<T> f)

    • ttl

      public Long ttl(byte[] key, TimeUnit timeUnit)

    • pTtl

      public Long pTtl(byte[] key)

    • pTtl

      public Long pTtl(byte[] key, TimeUnit timeUnit)

    • sort

      public List<byte[]> sort(byte[] key, org.springframework.data.redis.connection.SortParameters sortParams)

    • sort

      public Long sort(byte[] key, org.springframework.data.redis.connection.SortParameters sortParams, byte[] storeKey)

    • dump

      public byte[] dump(byte[] key)

    • restore

      public void restore(byte[] key, long ttlInMillis, byte[] serializedValue)

    • get

      public byte[] get(byte[] key)

    • getSet

      public byte[] getSet(byte[] key, byte[] value)

    • mGet

      public List<byte[]> mGet(byte[]... keys)

    • set

      public Boolean set(byte[] key, byte[] value)

    • set

      public Boolean set(byte[] key, byte[] value, org.springframework.data.redis.core.types.Expiration expiration, org.springframework.data.redis.connection.RedisStringCommands.SetOption option)

    • setNX

      public Boolean setNX(byte[] key, byte[] value)

    • setEx

      public Boolean setEx(byte[] key, long seconds, byte[] value)

    • pSetEx

      public Boolean pSetEx(byte[] key, long milliseconds, byte[] value)

    • mSet

      public Boolean mSet(Map<byte[],byte[]> tuple)

    • convert

      protected List<byte[]> convert(Map<byte[],byte[]> tuple)

    • mSetNX

      public Boolean mSetNX(Map<byte[],byte[]> tuple)

    • incr

      public Long incr(byte[] key)

    • incrBy

      public Long incrBy(byte[] key, long value)

    • incrBy

      public Double incrBy(byte[] key, double value)

    • decr

      public Long decr(byte[] key)

    • decrBy

      public Long decrBy(byte[] key, long value)

    • append

      public Long append(byte[] key, byte[] value)

    • getRange

      public byte[] getRange(byte[] key, long begin, long end)

    • setRange

      public void setRange(byte[] key, byte[] value, long offset)

    • getBit

      public Boolean getBit(byte[] key, long offset)

    • setBit

      public Boolean setBit(byte[] key, long offset, boolean value)

    • bitCount

      public Long bitCount(byte[] key)

    • bitCount

      public Long bitCount(byte[] key, long begin, long end)

    • bitOp

      public Long bitOp(org.springframework.data.redis.connection.RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)

    • strLen

      public Long strLen(byte[] key)

    • rPush

      public Long rPush(byte[] key, byte[]... values)

    • lPush

      public Long lPush(byte[] key, byte[]... values)

    • rPushX

      public Long rPushX(byte[] key, byte[] value)

    • lPushX

      public Long lPushX(byte[] key, byte[] value)

    • lLen

      public Long lLen(byte[] key)

    • lRange

      public List<byte[]> lRange(byte[] key, long start, long end)

    • lTrim

      public void lTrim(byte[] key, long start, long end)

    • lIndex

      public byte[] lIndex(byte[] key, long index)

    • lInsert

      public Long lInsert(byte[] key, org.springframework.data.redis.connection.RedisListCommands.Position where, byte[] pivot, byte[] value)

    • indexCommand

      protected void indexCommand(RedisCommand<?> command)

    • lSet

      public void lSet(byte[] key, long index, byte[] value)

    • lRem

      public Long lRem(byte[] key, long count, byte[] value)

    • lPop

      public byte[] lPop(byte[] key)

    • rPop

      public byte[] rPop(byte[] key)

    • bLPop

      public List<byte[]> bLPop(int timeout, byte[]... keys)

    • bRPop

      public List<byte[]> bRPop(int timeout, byte[]... keys)

    • rPopLPush

      public byte[] rPopLPush(byte[] srcKey, byte[] dstKey)

    • bRPopLPush

      public byte[] bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)

    • lPos

      public List<Long> lPos(byte[] key, byte[] element, Integer rank, Integer count)

    • sAdd

      public Long sAdd(byte[] key, byte[]... values)

    • sRem

      public Long sRem(byte[] key, byte[]... values)

    • sPop

      public byte[] sPop(byte[] key)

    • sPop

      public List<byte[]> sPop(byte[] key, long count)

    • sMove

      public Boolean sMove(byte[] srcKey, byte[] destKey, byte[] value)

    • sCard

      public Long sCard(byte[] key)

    • sIsMember

      public Boolean sIsMember(byte[] key, byte[] value)

    • sInter

      public Set<byte[]> sInter(byte[]... keys)

    • sInterStore

      public Long sInterStore(byte[] destKey, byte[]... keys)

    • sUnion

      public Set<byte[]> sUnion(byte[]... keys)

    • sUnionStore

      public Long sUnionStore(byte[] destKey, byte[]... keys)

    • sDiff

      public Set<byte[]> sDiff(byte[]... keys)

    • sDiffStore

      public Long sDiffStore(byte[] destKey, byte[]... keys)

    • sMembers

      public Set<byte[]> sMembers(byte[] key)

    • sRandMember

      public byte[] sRandMember(byte[] key)

    • sRandMember

      public List<byte[]> sRandMember(byte[] key, long count)

    • sScan

      public org.springframework.data.redis.core.Cursor<byte[]> sScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)

    • zAdd

      public Boolean zAdd(byte[] key, double score, byte[] value, org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs args)

    • zAdd

      public Long zAdd(byte[] key, Set<org.springframework.data.redis.connection.zset.Tuple> tuples, org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs args)

    • zRem

      public Long zRem(byte[] key, byte[]... values)

    • zIncrBy

      public Double zIncrBy(byte[] key, double increment, byte[] value)

    • zRank

      public Long zRank(byte[] key, byte[] value)

    • zRevRank

      public Long zRevRank(byte[] key, byte[] value)

    • zRange

      public Set<byte[]> zRange(byte[] key, long start, long end)

    • zRangeWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zRangeWithScores(byte[] key, long start, long end)

    • zRangeByScoreWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)

    • zRevRange

      public Set<byte[]> zRevRange(byte[] key, long start, long end)

    • zRevRangeWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zRevRangeWithScores(byte[] key, long start, long end)

    • zRevRangeByScore

      public Set<byte[]> zRevRangeByScore(byte[] key, double min, double max)

    • zRevRangeByScore

      public Set<byte[]> zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)

    • zRevRangeByScoreWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)

    • zCount

      public Long zCount(byte[] key, double min, double max)

    • zCount

      public Long zCount(byte[] key, org.springframework.data.domain.Range range)

    • zCard

      public Long zCard(byte[] key)

    • zScore

      public Double zScore(byte[] key, byte[] value)

    • zRemRange

      public Long zRemRange(byte[] key, long start, long end)

    • zRemRangeByScore

      public Long zRemRangeByScore(byte[] key, double min, double max)

    • zRemRangeByScore

      public Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range)

    • zUnionStore

      public Long zUnionStore(byte[] destKey, byte[]... sets)

    • zUnionStore

      public Long zUnionStore(byte[] destKey, org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)

    • zInterStore

      public Long zInterStore(byte[] destKey, byte[]... sets)

    • zInterStore

      public Long zInterStore(byte[] destKey, org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)

    • zScan

      public org.springframework.data.redis.core.Cursor<org.springframework.data.redis.connection.zset.Tuple> zScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)

    • zRangeByScore

      public Set<byte[]> zRangeByScore(byte[] key, String min, String max)

    • zRangeByScore

      public Set<byte[]> zRangeByScore(byte[] key, String min, String max, long offset, long count)

    • zRangeByScore

      public Set<byte[]> zRangeByScore(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)

    • zRangeByLex

      public Set<byte[]> zRangeByLex(byte[] key, org.springframework.data.domain.Range<byte[]> range, org.springframework.data.redis.connection.Limit limit)

    • hSet

      public Boolean hSet(byte[] key, byte[] field, byte[] value)

    • hSetNX

      public Boolean hSetNX(byte[] key, byte[] field, byte[] value)

    • hGet

      public byte[] hGet(byte[] key, byte[] field)

    • hMGet

      public List<byte[]> hMGet(byte[] key, byte[]... fields)

    • hMSet

      public void hMSet(byte[] key, Map<byte[],byte[]> hashes)

    • hIncrBy

      public Long hIncrBy(byte[] key, byte[] field, long delta)

    • hIncrBy

      public Double hIncrBy(byte[] key, byte[] field, double delta)

    • hExists

      public Boolean hExists(byte[] key, byte[] field)

    • hDel

      public Long hDel(byte[] key, byte[]... fields)

    • hLen

      public Long hLen(byte[] key)

    • hKeys

      public Set<byte[]> hKeys(byte[] key)

    • hVals

      public List<byte[]> hVals(byte[] key)

    • hGetAll

      public Map<byte[],byte[]> hGetAll(byte[] key)

    • hScan

      public org.springframework.data.redis.core.Cursor<Map.Entry<byte[],byte[]>> hScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)

    • multi

      public void multi()

    • exec

      public List<Object> exec()

    • filterResults

      protected void filterResults(BatchResult<?> result)

    • resetConnection

      protected void resetConnection()

    • discard

      public void discard()

    • watch

      public void watch(byte[]... keys)

    • unwatch

      public void unwatch()

    • isSubscribed

      public boolean isSubscribed()

    • getSubscription

      public org.springframework.data.redis.connection.Subscription getSubscription()

    • publish

      public Long publish(byte[] channel, byte[] message)

    • subscribe

      public void subscribe(org.springframework.data.redis.connection.MessageListener listener, byte[]... channels)

    • pSubscribe

      public void pSubscribe(org.springframework.data.redis.connection.MessageListener listener, byte[]... patterns)

    • select

      public void select(int dbIndex)

    • echo

      public byte[] echo(byte[] message)

    • ping

      public String ping()

    • bgReWriteAof

      public void bgReWriteAof()

    • bgSave

      public void bgSave()

    • lastSave

      public Long lastSave()

    • save

      public void save()

    • dbSize

      public Long dbSize()

    • flushDb

      public void flushDb()

    • flushAll

      public void flushAll()

    • info

      public Properties info()

    • info

      public Properties info(String section)

    • shutdown

      public void shutdown()

    • shutdown

      public void shutdown(org.springframework.data.redis.connection.RedisServerCommands.ShutdownOption option)

    • getConfig

      public Properties getConfig(String pattern)

    • setConfig

      public void setConfig(String param, String value)

    • resetConfigStats

      public void resetConfigStats()

    • killClient

      public void killClient(String host, int port)

    • setClientName

      public void setClientName(byte[] name)

    • getClientName

      public String getClientName()

    • getClientList

      public List<org.springframework.data.redis.core.types.RedisClientInfo> getClientList()

    • migrate

      public void migrate(byte[] key, org.springframework.data.redis.connection.RedisNode target, int dbIndex, org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option)

    • migrate

      public void migrate(byte[] key, org.springframework.data.redis.connection.RedisNode target, int dbIndex, org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option, long timeout)

    • scriptFlush

      public void scriptFlush()

    • scriptKill

      public void scriptKill()

    • scriptLoad

      public String scriptLoad(byte[] script)

    • scriptExists

      public List<Boolean> scriptExists(String... scriptShas)

    • eval

      public <T> T eval(byte[] script, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)

    • toCommand

      protected RedisCommand<?> toCommand(org.springframework.data.redis.connection.ReturnType returnType, String name)

    • evalSha

      public <T> T evalSha(String scriptSha, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)

    • evalSha

      public <T> T evalSha(byte[] scriptSha, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)

    • geoAdd

      public Long geoAdd(byte[] key, org.springframework.data.geo.Point point, byte[] member)

    • geoAdd

      public Long geoAdd(byte[] key, org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]> location)

    • geoAdd

      public Long geoAdd(byte[] key, Map<byte[],org.springframework.data.geo.Point> memberCoordinateMap)

    • geoAdd

      public Long geoAdd(byte[] key, Iterable<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> locations)

    • geoDist

      public org.springframework.data.geo.Distance geoDist(byte[] key, byte[] member1, byte[] member2)

    • geoDist

      public org.springframework.data.geo.Distance geoDist(byte[] key, byte[] member1, byte[] member2, org.springframework.data.geo.Metric metric)

    • geoHash

      public List<String> geoHash(byte[] key, byte[]... members)

    • geoPos

      public List<org.springframework.data.geo.Point> geoPos(byte[] key, byte[]... members)

    • geoRadius

      public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key, org.springframework.data.geo.Circle within)

    • geoRadius

      public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key, org.springframework.data.geo.Circle within, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)

    • geoRadiusByMember

      public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, double radius)

    • geoRadiusByMember

      public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius)

    • geoRadiusByMember

      public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)

    • geoRemove

      public Long geoRemove(byte[] key, byte[]... members)

    • geoSearch

      public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoSearch(byte[] key, org.springframework.data.redis.domain.geo.GeoReference<byte[]> reference, org.springframework.data.redis.domain.geo.GeoShape predicate, org.springframework.data.redis.connection.RedisGeoCommands.GeoSearchCommandArgs args)

    • geoSearchStore

      public Long geoSearchStore(byte[] destKey, byte[] key, org.springframework.data.redis.domain.geo.GeoReference<byte[]> reference, org.springframework.data.redis.domain.geo.GeoShape predicate, org.springframework.data.redis.connection.RedisGeoCommands.GeoSearchStoreCommandArgs args)

    • pfAdd

      public Long pfAdd(byte[] key, byte[]... values)

    • pfCount

      public Long pfCount(byte[]... keys)

    • pfMerge

      public void pfMerge(byte[] destinationKey, byte[]... sourceKeys)

    • hStrLen

      public Long hStrLen(byte[] key, byte[] field)

    • streamCommands

      public org.springframework.data.redis.connection.RedisStreamCommands streamCommands()

    • bitField

      public List<Long> bitField(byte[] key, org.springframework.data.redis.connection.BitFieldSubCommands subCommands)

    • exists

      public Long exists(byte[]... keys)

    • touch

      public Long touch(byte[]... keys)

    • encodingOf

      public org.springframework.data.redis.connection.ValueEncoding encodingOf(byte[] key)

    • idletime

      public Duration idletime(byte[] key)

    • refcount

      public Long refcount(byte[] key)

    • bitPos

      public Long bitPos(byte[] key, boolean bit, org.springframework.data.domain.Range<Long> range)

    • restore

      public void restore(byte[] key, long ttlInMillis, byte[] serializedValue, boolean replace)

    • zRandMember

      public byte[] zRandMember(byte[] key)

    • zRandMember

      public List<byte[]> zRandMember(byte[] key, long count)

    • zRandMemberWithScore

      public org.springframework.data.redis.connection.zset.Tuple zRandMemberWithScore(byte[] key)

    • zRandMemberWithScore

      public List<org.springframework.data.redis.connection.zset.Tuple> zRandMemberWithScore(byte[] key, long count)

    • zPopMin

      public org.springframework.data.redis.connection.zset.Tuple zPopMin(byte[] key)

    • zPopMin

      public Set<org.springframework.data.redis.connection.zset.Tuple> zPopMin(byte[] key, long count)

    • bZPopMin

      public org.springframework.data.redis.connection.zset.Tuple bZPopMin(byte[] key, long timeout, TimeUnit unit)

    • zPopMax

      public org.springframework.data.redis.connection.zset.Tuple zPopMax(byte[] key)

    • zPopMax

      public Set<org.springframework.data.redis.connection.zset.Tuple> zPopMax(byte[] key, long count)

    • bZPopMax

      public org.springframework.data.redis.connection.zset.Tuple bZPopMax(byte[] key, long timeout, TimeUnit unit)

    • zMScore

      public List<Double> zMScore(byte[] key, byte[]... values)

    • zDiff

      public Set<byte[]> zDiff(byte[]... sets)

    • zDiffWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zDiffWithScores(byte[]... sets)

    • zDiffStore

      public Long zDiffStore(byte[] destKey, byte[]... sets)

    • zInter

      public Set<byte[]> zInter(byte[]... sets)

    • zInterWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zInterWithScores(org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)

    • zInterWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zInterWithScores(byte[]... sets)

    • zUnion

      public Set<byte[]> zUnion(byte[]... sets)

    • zUnionWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zUnionWithScores(org.springframework.data.redis.connection.zset.Aggregate aggregate, org.springframework.data.redis.connection.zset.Weights weights, byte[]... sets)

    • zUnionWithScores

      public Set<org.springframework.data.redis.connection.zset.Tuple> zUnionWithScores(byte[]... sets)

    • hRandField

      public byte[] hRandField(byte[] key)

    • hRandFieldWithValues

      public Map.Entry<byte[],byte[]> hRandFieldWithValues(byte[] key)

    • hRandField

      public List<byte[]> hRandField(byte[] key, long count)

    • hRandFieldWithValues

      public List<Map.Entry<byte[],byte[]>> hRandFieldWithValues(byte[] key, long count)

    • copy

      public Boolean copy(byte[] sourceKey, byte[] targetKey, boolean replace)

    • lMove

      public byte[] lMove(byte[] sourceKey, byte[] destinationKey, org.springframework.data.redis.connection.RedisListCommands.Direction from, org.springframework.data.redis.connection.RedisListCommands.Direction to)

    • bLMove

      public byte[] bLMove(byte[] sourceKey, byte[] destinationKey, org.springframework.data.redis.connection.RedisListCommands.Direction from, org.springframework.data.redis.connection.RedisListCommands.Direction to, double timeout)

    • lPop

      public List<byte[]> lPop(byte[] key, long count)

    • rPop

      public List<byte[]> rPop(byte[] key, long count)

    • sMIsMember

      public List<Boolean> sMIsMember(byte[] key, byte[]... value)

    • getEx

      public byte[] getEx(byte[] key, org.springframework.data.redis.core.types.Expiration expiration)

    • getDel

      public byte[] getDel(byte[] key)

    • zRevRangeByLex

      public Set<byte[]> zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit)

    • time

      public Long time(TimeUnit timeUnit)

    • zRemRangeByLex

      public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range)

    • zLexCount

      public Long zLexCount(byte[] key, org.springframework.data.domain.Range range)

    • rewriteConfig

      public void rewriteConfig()

    • zRangeStoreByLex

      public Long zRangeStoreByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<byte[]> range, org.springframework.data.redis.connection.Limit limit)

    • zRangeStoreRevByLex

      public Long zRangeStoreRevByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<byte[]> range, org.springframework.data.redis.connection.Limit limit)

    • zRangeStoreByScore

      public Long zRangeStoreByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<? extends Number> range, org.springframework.data.redis.connection.Limit limit)

    • zRangeStoreRevByScore

      public Long zRangeStoreRevByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<? extends Number> range, org.springframework.data.redis.connection.Limit limit)

    • flushDb

      public void flushDb(org.springframework.data.redis.connection.RedisServerCommands.FlushOption option)

    • flushAll

      public void flushAll(org.springframework.data.redis.connection.RedisServerCommands.FlushOption option)

    • replicaOf

      public void replicaOf(String host, int port)

    • replicaOfNoOne

      public void replicaOfNoOne()

    • setGet

      public byte[] setGet(byte[] key, byte[] value, org.springframework.data.redis.core.types.Expiration expiration, org.springframework.data.redis.connection.RedisStringCommands.SetOption option)

    • expire

      public Boolean expire(byte[] key, long seconds, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)

    • pExpire

      public Boolean pExpire(byte[] key, long millis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)

    • expireAt

      public Boolean expireAt(byte[] key, long unixTime, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)

    • pExpireAt

      public Boolean pExpireAt(byte[] key, long unixTimeInMillis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition)

    • hExpire

      public List<Long> hExpire(byte[] key, long seconds, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)

    • hpExpire

      public List<Long> hpExpire(byte[] key, long millis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)

    • hExpireAt

      public List<Long> hExpireAt(byte[] key, long unixTime, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)

    • hpExpireAt

      public List<Long> hpExpireAt(byte[] key, long unixTimeInMillis, org.springframework.data.redis.connection.ExpirationOptions.Condition condition, byte[]... fields)

    • hPersist

      public List<Long> hPersist(byte[] key, byte[]... fields)

    • hTtl

      public List<Long> hTtl(byte[] key, byte[]... fields)

    • hTtl

      public List<Long> hTtl(byte[] key, TimeUnit timeUnit, byte[]... fields)

    • hpTtl

      public List<Long> hpTtl(byte[] key, byte[]... fields)

    • commands

      public org.springframework.data.redis.connection.RedisCommands commands()

    • geoCommands

      public org.springframework.data.redis.connection.RedisGeoCommands geoCommands()

    • hashCommands

      public org.springframework.data.redis.connection.RedisHashCommands hashCommands()

    • hyperLogLogCommands

      public org.springframework.data.redis.connection.RedisHyperLogLogCommands hyperLogLogCommands()

    • keyCommands

      public org.springframework.data.redis.connection.RedisKeyCommands keyCommands()

    • listCommands

      public org.springframework.data.redis.connection.RedisListCommands listCommands()

    • setCommands

      public org.springframework.data.redis.connection.RedisSetCommands setCommands()

    • scriptingCommands

      public org.springframework.data.redis.connection.RedisScriptingCommands scriptingCommands()

    • serverCommands

      public org.springframework.data.redis.connection.RedisServerCommands serverCommands()

    • stringCommands

      public org.springframework.data.redis.connection.RedisStringCommands stringCommands()

    • zSetCommands

      public org.springframework.data.redis.connection.RedisZSetCommands zSetCommands()