com.lambdaworks.redis.RedisFuture Java Examples

private final CompletionStage<Object> clean(RedisFuture<KeyScanCursor<byte[]>> future, ScanArgs args,
		String match) {
	return future.thenCompose(keyScanCursor -> {
		List<byte[]> keys = keyScanCursor.getKeys();
		if (keys == null || keys.isEmpty()) {
			return CompletableFuture.completedFuture(keyScanCursor);
		}
		if (match != null) {
			Iterator<byte[]> i = keys.iterator();
			while (i.hasNext()) {
				if (!Matcher.matches(new String(i.next(), StandardCharsets.UTF_8), match)) {
					i.remove();
				}
			}
		}
		if (keys.isEmpty()) {
			return CompletableFuture.completedFuture(keyScanCursor);
		}
		byte[][] array = new byte[keys.size()][];
		keys.toArray(array);
		return client.del(array).thenApply(nul -> keyScanCursor);
	}).thenApply(keyScanCursor -> {
		if (((KeyScanCursor<byte[]>) keyScanCursor).isFinished()) {
			return null;
		}
		return ((KeyScanCursor<byte[]>) keyScanCursor).getCursor();
	}).thenCompose(currentCursor -> {
		if (currentCursor == null) {
			return CompletableFuture.completedFuture(null);
		}
		return clean(new ScanCursor((String) currentCursor, false), args, match);
	});
}
 

@Test
public void testSameResultType() throws Exception {
    Method method = asyncClass.getMethod(this.method.getName(), this.method.getParameterTypes());
    Class<?> returnType = method.getReturnType();

    if (returnType.equals(RedisFuture.class)) {
        ParameterizedType genericReturnType = (ParameterizedType) method.getGenericReturnType();
        Type[] actualTypeArguments = genericReturnType.getActualTypeArguments();

        if (actualTypeArguments[0] instanceof TypeVariable) {

            assertThat(Object.class).isEqualTo(this.method.getReturnType());
            return;
        }

        if (actualTypeArguments[0] instanceof ParameterizedType) {

            ParameterizedType parameterizedType = (ParameterizedType) actualTypeArguments[0];
            returnType = (Class<?>) parameterizedType.getRawType();
        } else if (actualTypeArguments[0] instanceof GenericArrayType) {

            GenericArrayType arrayType = (GenericArrayType) actualTypeArguments[0];
            returnType = Array.newInstance((Class<?>) arrayType.getGenericComponentType(), 0).getClass();
        } else {
            returnType = (Class<?>) actualTypeArguments[0];
        }
    }

    Class<?> expectedType = getType(this.method.getReturnType());
    returnType = getType(returnType);

    assertThat(returnType).describedAs(this.method.toString()).isEqualTo(expectedType);

}
 

@Override
public void appendTransLog(String appId, String busCode, long trxId, List<Content> newOrderedContent,
		boolean finished) {

	String transId = ObjectDigestUtil.byteArrayToHexString(idCodec.getTransIdByte(new TransactionId(appId, busCode, trxId)));
	RedisFuture<Long> zadd = null;
	RedisFuture<Long> rpush = null;
	RedisFuture<Long> zrem = null;
	RedisFuture<Long> del = null;
	if (!finished) {
		zadd = async.zadd(keyPrefix + appId, (double) System.currentTimeMillis(), (keyPrefix + transId).getBytes(StandardCharsets.UTF_8));
		//序列化
		byte[][] array = newOrderedContent.stream().map(objectSerializer::serialization).toArray(byte[][]::new);
		rpush = async.rpush(keyPrefix + transId, array);
	} else {
		zrem = async.zrem(keyPrefix + appId, (keyPrefix + transId).getBytes(StandardCharsets.UTF_8));
		del = async.del(keyPrefix + transId);
	}

	try {
		if (zadd != null) {
			zadd.get();
		}
		if (rpush != null) {
			rpush.get();
		}
		if (zrem != null) {
			zrem.get();
		}
		if (del != null) {
			del.get();
		}
	} catch (InterruptedException | ExecutionException e) {
		throw new RuntimeException(e);
	}
}
 

