标签：return String Redis value 命令 param key StringCommands string
package redis.clients.jedis.commands;
import java.util.List;
import redis.clients.jedis.args.BitCountOption;
import redis.clients.jedis.args.BitOP;
import redis.clients.jedis.params.BitPosParams;
import redis.clients.jedis.params.GetExParams;
import redis.clients.jedis.params.SetParams;
import redis.clients.jedis.params.StrAlgoLCSParams;
import redis.clients.jedis.params.LCSParams;
import redis.clients.jedis.resps.LCSMatchResult;
public interface StringCommands {
/**
* <b><a href="http://redis.io/commands/set">Set Command</a></b>
* Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 GB).
* <p>
* Time complexity: O(1)
* @param key
* @param value
* @return OK
*/
String set(String key, String value);
/**
* <b><a href="http://redis.io/commands/set">Set Command</a></b>
* Set the string value as value of the key. Can be used with optional params.
* <p>
* Time complexity: O(1)<
* @param key
* @param value
* @param params {@link SetParams}
* @return OK
*/
String set(String key, String value, SetParams params);
/**
* <b><a href="http://redis.io/commands/get">Get Command</a></b>
* Get the value of the specified key. If the key does not exist the special value 'nil' is
* returned. If the value stored at key is not a string an error is returned because GET can only
* handle string values.
* <p>
* Time complexity: O(1)
* @param key
* @return The value stored in key
*/
String get(String key);
/**
* <b><a href="http://redis.io/commands/getdel">GetDel Command</a></b>
* Get the value of key and delete the key. This command is similar to GET, except for the fact
* that it also deletes the key on success (if and only if the key's value type is a string).
* <p>
* Time complexity: O(1)
* @param key
* @return The value of key
*
* 获取并删除
*/
String getDel(String key);
/**
* <b><a href="http://redis.io/commands/getex">GetEx Command</a></b>
* Get the value of key and optionally set its expiration. GETEX is similar to {@link StringCommands#get(String) GET},
* but is a write command with additional options:
* EX seconds -- Set the specified expire time, in seconds.
* PX milliseconds -- Set the specified expire time, in milliseconds.
* EXAT timestamp-seconds -- Set the specified Unix time at which the key will expire, in seconds.
* PXAT timestamp-milliseconds -- Set the specified Unix time at which the key will expire, in milliseconds.
* PERSIST -- Remove the time to live associated with the key.
* <p>
* Time complexity: O(1)
* @param key
* @param params {@link GetExParams}
* @return The original bit value stored at offset
*
* 获取 并设置 key的过期时间
*/
String getEx(String key, GetExParams params);
/**
* <b><a href="http://redis.io/commands/setbit">SetBit Command</a></b>
* Sets or clears the bit at offset in the string value stored at key.
* <p>
* Time complexity: O(1)
* @param key
* @param offset
* @param value
* @return The original bit value stored at offset
*
* 设置 key 存储的 string offset 位上的 值 （value） 设置的是 位 bit
*/
boolean setbit(String key, long offset, boolean value);
/**
* <b><a href="http://redis.io/commands/getbit">GetBit Command</a></b>
* Returns the bit value at offset in the string value stored at key.
* <p>
* Time complexity: O(1)
* @param key
* @param offset
* @return The bit value stored at offset
*
* 获取 key 存储的 string offset 位上的 值
*/
boolean getbit(String key, long offset);
/**
* <b><a href="http://redis.io/commands/setrange">SetRange Command</a></b>
* GETRANGE overwrite part of the string stored at key, starting at the specified offset, for the entire
* length of value. If the offset is larger than the current length of the string at key, the string is
* padded with zero-bytes to make offset fit. Non-existing keys are considered as empty strings, so this
* command will make sure it holds a string large enough to be able to set value at offset.
* <p>
* Time complexity: O(1)
* @param key
* @param offset
* @param value
* @return The length of the string after it was modified by the command
*
* 命令用指定的字符串覆盖给定 key 所储存的字符串值，覆盖的位置从偏移量 offset 开始。
*/
long setrange(String key, long offset, String value);
/**
* <b><a href="http://redis.io/commands/getrange">GetRange Command</a></b>
* Return the substring of the string value stored at key, determined by the offsets start
* and end (both are inclusive). Negative offsets can be used in order to provide an offset starting
* from the end of the string. So -1 means the last character, -2 the penultimate and so forth.
* <p>
* Time complexity: O(N) where N is the length of the returned string
* @param key
* @param startOffset
* @param endOffset
* @return The substring
*
* 令用于获取存储在指定 key 中字符串的子字符串。字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)
*/
String getrange(String key, long startOffset, long endOffset);
/**
* <b><a href="http://redis.io/commands/getset">GetSet Command</a></b>
* GETSET is an atomic set this value and return the old value command. Set key to the string
* value and return the old value stored at key. The string can't be longer than 1073741824 byte (1 GB).
* <p>
* Time complexity: O(1)
* @param key
* @param value
* @return The old value that was stored in key
*
* 获取 并且设置值
*/
String getSet(String key, String value);
/**
* <b><a href="http://redis.io/commands/setnx">SetNE Command</a></b>
* SETNX works exactly like {@link StringCommands#set(String, String) SET} with the only difference that if
* the key already exists no operation is performed. SETNX actually means "SET if Not Exists".
* <p>
* Time complexity: O(1)
* @param key
* @param value
* @return 1 if the key was set, 0 otherwise
*
* 不存在时则设置
*/
long setnx(String key, String value);
/**
* <b><a href="http://redis.io/commands/setex">SetEx Command</a></b>
* The command is exactly equivalent to the following group of commands:
* {@link StringCommands#set(String, String) SET} + {@link KeyBinaryCommands#expire(byte[], long) EXPIRE}.
* The operation is atomic.
* <p>
* Time complexity: O(1)
* @param key
* @param seconds
* @param value
* @return OK
*
* 设置设置 key的value 并设置过期时间，如果存在则替换旧的值
*/
String setex(String key, long seconds, String value);
/**
* <b><a href="http://redis.io/commands/psetex">PSetEx Command</a></b>
* PSETEX works exactly like {@link StringCommands#setex(String, long, String) SETEX} with the sole difference
* that the expire time is specified in milliseconds instead of seconds.
* <p>
* Time complexity: O(1)
* @param key
* @param milliseconds
* @param value
* @return OK
*
* 设置设置 key的value 并设置过期时间（毫秒），如果存在则替换旧的值
*/
String psetex(String key, long milliseconds, String value);
/**
* <b><a href="http://redis.io/commands/mget">MGet Command</a></b>
* Get the values of all the specified keys. If one or more keys don't exist or is not of type
* String, a 'nil' value is returned instead of the value of the specified key, but the operation
* never fails.
* <p>
* Time complexity: O(1) for every key
* @param keys
* @return Multi bulk reply
*
* t 命令返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil
*/
List<String> mget(String... keys);
/**
* <b><a href="http://redis.io/commands/mset">MSet Command</a></b>
* Set the the respective keys to the respective values. MSET will replace old values with new
* values, while {@link StringCommands#msetnx(String...) MSETNX} will not perform any operation at all even
* if just a single key already exists.
* <p>
* Because of this semantic MSETNX can be used in order to set different keys representing
* different fields of an unique logic object in a way that ensures that either all the fields or
* none at all are set.
* <p>
* Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B
* are modified, another connection talking to Redis can either see the changes to both A and B at
* once, or no modification at all.
* @param keysvalues pairs of keys and their values
* e.g mset("foo", "foovalue", "bar", "barvalue")
* @return OK
*
* Redis Mset 命令用于同时设置一个或多个 key-value 对。 MSET key1 value1 key2 value2 .. keyN valueN
*/
String mset(String... keysvalues);
/**
* <b><a href="http://redis.io/commands/msetnx">MSetNX Command</a></b>
* Set the respective keys to the respective values. {@link StringCommands#mset(String...) MSET} will
* replace old values with new values, while MSETNX will not perform any operation at all even if
* just a single key already exists.
* <p>
* Because of this semantic MSETNX can be used in order to set different keys representing
* different fields of an unique logic object in a way that ensures that either all the fields or
* none at all are set.
* <p>
* Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B
* are modified, another connection talking to Redis can either see the changes to both A and B at
* once, or no modification at all.
* @param keysvalues pairs of keys and their values
* e.g msetnx("foo", "foovalue", "bar", "barvalue")
* @return 1 if the all the keys were set, 0 if no key was set (at least one key already existed)
*
* Redis Msetnx 命令用于所有给定 key 都不存在时，同时设置一个或多个 key-value 对。
* 当所有 key 都成功设置，返回 1 。 如果所有给定 key 都设置失败(至少有一个 key 已经存在)，那么返回 0 。
*/
long msetnx(String... keysvalues);
/**
* <b><a href="http://redis.io/commands/incr">Incr Command</a></b>
* Increment the number stored at key by one. If the key does not exist or contains a value of a
* wrong type, set the key to the value of "0" before to perform the increment operation.
* <p>
* INCR commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to increment
* @return The value of the key after the increment
*
* Redis Incr 命令将 key 中储存的数字值增一。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long incr(String key);
/**
* <b><a href="http://redis.io/commands/incrby">IncrBy Command</a></b>
* INCRBY work just like {@link StringCommands#incr(String) INCR} but instead to increment by 1 the
* increment is integer.
* <p>
* INCR commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to increment
* @param increment the value to increment by
* @return The value of the key after the increment
*
* Redis Incr 命令将 key 中储存的数字值增 increment。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long incrBy(String key, long increment);
/**
* <b><a href="http://redis.io/commands/incrbyfloat">IncrByFloat Command</a></b>
* INCRBYFLOAT work just like {@link StringCommands#incrBy(String, long)} INCRBY} but increments by floats
* instead of integers.
* <p>
* INCRBYFLOAT commands are limited to double precision floating point values.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "double" types.
* Simply the string stored at the key is parsed as a base double precision floating point value,
* incremented, and then converted back as a string. There is no DECRYBYFLOAT but providing a
* negative value will work as expected.
* <p>
* Time complexity: O(1)
* @param key the key to increment
* @param increment the value to increment by
* @return The value of the key after the increment
*
* Redis Incrbyfloat 命令为 key 中所储存的值加上指定的浮点数增量值。
* 如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作。
*/
double incrByFloat(String key, double increment);
/**
* <b><a href="http://redis.io/commands/decr">Decr Command</a></b>
* Decrement the number stored at key by one. If the key does not exist or contains a value of a
* wrong type, set the key to the value of "0" before to perform the decrement operation.
* <p>
* DECR commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to decrement
* @return The value of the key after the decrement
*
* Redis Decr 命令将 key 中储存的数字值减一。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long decr(String key);
/**
* <b><a href="http://redis.io/commands/decrby">DecrBy Command</a></b>
* DECRBY work just like {@link StringCommands#decr(String) DECR} but instead to decrement by 1 the
* decrement is integer.
* <p>
* DECRBY commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to decrement
* @param decrement the value to decrement by
* @return The value of the key after the decrement
*
* Redis Decr 命令将 key 中储存的数字值减 decrement。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long decrBy(String key, long decrement);
/**
* <b><a href="http://redis.io/commands/append">Append Command</a></b>
* If the key already exists and is a string, this command appends the provided value at the end
* of the string. If the key does not exist it is created and set as an empty string, so APPEND
* will be very similar to SET in this special case.
* <p>
* Time complexity: O(1). The amortized time complexity is O(1) assuming the appended value is
* small and the already present value is of any size, since the dynamic string library used by
* Redis will double the free space available on every reallocation.
* @param key the key to append to
* @param value the value to append
* @return The total length of the string after the append operation.
*
* Redis Append 命令用于为指定的 key 追加值。
* 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
* 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
*/
long append(String key, String value);
/**
* <b><a href="http://redis.io/commands/substr">SubStr Command</a></b>
* Return a subset of the string from offset start to offset end (both offsets are inclusive).
* Negative offsets can be used in order to provide an offset starting from the end of the string.
* So -1 means the last char, -2 the penultimate and so forth.
* <p>
* The function handles out of range requests without raising an error, but just limiting the
* resulting range to the actual length of the string.
* <p>
* Time complexity: O(start+n) (with start being the start index and n the total length of the
* requested range). Note that the lookup part of this command is O(1) so for small strings this
* is actually an O(1) command.
* @param key
* @param start
* @param end
* @return The substring
*
* 截取字符串的值
*/
String substr(String key, int start, int end);
/**
* <b><a href="http://redis.io/commands/strlen">StrLen Command</a></b>
* Return the length of the string value stored at key.
* @param key
* @return The length of the string at key, or 0 when key does not exist
*
* 返回值的长度
*/
long strlen(String key);
/**
* <b><a href="http://redis.io/commands/bitcount">Bitcount Command</a></b>
* Count the number of set bits (population counting) in a string.
* @param key
* @return The number of bits set to 1
*
* 返回 值 bit 的数量
*/
long bitcount(String key);
/**
* <b><a href="http://redis.io/commands/bitcount">Bitcount Command</a></b>
* Count the number of set bits (population counting) in a string only in an interval start and end.
* <p>
* Like for the GETRANGE command start and end can contain negative values in order to index bytes
* starting from the end of the string, where -1 is the last byte, -2 is the penultimate, and so forth.
* @param key
* @param start byte start index
* @param end byte end index
* @return The number of bits set to 1
*
* start 至 end 中间的字节数量
*/
long bitcount(String key, long start, long end);
/**
* @see StringCommands#bitcount(String, long, long)
* @param key
* @param start byte start index
* @param end byte end index
* @param option indicate BYTE or BIT
* @return The number of bits set to 1
*
* start 至 end 中间的字节数量
*/
long bitcount(String key, long start, long end, BitCountOption option);
/**
* <b><a href="http://redis.io/commands/bitpos">Bitpos Command</a></b>
* Return the position of the first bit set to 1 or 0 in a string.
* @param key
* @param value the bit value
* @return The position of the first bit set to 1 or 0 according to the request
*
* 第一次出现 value 的位置
*/
long bitpos(String key, boolean value);
/**
* <b><a href="http://redis.io/commands/bitpos">Bitpos Command</a></b>
* Return the position of the first bit set to 1 or 0 in a string.
* @param key
* @param value the bit value
* @param params {@link BitPosParams}
* @return The position of the first bit set to 1 or 0 according to the request
*
* 第一次出现 value 的位置
*/
long bitpos(String key, boolean value, BitPosParams params);
/**
* <b><a href="http://redis.io/commands/bitfield">Bitfield Command</a></b>
* The command treats a Redis string as an array of bits, and is capable of addressing specific integer
* fields of varying bit widths and arbitrary non (necessary) aligned offset.
* @param key
* @param arguments may be used with optional arguments
* @return A List of results
*/
List<Long> bitfield(String key, String...arguments);
/**
* The readonly version of {@link StringCommands#bitfield(String, String...) BITFIELD}
*/
List<Long> bitfieldReadonly(String key, String...arguments);
/**
* <b><a href="http://redis.io/commands/bitop">Bitop Command</a></b>
* Perform a bitwise operation between multiple keys (containing string values) and store the result in the destKey.
* @param op can be AND, OR, XOR or NOT
* @param destKey
* @param srcKeys
* @return The size of the string stored in the destKey
*/
long bitop(BitOP op, String destKey, String... srcKeys);
/**
* Calculate the longest common subsequence of keyA and keyB.
* @deprecated STRALGO LCS command will be removed from Redis 7.
* {@link StringCommands#lcs(String, String, LCSParams) LCS} can be used instead of this method.
* @param keyA
* @param keyB
* @param params
* @return According to StrAlgoLCSParams to decide to return content to fill LCSMatchResult.
*/
@Deprecated
LCSMatchResult strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params);
/**
* Calculate the longest common subsequence of keyA and keyB.
* @param keyA
* @param keyB
* @param params
* @return According to LCSParams to decide to return content to fill LCSMatchResult.
*/
LCSMatchResult lcs(String keyA, String keyB, LCSParams params);
}
package redis.clients.jedis.commands;
import java.util.List;
import redis.clients.jedis.args.BitCountOption;
import redis.clients.jedis.args.BitOP;
import redis.clients.jedis.params.BitPosParams;
import redis.clients.jedis.params.GetExParams;
import redis.clients.jedis.params.SetParams;
import redis.clients.jedis.params.StrAlgoLCSParams;
import redis.clients.jedis.params.LCSParams;
import redis.clients.jedis.resps.LCSMatchResult;
public interface StringCommands {
/**
* <b><a href="http://redis.io/commands/set">Set Command</a></b>
* Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 GB).
* <p>
* Time complexity: O(1)
* @param key
* @param value
* @return OK
*/
String set(String key, String value);
/**
* <b><a href="http://redis.io/commands/set">Set Command</a></b>
* Set the string value as value of the key. Can be used with optional params.
* <p>
* Time complexity: O(1)<
* @param key
* @param value
* @param params {@link SetParams}
* @return OK
*/
String set(String key, String value, SetParams params);
/**
* <b><a href="http://redis.io/commands/get">Get Command</a></b>
* Get the value of the specified key. If the key does not exist the special value 'nil' is
* returned. If the value stored at key is not a string an error is returned because GET can only
* handle string values.
* <p>
* Time complexity: O(1)
* @param key
* @return The value stored in key
*/
String get(String key);
/**
* <b><a href="http://redis.io/commands/getdel">GetDel Command</a></b>
* Get the value of key and delete the key. This command is similar to GET, except for the fact
* that it also deletes the key on success (if and only if the key's value type is a string).
* <p>
* Time complexity: O(1)
* @param key
* @return The value of key
*
* 获取并删除
*/
String getDel(String key);
/**
* <b><a href="http://redis.io/commands/getex">GetEx Command</a></b>
* Get the value of key and optionally set its expiration. GETEX is similar to {@link StringCommands#get(String) GET},
* but is a write command with additional options:
* EX seconds -- Set the specified expire time, in seconds.
* PX milliseconds -- Set the specified expire time, in milliseconds.
* EXAT timestamp-seconds -- Set the specified Unix time at which the key will expire, in seconds.
* PXAT timestamp-milliseconds -- Set the specified Unix time at which the key will expire, in milliseconds.
* PERSIST -- Remove the time to live associated with the key.
* <p>
* Time complexity: O(1)
* @param key
* @param params {@link GetExParams}
* @return The original bit value stored at offset
*
* 获取 并设置 key的过期时间
*/
String getEx(String key, GetExParams params);
/**
* <b><a href="http://redis.io/commands/setbit">SetBit Command</a></b>
* Sets or clears the bit at offset in the string value stored at key.
* <p>
* Time complexity: O(1)
* @param key
* @param offset
* @param value
* @return The original bit value stored at offset
*
* 设置 key 存储的 string offset 位上的 值 （value） 设置的是 位 bit
*/
boolean setbit(String key, long offset, boolean value);
/**
* <b><a href="http://redis.io/commands/getbit">GetBit Command</a></b>
* Returns the bit value at offset in the string value stored at key.
* <p>
* Time complexity: O(1)
* @param key
* @param offset
* @return The bit value stored at offset
*
* 获取 key 存储的 string offset 位上的 值
*/
boolean getbit(String key, long offset);
/**
* <b><a href="http://redis.io/commands/setrange">SetRange Command</a></b>
* GETRANGE overwrite part of the string stored at key, starting at the specified offset, for the entire
* length of value. If the offset is larger than the current length of the string at key, the string is
* padded with zero-bytes to make offset fit. Non-existing keys are considered as empty strings, so this
* command will make sure it holds a string large enough to be able to set value at offset.
* <p>
* Time complexity: O(1)
* @param key
* @param offset
* @param value
* @return The length of the string after it was modified by the command
*
* 命令用指定的字符串覆盖给定 key 所储存的字符串值，覆盖的位置从偏移量 offset 开始。
*/
long setrange(String key, long offset, String value);
/**
* <b><a href="http://redis.io/commands/getrange">GetRange Command</a></b>
* Return the substring of the string value stored at key, determined by the offsets start
* and end (both are inclusive). Negative offsets can be used in order to provide an offset starting
* from the end of the string. So -1 means the last character, -2 the penultimate and so forth.
* <p>
* Time complexity: O(N) where N is the length of the returned string
* @param key
* @param startOffset
* @param endOffset
* @return The substring
*
* 令用于获取存储在指定 key 中字符串的子字符串。字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)
*/
String getrange(String key, long startOffset, long endOffset);
/**
* <b><a href="http://redis.io/commands/getset">GetSet Command</a></b>
* GETSET is an atomic set this value and return the old value command. Set key to the string
* value and return the old value stored at key. The string can't be longer than 1073741824 byte (1 GB).
* <p>
* Time complexity: O(1)
* @param key
* @param value
* @return The old value that was stored in key
*
* 获取 并且设置值
*/
String getSet(String key, String value);
/**
* <b><a href="http://redis.io/commands/setnx">SetNE Command</a></b>
* SETNX works exactly like {@link StringCommands#set(String, String) SET} with the only difference that if
* the key already exists no operation is performed. SETNX actually means "SET if Not Exists".
* <p>
* Time complexity: O(1)
* @param key
* @param value
* @return 1 if the key was set, 0 otherwise
*
* 不存在时则设置
*/
long setnx(String key, String value);
/**
* <b><a href="http://redis.io/commands/setex">SetEx Command</a></b>
* The command is exactly equivalent to the following group of commands:
* {@link StringCommands#set(String, String) SET} + {@link KeyBinaryCommands#expire(byte[], long) EXPIRE}.
* The operation is atomic.
* <p>
* Time complexity: O(1)
* @param key
* @param seconds
* @param value
* @return OK
*
* 设置设置 key的value 并设置过期时间，如果存在则替换旧的值
*/
String setex(String key, long seconds, String value);
/**
* <b><a href="http://redis.io/commands/psetex">PSetEx Command</a></b>
* PSETEX works exactly like {@link StringCommands#setex(String, long, String) SETEX} with the sole difference
* that the expire time is specified in milliseconds instead of seconds.
* <p>
* Time complexity: O(1)
* @param key
* @param milliseconds
* @param value
* @return OK
*
* 设置设置 key的value 并设置过期时间（毫秒），如果存在则替换旧的值
*/
String psetex(String key, long milliseconds, String value);
/**
* <b><a href="http://redis.io/commands/mget">MGet Command</a></b>
* Get the values of all the specified keys. If one or more keys don't exist or is not of type
* String, a 'nil' value is returned instead of the value of the specified key, but the operation
* never fails.
* <p>
* Time complexity: O(1) for every key
* @param keys
* @return Multi bulk reply
*
* t 命令返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil
*/
List<String> mget(String... keys);
/**
* <b><a href="http://redis.io/commands/mset">MSet Command</a></b>
* Set the the respective keys to the respective values. MSET will replace old values with new
* values, while {@link StringCommands#msetnx(String...) MSETNX} will not perform any operation at all even
* if just a single key already exists.
* <p>
* Because of this semantic MSETNX can be used in order to set different keys representing
* different fields of an unique logic object in a way that ensures that either all the fields or
* none at all are set.
* <p>
* Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B
* are modified, another connection talking to Redis can either see the changes to both A and B at
* once, or no modification at all.
* @param keysvalues pairs of keys and their values
* e.g mset("foo", "foovalue", "bar", "barvalue")
* @return OK
*
* Redis Mset 命令用于同时设置一个或多个 key-value 对。 MSET key1 value1 key2 value2 .. keyN valueN
*/
String mset(String... keysvalues);
/**
* <b><a href="http://redis.io/commands/msetnx">MSetNX Command</a></b>
* Set the respective keys to the respective values. {@link StringCommands#mset(String...) MSET} will
* replace old values with new values, while MSETNX will not perform any operation at all even if
* just a single key already exists.
* <p>
* Because of this semantic MSETNX can be used in order to set different keys representing
* different fields of an unique logic object in a way that ensures that either all the fields or
* none at all are set.
* <p>
* Both MSET and MSETNX are atomic operations. This means that for instance if the keys A and B
* are modified, another connection talking to Redis can either see the changes to both A and B at
* once, or no modification at all.
* @param keysvalues pairs of keys and their values
* e.g msetnx("foo", "foovalue", "bar", "barvalue")
* @return 1 if the all the keys were set, 0 if no key was set (at least one key already existed)
*
* Redis Msetnx 命令用于所有给定 key 都不存在时，同时设置一个或多个 key-value 对。
* 当所有 key 都成功设置，返回 1 。 如果所有给定 key 都设置失败(至少有一个 key 已经存在)，那么返回 0 。
*/
long msetnx(String... keysvalues);
/**
* <b><a href="http://redis.io/commands/incr">Incr Command</a></b>
* Increment the number stored at key by one. If the key does not exist or contains a value of a
* wrong type, set the key to the value of "0" before to perform the increment operation.
* <p>
* INCR commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to increment
* @return The value of the key after the increment
*
* Redis Incr 命令将 key 中储存的数字值增一。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long incr(String key);
/**
* <b><a href="http://redis.io/commands/incrby">IncrBy Command</a></b>
* INCRBY work just like {@link StringCommands#incr(String) INCR} but instead to increment by 1 the
* increment is integer.
* <p>
* INCR commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to increment
* @param increment the value to increment by
* @return The value of the key after the increment
*
* Redis Incr 命令将 key 中储存的数字值增 increment。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long incrBy(String key, long increment);
/**
* <b><a href="http://redis.io/commands/incrbyfloat">IncrByFloat Command</a></b>
* INCRBYFLOAT work just like {@link StringCommands#incrBy(String, long)} INCRBY} but increments by floats
* instead of integers.
* <p>
* INCRBYFLOAT commands are limited to double precision floating point values.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "double" types.
* Simply the string stored at the key is parsed as a base double precision floating point value,
* incremented, and then converted back as a string. There is no DECRYBYFLOAT but providing a
* negative value will work as expected.
* <p>
* Time complexity: O(1)
* @param key the key to increment
* @param increment the value to increment by
* @return The value of the key after the increment
*
* Redis Incrbyfloat 命令为 key 中所储存的值加上指定的浮点数增量值。
* 如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作。
*/
double incrByFloat(String key, double increment);
/**
* <b><a href="http://redis.io/commands/decr">Decr Command</a></b>
* Decrement the number stored at key by one. If the key does not exist or contains a value of a
* wrong type, set the key to the value of "0" before to perform the decrement operation.
* <p>
* DECR commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to decrement
* @return The value of the key after the decrement
*
* Redis Decr 命令将 key 中储存的数字值减一。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long decr(String key);
/**
* <b><a href="http://redis.io/commands/decrby">DecrBy Command</a></b>
* DECRBY work just like {@link StringCommands#decr(String) DECR} but instead to decrement by 1 the
* decrement is integer.
* <p>
* DECRBY commands are limited to 64 bit signed integers.
* <p>
* Note: this is actually a string operation, that is, in Redis there are not "integer" types.
* Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented,
* and then converted back as a string.
* <p>
* Time complexity: O(1)
* @param key the key to decrement
* @param decrement the value to decrement by
* @return The value of the key after the decrement
*
* Redis Decr 命令将 key 中储存的数字值减 decrement。
* 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
*/
long decrBy(String key, long decrement);
/**
* <b><a href="http://redis.io/commands/append">Append Command</a></b>
* If the key already exists and is a string, this command appends the provided value at the end
* of the string. If the key does not exist it is created and set as an empty string, so APPEND
* will be very similar to SET in this special case.
* <p>
* Time complexity: O(1). The amortized time complexity is O(1) assuming the appended value is
* small and the already present value is of any size, since the dynamic string library used by
* Redis will double the free space available on every reallocation.
* @param key the key to append to
* @param value the value to append
* @return The total length of the string after the append operation.
*
* Redis Append 命令用于为指定的 key 追加值。
* 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
* 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
*/
long append(String key, String value);
/**
* <b><a href="http://redis.io/commands/substr">SubStr Command</a></b>
* Return a subset of the string from offset start to offset end (both offsets are inclusive).
* Negative offsets can be used in order to provide an offset starting from the end of the string.
* So -1 means the last char, -2 the penultimate and so forth.
* <p>
* The function handles out of range requests without raising an error, but just limiting the
* resulting range to the actual length of the string.
* <p>
* Time complexity: O(start+n) (with start being the start index and n the total length of the
* requested range). Note that the lookup part of this command is O(1) so for small strings this
* is actually an O(1) command.
* @param key
* @param start
* @param end
* @return The substring
*
* 截取字符串的值
*/
String substr(String key, int start, int end);
/**
* <b><a href="http://redis.io/commands/strlen">StrLen Command</a></b>
* Return the length of the string value stored at key.
* @param key
* @return The length of the string at key, or 0 when key does not exist
*
* 返回值的长度
*/
long strlen(String key);
/**
* <b><a href="http://redis.io/commands/bitcount">Bitcount Command</a></b>
* Count the number of set bits (population counting) in a string.
* @param key
* @return The number of bits set to 1
*
* 返回 值 bit 的数量
*/
long bitcount(String key);
/**
* <b><a href="http://redis.io/commands/bitcount">Bitcount Command</a></b>
* Count the number of set bits (population counting) in a string only in an interval start and end.
* <p>
* Like for the GETRANGE command start and end can contain negative values in order to index bytes
* starting from the end of the string, where -1 is the last byte, -2 is the penultimate, and so forth.
* @param key
* @param start byte start index
* @param end byte end index
* @return The number of bits set to 1
*
* start 至 end 中间的字节数量
*/
long bitcount(String key, long start, long end);
/**
* @see StringCommands#bitcount(String, long, long)
* @param key
* @param start byte start index
* @param end byte end index
* @param option indicate BYTE or BIT
* @return The number of bits set to 1
*
* start 至 end 中间的字节数量
*/
long bitcount(String key, long start, long end, BitCountOption option);
/**
* <b><a href="http://redis.io/commands/bitpos">Bitpos Command</a></b>
* Return the position of the first bit set to 1 or 0 in a string.
* @param key
* @param value the bit value
* @return The position of the first bit set to 1 or 0 according to the request
*
* 第一次出现 value 的位置
*/
long bitpos(String key, boolean value);
/**
* <b><a href="http://redis.io/commands/bitpos">Bitpos Command</a></b>
* Return the position of the first bit set to 1 or 0 in a string.
* @param key
* @param value the bit value
* @param params {@link BitPosParams}
* @return The position of the first bit set to 1 or 0 according to the request
*
* 第一次出现 value 的位置
*/
long bitpos(String key, boolean value, BitPosParams params);
/**
* <b><a href="http://redis.io/commands/bitfield">Bitfield Command</a></b>
* The command treats a Redis string as an array of bits, and is capable of addressing specific integer
* fields of varying bit widths and arbitrary non (necessary) aligned offset.
* @param key
* @param arguments may be used with optional arguments
* @return A List of results
*/
List<Long> bitfield(String key, String...arguments);
/**
* The readonly version of {@link StringCommands#bitfield(String, String...) BITFIELD}
*/
List<Long> bitfieldReadonly(String key, String...arguments);
/**
* <b><a href="http://redis.io/commands/bitop">Bitop Command</a></b>
* Perform a bitwise operation between multiple keys (containing string values) and store the result in the destKey.
* @param op can be AND, OR, XOR or NOT
* @param destKey
* @param srcKeys
* @return The size of the string stored in the destKey
*/
long bitop(BitOP op, String destKey, String... srcKeys);
/**
* Calculate the longest common subsequence of keyA and keyB.
* @deprecated STRALGO LCS command will be removed from Redis 7.
* {@link StringCommands#lcs(String, String, LCSParams) LCS} can be used instead of this method.
* @param keyA
* @param keyB
* @param params
* @return According to StrAlgoLCSParams to decide to return content to fill LCSMatchResult.
*/
@Deprecated
LCSMatchResult strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params);
/**
* Calculate the longest common subsequence of keyA and keyB.
* @param keyA
* @param keyB
* @param params
* @return According to LCSParams to decide to return content to fill LCSMatchResult.
*/
LCSMatchResult lcs(String keyA, String keyB, LCSParams params);
}
标签：return,String,Redis,value,命令,param,key,StringCommands,string 来源： https://www.cnblogs.com/dbqjava/p/16641110.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。