github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

RStream deprecated methods removed

Browse Source
pull/5644/head
Nikita Koksharov 12 months ago
parent 030c17a219
commit 69f7ce2eed
6 changed files with 52 additions and 2129 deletions
Show Stats Download Patch File Download Diff File

631
redisson/src/main/java/org/redisson/RedissonStream.java
Unescape Escape View File

@ -82,26 +82,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP, params.toArray());
}
@Override
public void createGroup(String groupName) {
get(createGroupAsync(groupName));
}
@Override
public RFuture<Void> createGroupAsync(String groupName) {
return createGroupAsync(groupName, StreamMessageId.NEWEST);
}
@Override
public void createGroup(String groupName, StreamMessageId id) {
get(createGroupAsync(groupName, id));
}
@Override
public RFuture<Void> createGroupAsync(String groupName, StreamMessageId id) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP, "CREATE", getRawName(), groupName, id, "MKSTREAM");
}
@Override
public RFuture<Long> ackAsync(String groupName, StreamMessageId... ids) {
List<Object> params = new ArrayList<Object>();
@ -343,290 +323,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return get(claimAsync(groupName, consumerName, idleTime, idleTimeUnit, ids));
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, StreamMessageId... ids) {
return readGroupAsync(groupName, consumerName, 0, ids);
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId... ids) {
return readGroupAsync(groupName, consumerName, count, 0, null, ids);
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit,
StreamMessageId... ids) {
return readGroupAsync(groupName, consumerName, 0, timeout, unit, ids);
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit,
StreamMessageId... ids) {
List<Object> params = new ArrayList<Object>();
params.add("GROUP");
params.add(groupName);
params.add(consumerName);
if (count > 0) {
params.add("COUNT");
params.add(count);
}
if (timeout > 0) {
params.add("BLOCK");
params.add(unit.toMillis(timeout));
}
params.add("STREAMS");
params.add(getRawName());
if (ids.length == 0) {
params.add(">");
}
for (StreamMessageId id : ids) {
params.add(id.toString());
}
if (timeout > 0) {
return commandExecutor.writeAsync(getRawName(), codec, getServiceManager().getXReadGroupBlockingSingleCommand(), params.toArray());
}
return commandExecutor.writeAsync(getRawName(), codec, getServiceManager().getXReadGroupSingleCommand(), params.toArray());
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readGroup(groupName, consumerName, 0, id, keyToId);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readGroupAsync(groupName, consumerName, 0, id, keyToId);
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return get(readGroupAsync(groupName, consumerName, count, id, keyToId));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readGroupAsync(groupName, consumerName, count, -1, null, id, keyToId);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2) {
return readGroupAsync(groupName, consumerName, count, timeout, unit, id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readGroupAsync(groupName, consumerName, count, timeout, unit, id, params);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readGroupAsync(groupName, consumerName, 0, timeout, unit, id, keyToId);
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return get(readGroupAsync(groupName, consumerName, count, timeout, unit, id, keyToId));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readGroup(groupName, consumerName, 0, timeout, unit, id, keyToId);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2) {
return readGroupAsync(groupName, consumerName, id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readGroupAsync(groupName, consumerName, id, params);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2) {
return readGroupAsync(groupName, consumerName, count, id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2,
String key3, StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readGroupAsync(groupName, consumerName, count, id, params);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2) {
return readGroupAsync(groupName, consumerName, timeout, unit, id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readGroupAsync(groupName, consumerName, timeout, unit, id, params);
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2) {
return get(readGroupAsync(groupName, consumerName, id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3) {
return get(readGroupAsync(groupName, consumerName, id, key2, id2, key3, id3));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2) {
return get(readGroupAsync(groupName, consumerName, count, id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3) {
return get(readGroupAsync(groupName, consumerName, count, id, key2, id2, key3, id3));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2) {
return get(readGroupAsync(groupName, consumerName, timeout, unit, id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2, String key3, StreamMessageId id3) {
return get(readGroupAsync(groupName, consumerName, timeout, unit, id, key2, id2, key3, id3));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2) {
return get(readGroupAsync(groupName, consumerName, count, timeout, unit, id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2, String key3, StreamMessageId id3) {
return get(readGroupAsync(groupName, consumerName, count, timeout, unit, id, key2, id2, key3, id3));
}
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit,
StreamMessageId id, Map<String, StreamMessageId> keyToId) {
List<Object> params = new ArrayList<Object>();
params.add("GROUP");
params.add(groupName);
params.add(consumerName);
if (count > 0) {
params.add("COUNT");
params.add(count);
}
if (timeout > 0) {
params.add("BLOCK");
params.add(unit.toMillis(timeout));
}
params.add("STREAMS");
params.add(getRawName());
params.addAll(keyToId.keySet());
if (id == null) {
params.add(">");
} else {
params.add(id);
}
for (StreamMessageId nextId : keyToId.values()) {
params.add(nextId.toString());
}
if (timeout > 0) {
return commandExecutor.writeAsync(getRawName(), codec, getServiceManager().getXReadGroupBlockingCommand(), params.toArray());
}
return commandExecutor.writeAsync(getRawName(), codec, getServiceManager().getXReadGroupCommand(), params.toArray());
}
@Override
public Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, StreamMessageId... ids) {
return get(readGroupAsync(groupName, consumerName, ids));
}
@Override
public Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, int count, StreamMessageId... ids) {
return get(readGroupAsync(groupName, consumerName, count, ids));
}
@Override
public Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId... ids) {
return get(readGroupAsync(groupName, consumerName, timeout, unit, ids));
}
@Override
public Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit,
StreamMessageId... ids) {
return get(readGroupAsync(groupName, consumerName, count, timeout, unit, ids));
}
@Override
public StreamMessageId addAll(Map<K, V> entries) {
return addAll(entries, 0, false);
}
@Override
public RFuture<StreamMessageId> addAllAsync(Map<K, V> entries) {
return addAllAsync(entries, 0, false);
}
@Override
public void addAll(StreamMessageId id, Map<K, V> entries) {
addAll(id, entries, 0, false);
}
@Override
public RFuture<Void> addAllAsync(StreamMessageId id, Map<K, V> entries) {
return addAllAsync(id, entries, 0, false);
}
@Override
public StreamMessageId addAll(Map<K, V> entries, int trimLen, boolean trimStrict) {
return get(addAllAsync(entries, trimLen, trimStrict));
}
@Override
public RFuture<StreamMessageId> addAllAsync(Map<K, V> entries, int trimLen, boolean trimStrict) {
return addAllCustomAsync(null, entries, trimLen, trimStrict);
}
@Override
public void addAll(StreamMessageId id, Map<K, V> entries, int trimLen, boolean trimStrict) {
get(addAllAsync(id, entries, trimLen, trimStrict));
}
private <R> RFuture<R> addAllCustomAsync(StreamMessageId id, Map<K, V> entries, int trimLen, boolean trimStrict) {
List<Object> params = new ArrayList<Object>(entries.size()*2 + 1);
params.add(getRawName());
@ -659,11 +355,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD_VOID, params.toArray());
}
@Override
public RFuture<Void> addAllAsync(StreamMessageId id, Map<K, V> entries, int trimLen, boolean trimStrict) {
return addAllCustomAsync(id, entries, trimLen, trimStrict);
}
@Override
public long size() {
return get(sizeAsync());
@ -739,173 +430,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return commandExecutor.readAsync(getRawName(), codec, getServiceManager().getXReadSingleCommand(), params.toArray());
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return read(0, id, keyToId);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readAsync(0, id, keyToId);
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return get(readAsync(count, id, keyToId));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readAsync(count, -1, null, id, keyToId);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2) {
return readAsync(count, timeout, unit, id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readAsync(count, timeout, unit, id, params);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return readAsync(0, timeout, unit, id, keyToId);
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return get(readAsync(count, timeout, unit, id, keyToId));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
return read(0, timeout, unit, id, keyToId);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(StreamMessageId id, String key2, StreamMessageId id2) {
return readAsync(id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readAsync(id, params);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, StreamMessageId id, String key2, StreamMessageId id2) {
return readAsync(count, id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, StreamMessageId id, String key2, StreamMessageId id2,
String key3, StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readAsync(count, id, params);
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2) {
return readAsync(timeout, unit, id, Collections.singletonMap(key2, id2));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3) {
Map<String, StreamMessageId> params = new HashMap<String, StreamMessageId>(2);
params.put(key2, id2);
params.put(key3, id3);
return readAsync(timeout, unit, id, params);
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(StreamMessageId id, String key2, StreamMessageId id2) {
return get(readAsync(id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3) {
return get(readAsync(id, key2, id2, key3, id3));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId id, String key2, StreamMessageId id2) {
return get(readAsync(count, id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3) {
return get(readAsync(count, id, key2, id2, key3, id3));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2) {
return get(readAsync(timeout, unit, id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2, String key3, StreamMessageId id3) {
return get(readAsync(timeout, unit, id, key2, id2, key3, id3));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2) {
return get(readAsync(count, timeout, unit, id, key2, id2));
}
@Override
public Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2, String key3, StreamMessageId id3) {
return get(readAsync(count, timeout, unit, id, key2, id2, key3, id3));
}
@Override
public RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> keyToId) {
List<Object> params = new ArrayList<Object>();
if (count > 0) {
params.add("COUNT");
params.add(count);
}
if (timeout > 0) {
params.add("BLOCK");
params.add(unit.toMillis(timeout));
}
params.add("STREAMS");
params.add(getRawName());
params.addAll(keyToId.keySet());
params.add(id);
for (StreamMessageId nextId : keyToId.values()) {
params.add(nextId.toString());
}
if (timeout > 0) {
return commandExecutor.readAsync(getRawName(), codec, getServiceManager().getXReadBlockingCommand(), params.toArray());
}
return commandExecutor.readAsync(getRawName(), codec, getServiceManager().getXReadCommand(), params.toArray());
}
@Override
public StreamMessageId add(StreamAddArgs<K, V> args) {
return get(addAsync(args));
@ -976,21 +500,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD_VOID, params.toArray());
}
@Override
public RFuture<StreamMessageId> addAsync(K key, V value) {
return addAsync(key, value, 0, false);
}
@Override
public RFuture<Void> addAsync(StreamMessageId id, K key, V value) {
return addAsync(id, key, value, 0, false);
}
@Override
public RFuture<StreamMessageId> addAsync(K key, V value, int trimLen, boolean trimStrict) {
return addCustomAsync(null, key, value, trimLen, trimStrict);
}
private <R> RFuture<R> addCustomAsync(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict) {
List<Object> params = new LinkedList<Object>();
params.add(getRawName());
@ -1021,73 +530,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD_VOID, params.toArray());
}
@Override
public RFuture<Void> addAsync(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict) {
return addCustomAsync(id, key, value, trimLen, trimStrict);
}
@Override
public StreamMessageId add(K key, V value) {
return get(addAsync(key, value));
}
@Override
public void add(StreamMessageId id, K key, V value) {
get(addAsync(id, key, value));
}
@Override
public StreamMessageId add(K key, V value, int trimLen, boolean trimStrict) {
return get(addAsync(key, value, trimLen, trimStrict));
}
@Override
public void add(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict) {
get(addAsync(id, key, value, trimLen, trimStrict));
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(int count, StreamMessageId... ids) {
return readAsync(count, 0, null, ids);
}
@Override
public Map<StreamMessageId, Map<K, V>> read(int count, long timeout, TimeUnit unit, StreamMessageId... ids) {
return get(readAsync(count, timeout, unit, ids));
}
@Override
public Map<StreamMessageId, Map<K, V>> read(int count, StreamMessageId... ids) {
return get(readAsync(count, ids));
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(int count, long timeout, TimeUnit unit,
StreamMessageId... ids) {
List<Object> params = new ArrayList<Object>();
if (count > 0) {
params.add("COUNT");
params.add(count);
}
if (timeout > 0) {
params.add("BLOCK");
params.add(unit.toMillis(timeout));
}
params.add("STREAMS");
params.add(getRawName());
for (StreamMessageId id : ids) {
params.add(id.toString());
}
if (timeout > 0) {
return commandExecutor.readAsync(getRawName(), codec, getServiceManager().getXReadBlockingSingleCommand(), params.toArray());
}
return commandExecutor.readAsync(getRawName(), codec, getServiceManager().getXReadSingleCommand(), params.toArray());
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> rangeAsync(int count, StreamMessageId startId, StreamMessageId endId) {
List<Object> params = new LinkedList<Object>();
@ -1128,16 +570,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return get(rangeReversedAsync(count, startId, endId));
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(StreamMessageId... ids) {
return readAsync(0, ids);
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(long timeout, TimeUnit unit, StreamMessageId... ids) {
return readAsync(0, timeout, unit, ids);
}
@Override
public RFuture<Map<StreamMessageId, Map<K, V>>> rangeAsync(StreamMessageId startId, StreamMessageId endId) {
return rangeAsync(0, startId, endId);
@ -1148,16 +580,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return rangeReversedAsync(0, startId, endId);
}
@Override
public Map<StreamMessageId, Map<K, V>> read(StreamMessageId... ids) {
return read(0, ids);
}
@Override
public Map<StreamMessageId, Map<K, V>> read(long timeout, TimeUnit unit, StreamMessageId... ids) {
return read(0, timeout, unit, ids);
}
@Override
public Map<StreamMessageId, Map<K, V>> range(StreamMessageId startId, StreamMessageId endId) {
return range(0, startId, endId);
@ -1182,59 +604,6 @@ public class RedissonStream<K, V> extends RedissonExpirable implements RStream<K
return get(removeAsync(ids));
}
@Override
public long trim(TrimStrategy strategy, int threshold) {
return get(trimAsync(strategy, threshold));
}
@Override
public long trimNonStrict(TrimStrategy strategy, int threshold, int limit) {
return get(trimNonStrictAsync(strategy, threshold, limit));
}
@Override
public RFuture<Long> trimAsync(TrimStrategy strategy, int threshold) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XTRIM,
getRawName(), strategy.toString(), threshold);
}
@Override
public RFuture<Long> trimNonStrictAsync(TrimStrategy strategy, int threshold, int limit) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XTRIM,
getRawName(), strategy.toString(), "~", threshold, "LIMIT", limit);
}
@Override
public long trimNonStrict(TrimStrategy strategy, int threshold) {
return get(trimNonStrictAsync(strategy, threshold));
}
@Override
public RFuture<Long> trimNonStrictAsync(TrimStrategy strategy, int threshold) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XTRIM,
getRawName(), strategy.toString(), "~", threshold);
}
@Override
public RFuture<Long> trimAsync(int count) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XTRIM, getRawName(), "MAXLEN", count);
}
@Override
public RFuture<Long> trimNonStrictAsync(int count) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XTRIM, getRawName(), "MAXLEN", "~", count);
}
@Override
public long trim(int count) {
return get(trimAsync(count));
}
@Override
public long trimNonStrict(int count) {
return get(trimNonStrictAsync(count));
}
@Override
public RFuture<Void> removeGroupAsync(String groupName) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP, "DESTROY", getRawName(), groupName);

337
redisson/src/main/java/org/redisson/api/RStream.java
Unescape Escape View File

@ -45,18 +45,6 @@ public interface RStream<K, V> extends RStreamAsync<K, V>, RExpirable {
*/
void createGroup(StreamCreateGroupArgs args);
/**
* Use createGroup(StreamCreateGroupArgs) method instead
*/
@Deprecated
void createGroup(String groupName);
/**
* Use createGroup(StreamCreateGroupArgs) method instead
*/
@Deprecated
void createGroup(String groupName, StreamMessageId id);
/**
* Removes group by name.
*
@ -352,124 +340,6 @@ public interface RStream<K, V> extends RStreamAsync<K, V>, RExpirable {
*/
Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, StreamReadGroupArgs args);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, int count, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2, String key3, StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2,
StreamMessageId id2, String key3, StreamMessageId id3);
/**
* Returns number of entries in stream
*
@ -511,62 +381,6 @@ public interface RStream<K, V> extends RStreamAsync<K, V>, RExpirable {
*/
void add(StreamMessageId id, StreamAddArgs<K, V> args);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
StreamMessageId add(K key, V value);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
void add(StreamMessageId id, K key, V value);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
StreamMessageId add(K key, V value, int trimLen, boolean trimStrict);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
void add(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
StreamMessageId addAll(Map<K, V> entries);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
void addAll(StreamMessageId id, Map<K, V> entries);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
StreamMessageId addAll(Map<K, V> entries, int trimLen, boolean trimStrict);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
void addAll(StreamMessageId id, Map<K, V> entries, int trimLen, boolean trimStrict);
/**
* Read stream data from multiple streams including current.
* <p>
@ -603,118 +417,6 @@ public interface RStream<K, V> extends RStreamAsync<K, V>, RExpirable {
*/
Map<StreamMessageId, Map<K, V>> read(StreamReadArgs args);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> read(StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> read(int count, StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> read(long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Map<StreamMessageId, Map<K, V>> read(int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Map<String, Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/**
* Returns stream data in range by specified start Stream Message ID (included) and end Stream Message ID (included).
*
@ -787,45 +489,6 @@ public interface RStream<K, V> extends RStreamAsync<K, V>, RExpirable {
*/
long trimNonStrict(StreamTrimArgs args);
/*
* Use trim(StreamTrimArgs) method instead
*
*/
@Deprecated
long trim(int size);
/*
* Use trim(StreamTrimArgs) method instead
*
*/
@Deprecated
long trim(TrimStrategy strategy, int threshold);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
long trimNonStrict(int size);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
long trimNonStrict(TrimStrategy strategy, int threshold);
/**
* Trims stream using almost exact trimming threshold up to limit.
*
* @param strategy - trim strategy
* @param threshold - trim threshold
* @param limit - trim limit
* @return number of deleted messages
*/
@Deprecated
long trimNonStrict(TrimStrategy strategy, int threshold, int limit);
/**
* Returns information about this stream.
*

447
redisson/src/main/java/org/redisson/api/RStreamAsync.java
Unescape Escape View File

@ -45,18 +45,6 @@ public interface RStreamAsync<K, V> extends RExpirableAsync {
*/
RFuture<Void> createGroupAsync(StreamCreateGroupArgs args);
/**
* Use createGroupAsync(StreamCreateGroupArgs) method instead
*/
@Deprecated
RFuture<Void> createGroupAsync(String groupName);
/**
* Use createGroupAsync(StreamCreateGroupArgs) method instead
*/
@Deprecated
RFuture<Void> createGroupAsync(String groupName, StreamMessageId id);
/**
* Removes group by name.
*
@ -334,224 +322,6 @@ public interface RStreamAsync<K, V> extends RExpirableAsync {
*/
RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, StreamReadGroupArgs args);
/**
* * Use readGroup(String, String, StreamReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param ids - collection of Stream IDs
* @return stream data mapped by Stream ID
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, StreamMessageId... ids);
/**
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param count - stream data size limit
* @param ids - collection of Stream IDs
* @return stream data mapped by Stream ID
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId... ids);
/**
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param timeout - time interval to wait for stream data availability
* @param unit - time interval unit
* @param ids - collection of Stream IDs
* @return stream data mapped by Stream ID
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId... ids);
/**
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param count - stream data size limit
* @param timeout - time interval to wait for stream data availability
* @param unit - time interval unit
* @param ids - collection of Stream IDs
* @return stream data mapped by Stream ID
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param id - starting message id for this stream
* @param nameToId - Stream Message ID mapped by stream name
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param count - stream data size limit
* @param id - starting message id for this stream
* @param nameToId - Stream Message ID mapped by stream name
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param count - stream data size limit
* @param timeout - time interval to wait for stream data availability
* @param unit - time interval unit
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param count - stream data size limit
* @param timeout - time interval to wait for stream data availability
* @param unit - time interval unit
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @param key3 - name of third stream
* @param id3 - starting message id for third stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param timeout - time interval to wait for stream data availability
* @param unit - time interval unit
* @param id - starting message id for this stream
* @param nameToId - Stream Message ID mapped by stream name
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @param key3 - name of third stream
* @param id3 - starting message id for third stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param count - stream data size limit
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param count - stream data size limit
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @param key3 - name of third stream
* @param id3 - starting message id for third stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2,
String key3, StreamMessageId id3);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param timeout - time interval to wait for stream data availability
* @param unit - time interval unit
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2);
/**
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
* @param groupName - name of group
* @param consumerName - name of consumer
* @param timeout - time interval to wait for stream data availability
* @param unit - time interval unit
* @param id - starting message id for this stream
* @param key2 - name of second stream
* @param id2 - starting message id for second stream
* @param key3 - name of third stream
* @param id3 - starting message id for third stream
* @return stream data mapped by key and Stream Message ID
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3);
/**
* Returns number of entries in stream
*
@ -575,62 +345,6 @@ public interface RStreamAsync<K, V> extends RExpirableAsync {
*/
RFuture<Void> addAsync(StreamMessageId id, StreamAddArgs<K, V> args);
/*
* Use addAsync(StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<StreamMessageId> addAsync(K key, V value);
/*
* Use addAsync(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<Void> addAsync(StreamMessageId id, K key, V value);
/*
* Use addAsync(StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<StreamMessageId> addAsync(K key, V value, int trimLen, boolean trimStrict);
/*
* Use addAsync(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<Void> addAsync(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict);
/*
* Use addAsync(StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<StreamMessageId> addAllAsync(Map<K, V> entries);
/*
* Use addAsync(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<Void> addAllAsync(StreamMessageId id, Map<K, V> entries);
/*
* Use addAsync(StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<StreamMessageId> addAllAsync(Map<K, V> entries, int trimLen, boolean trimStrict);
/*
* Use addAsync(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
RFuture<Void> addAllAsync(StreamMessageId id, Map<K, V> entries, int trimLen, boolean trimStrict);
/**
* Read stream data from multiple streams including current.
*
@ -647,118 +361,6 @@ public interface RStreamAsync<K, V> extends RExpirableAsync {
*/
RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(StreamReadArgs args);
/*
* Use readAsync(StreamReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(StreamMessageId... ids);
/*
* Use readAsync(StreamReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(int count, StreamMessageId... ids);
/*
* Use readAsync(StreamReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readAsync(StreamReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<StreamMessageId, Map<K, V>>> readAsync(int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use readAsync(StreamMultiReadArgs) method instead
*
*/
@Deprecated
RFuture<Map<String, Map<StreamMessageId, Map<K, V>>>> readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/**
* Returns stream data in range by specified start Stream ID (included) and end Stream ID (included).
*
@ -809,55 +411,6 @@ public interface RStreamAsync<K, V> extends RExpirableAsync {
RFuture<Long> trimNonStrictAsync(StreamTrimArgs args);
/**
* Trims stream using MAXLEN strategy to specified size
*
* @param size - new size of stream
* @return number of deleted messages
*/
@Deprecated
RFuture<Long> trimAsync(int size);
/**
* Trims stream to specified size
*
* @param strategy - trim strategy
* @param threshold - new size of stream
* @return number of deleted messages
*/
@Deprecated
RFuture<Long> trimAsync(TrimStrategy strategy, int threshold);
/**
* Trims stream using MAXLEN strategy to almost exact trimming threshold.
*
* @param size - new size of stream
* @return number of deleted messages
*/
@Deprecated
RFuture<Long> trimNonStrictAsync(int size);
/**
* Trims stream using almost exact trimming threshold.
*
* @param strategy - trim strategy
* @param threshold - trim threshold
* @return number of deleted messages
*/
@Deprecated
RFuture<Long> trimNonStrictAsync(TrimStrategy strategy, int threshold);
/**
* Trims stream using almost exact trimming threshold up to limit.
*
* @param strategy - trim strategy
* @param threshold - trim threshold
* @param limit - trim limit
* @return number of deleted messages
*/
@Deprecated
RFuture<Long> trimNonStrictAsync(TrimStrategy strategy, int threshold, int limit);
/**
* Returns information about this stream.
*

331
redisson/src/main/java/org/redisson/api/RStreamReactive.java
Unescape Escape View File

@ -46,18 +46,6 @@ public interface RStreamReactive<K, V> extends RExpirableReactive {
*/
Mono<Void> createGroup(StreamCreateGroupArgs args);
/**
* Use createGroup(StreamCreateGroupArgs) method instead
*/
@Deprecated
Mono<Void> createGroup(String groupName);
/**
* Use createGroup(StreamCreateGroupArgs) method instead
*/
@Deprecated
Mono<Void> createGroup(String groupName, StreamMessageId id);
/**
* Removes group by name.
*
@ -111,12 +99,6 @@ public interface RStreamReactive<K, V> extends RExpirableReactive {
*/
Mono<PendingResult> getPendingInfo(String groupName);
/*
* Use #getPendingInfo method
*/
@Deprecated
Mono<PendingResult> listPending(String groupName);
/**
* Returns list of pending messages by group name.
* Limited by start stream id and end stream id and count.
@ -309,116 +291,6 @@ public interface RStreamReactive<K, V> extends RExpirableReactive {
*/
Mono<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamReadGroupArgs args);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2,
String key3, StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3);
/**
* Returns number of entries in stream
*
@ -460,62 +332,6 @@ public interface RStreamReactive<K, V> extends RExpirableReactive {
*/
Mono<Void> add(StreamMessageId id, StreamAddArgs<K, V> args);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Mono<StreamMessageId> add(K key, V value);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Mono<Void> add(StreamMessageId id, K key, V value);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Mono<StreamMessageId> add(K key, V value, int trimLen, boolean trimStrict);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Mono<Void> add(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Mono<StreamMessageId> addAll(Map<K, V> entries);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Mono<Void> addAll(StreamMessageId id, Map<K, V> entries);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Mono<StreamMessageId> addAll(Map<K, V> entries, int trimLen, boolean trimStrict);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Mono<Void> addAll(StreamMessageId id, Map<K, V> entries, int trimLen, boolean trimStrict);
/**
* Read stream data from multiple streams including current.
* <p>
@ -552,118 +368,6 @@ public interface RStreamReactive<K, V> extends RExpirableReactive {
*/
Mono<Map<StreamMessageId, Map<K, V>>> read(StreamReadArgs args);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> read(StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Mono<Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Mono<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/**
* Returns stream data in range by specified start Stream ID (included) and end Stream ID (included).
*
@ -726,41 +430,6 @@ public interface RStreamReactive<K, V> extends RExpirableReactive {
*/
Mono<Long> trimNonStrict(StreamTrimArgs args);
/*
* Use trim(StreamTrimArgs) method instead
*
*/
@Deprecated
Mono<Long> trim(int size);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
Mono<Long> trimNonStrict(int size);
/*
* Use trim(StreamTrimArgs) method instead
*
*/
@Deprecated
Mono<Long> trim(TrimStrategy strategy, int threshold);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
Mono<Long> trimNonStrict(TrimStrategy strategy, int threshold);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
Mono<Long> trimNonStrict(TrimStrategy strategy, int threshold, int limit);
/**
* Returns information about this stream.
*

331
redisson/src/main/java/org/redisson/api/RStreamRx.java
Unescape Escape View File

@ -47,18 +47,6 @@ public interface RStreamRx<K, V> extends RExpirableRx {
*/
Completable createGroup(StreamCreateGroupArgs args);
/**
* Use createGroup(StreamCreateGroupArgs) method instead
*/
@Deprecated
Completable createGroup(String groupName);
/**
* Use createGroup(StreamCreateGroupArgs) method instead
*/
@Deprecated
Completable createGroup(String groupName, StreamMessageId id);
/**
* Removes group by name.
*
@ -112,12 +100,6 @@ public interface RStreamRx<K, V> extends RExpirableRx {
*/
Single<PendingResult> getPendingInfo(String groupName);
/*
* Use #getPendingInfo method
*/
@Deprecated
Single<PendingResult> listPending(String groupName);
/**
* Returns list of pending messages by group name.
* Limited by start stream id and end stream id and count.
@ -310,116 +292,6 @@ public interface RStreamRx<K, V> extends RExpirableRx {
*/
Single<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamReadGroupArgs args);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3,
StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2,
String key3, StreamMessageId id3);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2);
/*
* Use readGroup(String, String, StreamMultiReadGroupArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> readGroup(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id,
String key2, StreamMessageId id2, String key3, StreamMessageId id3);
/**
* Returns number of entries in stream
*
@ -461,62 +333,6 @@ public interface RStreamRx<K, V> extends RExpirableRx {
*/
Completable add(StreamMessageId id, StreamAddArgs<K, V> args);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Single<StreamMessageId> add(K key, V value);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Completable add(StreamMessageId id, K key, V value);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Single<StreamMessageId> add(K key, V value, int trimLen, boolean trimStrict);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Completable add(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Single<StreamMessageId> addAll(Map<K, V> entries);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Completable addAll(StreamMessageId id, Map<K, V> entries);
/*
* Use add(StreamAddArgs) method instead
*
*/
@Deprecated
Single<StreamMessageId> addAll(Map<K, V> entries, int trimLen, boolean trimStrict);
/*
* Use add(StreamMessageId, StreamAddArgs) method instead
*
*/
@Deprecated
Completable addAll(StreamMessageId id, Map<K, V> entries, int trimLen, boolean trimStrict);
/**
* Read stream data from multiple streams including current.
* <p>
@ -553,118 +369,6 @@ public interface RStreamRx<K, V> extends RExpirableRx {
*/
Single<Map<StreamMessageId, Map<K, V>>> read(StreamReadArgs args);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> read(StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> read(int count, StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> read(long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use read(StreamReadArgs) method instead
*
*/
@Deprecated
Single<Map<StreamMessageId, Map<K, V>>> read(int count, long timeout, TimeUnit unit, StreamMessageId... ids);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3);
/*
* Use read(StreamMultiReadArgs) method instead
*
*/
@Deprecated
Single<Map<String, Map<StreamMessageId, Map<K, V>>>> read(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String, StreamMessageId> nameToId);
/**
* Returns stream data in range by specified start Stream ID (included) and end Stream ID (included).
*
@ -727,41 +431,6 @@ public interface RStreamRx<K, V> extends RExpirableRx {
*/
Single<Long> trimNonStrict(StreamTrimArgs args);
/*
* Use trim(StreamTrimArgs) method instead
*
*/
@Deprecated
Single<Long> trim(int size);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
Single<Long> trimNonStrict(int size);
/*
* Use trim(StreamTrimArgs) method instead
*
*/
@Deprecated
Single<Long> trim(TrimStrategy strategy, int threshold);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
Single<Long> trimNonStrict(TrimStrategy strategy, int threshold);
/*
* Use trimNonStrict(StreamTrimArgs) method instead
*
*/
@Deprecated
Single<Long> trimNonStrict(TrimStrategy strategy, int threshold, int limit);
/**
* Returns information about this stream.
*

104
redisson/src/test/java/org/redisson/RedissonStreamTest.java
Unescape Escape View File

@ -42,7 +42,7 @@ public class RedissonStreamTest extends RedisDockerTest {
@Test
public void testEmptyMap() {
RStream<Object, Object> stream = redisson.getStream("stream");
stream.createGroup("group");
stream.createGroup(StreamCreateGroupArgs.name("group").makeStream());
stream.add(StreamAddArgs.entry("key", "value"));
Map<StreamMessageId, Map<Object, Object>> result2 = stream.readGroup("group", "consumer",
@ -61,7 +61,7 @@ public class RedissonStreamTest extends RedisDockerTest {
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -91,7 +91,7 @@ public class RedissonStreamTest extends RedisDockerTest {
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -142,7 +142,7 @@ public class RedissonStreamTest extends RedisDockerTest {
@Test
public void testPendingEmpty() {
RStream<Object, Object> stream = redisson.getStream("test");
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup").makeStream());
PendingResult result = stream.getPendingInfo("testGroup");
assertThat(result.getTotal()).isZero();
assertThat(result.getHighestId()).isNull();
@ -155,8 +155,8 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
StreamMessageId id = stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
System.out.println("id1 " + id1);
@ -177,9 +177,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup").makeStream());
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -197,7 +197,7 @@ public class RedissonStreamTest extends RedisDockerTest {
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -226,7 +226,7 @@ public class RedissonStreamTest extends RedisDockerTest {
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -254,9 +254,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -286,7 +286,7 @@ public class RedissonStreamTest extends RedisDockerTest {
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup3");
stream.createGroup(StreamCreateGroupArgs.name("testGroup3"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -313,7 +313,7 @@ public class RedissonStreamTest extends RedisDockerTest {
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup3");
stream.createGroup(StreamCreateGroupArgs.name("testGroup3"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -339,9 +339,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -382,9 +382,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("11", "12"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("21", "22"));
@ -410,9 +410,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup");
stream.createGroup(StreamCreateGroupArgs.name("testGroup"));
StreamMessageId id1 = stream.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id2 = stream.add(StreamAddArgs.entry("2", "2"));
@ -429,10 +429,10 @@ public class RedissonStreamTest extends RedisDockerTest {
StreamMessageId id01 = stream1.add(StreamAddArgs.entry("0", "0"));
StreamMessageId id02 = stream2.add(StreamAddArgs.entry("0", "0"));
stream1.createGroup("testGroup", id01);
stream2.createGroup("testGroup", id02);
stream1.createGroup(StreamCreateGroupArgs.name("testGroup").id(id01));
stream2.createGroup(StreamCreateGroupArgs.name("testGroup").id(id02));
StreamMessageId id11 = stream1.add(StreamAddArgs.entry("1", "1"));
StreamMessageId id12 = stream1.add(StreamAddArgs.entry("2", "2"));
StreamMessageId id13 = stream1.add(StreamAddArgs.entry("3", "3"));
@ -449,9 +449,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
StreamMessageId id0 = stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup", id0);
stream.createGroup(StreamCreateGroupArgs.name("testGroup").id(id0).makeStream());
stream.add(StreamAddArgs.entry("1", "1"));
stream.add(StreamAddArgs.entry("2", "2"));
stream.add(StreamAddArgs.entry("3", "3"));
@ -461,9 +461,9 @@ public class RedissonStreamTest extends RedisDockerTest {
assertThat(s.size()).isEqualTo(3);
stream.removeGroup("testGroup");
stream.createGroup("testGroup", id0);
stream.createGroup(StreamCreateGroupArgs.name("testGroup").id(id0).makeStream());
stream.add(StreamAddArgs.entry("1", "1"));
stream.add(StreamAddArgs.entry("2", "2"));
stream.add(StreamAddArgs.entry("3", "3"));
@ -471,9 +471,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream2 = redisson.getStream("test2");
StreamMessageId id1 = stream2.add(StreamAddArgs.entry("0", "0"));
stream2.createGroup("testGroup", id1);
stream2.createGroup(StreamCreateGroupArgs.name("testGroup").id(id1).makeStream());
// Map<String, Map<StreamMessageId, Map<String, String>>> s2 = stream.readGroup("testGroup", "consumer1", 3, 5, TimeUnit.SECONDS, id0, Collections.singletonMap("test2", id1));
// assertThat(s2.values().iterator().next().values().iterator().next().keySet()).containsAnyOf("1", "2", "3");
// assertThat(s2.size()).isEqualTo(3);
@ -482,7 +482,7 @@ public class RedissonStreamTest extends RedisDockerTest {
@Test
public void testCreateEmpty() {
RStream<String, String> stream = redisson.getStream("test");
stream.createGroup("testGroup", StreamMessageId.ALL);
stream.createGroup(StreamCreateGroupArgs.name("testGroup").id(StreamMessageId.ALL).makeStream());
stream.add(StreamAddArgs.entry("1", "2"));
Map<StreamMessageId, Map<String, String>> s = stream.readGroup("testGroup", "consumer1", StreamReadGroupArgs.neverDelivered());
@ -494,9 +494,9 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test");
StreamMessageId id0 = stream.add(StreamAddArgs.entry("0", "0"));
stream.createGroup("testGroup", id0);
stream.createGroup(StreamCreateGroupArgs.name("testGroup").id(id0));
stream.add(StreamAddArgs.entry("1", "1"));
stream.add(StreamAddArgs.entry("2", "2"));
stream.add(StreamAddArgs.entry("3", "3"));
@ -798,15 +798,15 @@ public class RedissonStreamTest extends RedisDockerTest {
RStream<String, String> stream = redisson.getStream("test1");
StreamMessageId id1 = new StreamMessageId(12, 44);
stream.createGroup("testGroup", id1);
stream.createGroup(StreamCreateGroupArgs.name("testGroup").id(id1).makeStream());
stream.add(StreamAddArgs.entry("1", "1"));
stream.add(StreamAddArgs.entry("2", "2"));
stream.add(StreamAddArgs.entry("3", "3"));
StreamMessageId id2 = new StreamMessageId(12, 44);
stream.createGroup("testGroup2", id2);
stream.createGroup(StreamCreateGroupArgs.name("testGroup2").id(id2).makeStream());
stream.add(StreamAddArgs.entry("1", "1"));
stream.add(StreamAddArgs.entry("2", "2"));
stream.add(StreamAddArgs.entry("3", "3"));
@ -845,15 +845,15 @@ public class RedissonStreamTest extends RedisDockerTest {
assertThat(s).isEmpty();
StreamMessageId id1 = new StreamMessageId(12, 44);
stream.createGroup("testGroup", id1);
stream.createGroup(StreamCreateGroupArgs.name("testGroup").id(id1));
stream.add(StreamAddArgs.entry("1", "1"));
stream.add(StreamAddArgs.entry("2", "2"));
stream.add(StreamAddArgs.entry("3", "3"));
StreamMessageId id2 = new StreamMessageId(12, 44);
stream.createGroup("testGroup2", id2);
stream.createGroup(StreamCreateGroupArgs.name("testGroup2").id(id2));
stream.add(StreamAddArgs.entry("1", "1"));
stream.add(StreamAddArgs.entry("2", "2"));
stream.add(StreamAddArgs.entry("3", "3"));
@ -874,8 +874,8 @@ public class RedissonStreamTest extends RedisDockerTest {
public void testStreamInfoEmpty() {
RStream<String, String> stream = redisson.getStream("test1");
StreamMessageId id1 = new StreamMessageId(12, 44);
stream.createGroup("testGroup", id1);
stream.createGroup(StreamCreateGroupArgs.name("testGroup").id(id1).makeStream());
StreamInfo<String, String> s = stream.getInfo();
}

Write Preview
Loading…
Cancel
Save