@Override
public RedisFuture<String> clusterNodes() {
    return dispatch(commandBuilder.clusterNodes());
}
 

@Override
public RedisFuture<String> addjob(K queue, V job, long commandTimeout, TimeUnit timeUnit) {
    return dispatch(commandBuilder.addjob(queue, job, commandTimeout, timeUnit, null));
}
 

@Override
public RedisFuture<Long> ackjob(String... jobIds) {
    return dispatch(commandBuilder.ackjob(jobIds));
}
 

@Override
public RedisFuture<Long> clientKill(KillArgs killArgs) {
    return dispatch(commandBuilder.clientKill(killArgs));
}
 

@Override
public RedisFuture<List<Object>> slowlogGet() {
    return dispatch(commandBuilder.slowlogGet());
}
 

@Override
public RedisFuture<String> addjob(K queue, V job, long commandTimeout, TimeUnit timeUnit, AddJobArgs addJobArgs) {
    return dispatch(commandBuilder.addjob(queue, job, commandTimeout, timeUnit, addJobArgs));
}
 

@Override
public RedisFuture<String> clientList() {
    return dispatch(commandBuilder.clientList());
}
 

@Override
public RedisFuture<List<String>> configGet(String parameter) {
    return dispatch(commandBuilder.configGet(parameter));
}
 

@Override
public RedisFuture<String> clientSetname(String name) {
    return dispatch(commandBuilder.clientSetname(name));
}
 

@Override
public RedisFuture<List<Object>> slowlogGet(int count) {
    return dispatch(commandBuilder.slowlogGet(count));
}
 

@Override
public RedisFuture<String> clusterInfo() {
    return dispatch(commandBuilder.clusterInfo());
}
 

@Override
public RedisFuture<String> debugFlushall() {
    return dispatch(commandBuilder.debugFlushall());
}
 

@Override
public RedisFuture<KeyScanCursor<String>> jscan(ScanCursor scanCursor, JScanArgs<K> scanArgs) {
    return dispatch(commandBuilder.jscan(scanCursor, scanArgs));
}
 

@Override
public RedisFuture<KeyScanCursor<K>> qscan(ScanCursor scanCursor, QScanArgs scanArgs) {
    return dispatch(commandBuilder.qscan(scanCursor, scanArgs));
}
 

@Override
public RedisFuture<List<V>> time() {
    return dispatch(commandBuilder.time());
}
 

@Override
public RedisFuture<String> clusterMyId() {
    return dispatch(commandBuilder.clusterMyId());
}
 

@Override
public RedisFuture<Long> commandCount() {
    return dispatch(commandBuilder.commandCount());
}
 

@Override
public RedisFuture<KeyScanCursor<String>> jscan() {
    return dispatch(commandBuilder.jscan(null, null));
}
 

@Override
public RedisFuture<String> clusterSaveconfig() {
    return dispatch(commandBuilder.clusterSaveconfig());
}
 

@Override
public RedisFuture<String> configResetstat() {
    return dispatch(commandBuilder.configResetstat());
}
 

@Override
public RedisFuture<String> ping() {
    return dispatch(commandBuilder.ping());
}
 

@Override
public RedisFuture<Long> enqueue(String... jobIds) {
    return dispatch(commandBuilder.enqueue(jobIds));
}
 

@Override
public RedisFuture<String> slowlogReset() {
    return dispatch(commandBuilder.slowlogReset());
}
 

@Override
public RedisFuture<List<Object>> show(String jobId) {
    return dispatch(commandBuilder.show(jobId));
}
 

@Override
public RedisFuture<Long> dequeue(String... jobIds) {
    return dispatch(commandBuilder.dequeue(jobIds));
}
 

@Override
public RedisFuture<String> clusterReset(boolean hard) {
    return dispatch(commandBuilder.clusterReset(hard));
}
 

@Override
public RedisFuture<String> clusterLeaving() {
    return dispatch(commandBuilder.clusterLeaving());
}