import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
public void configRewrite(BiConsumer<String, Throwable> consumer) {
    Consumer<StatefulRedisConnection> connectionConsumer = new Consumer<StatefulRedisConnection>() {
        @Override
        public void accept(StatefulRedisConnection statefulRedisConnection) {
            RedisFuture<String> redisFuture = statefulRedisConnection.async().configRewrite();
            redisFuture.whenCompleteAsync(consumer, executors);
        }
    };
    asyncExecute(connectionConsumer, null);
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Test
public void testAsyncCommand() throws Exception {
    RedisFuture<String> ping = disque.getConnection().async().ping();
    assertThat(ping).isInstanceOf(AsyncCommand.class);
    assertThat(ping.isCancelled()).isFalse();
    assertThat(ping.getError()).isNull();
    assertThat(ping.get(1, TimeUnit.MINUTES)).isEqualTo("PONG");

}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<List<Object>> commandInfo(CommandType... commands) {
    String[] stringCommands = new String[commands.length];
    for (int i = 0; i < commands.length; i++) {
        stringCommands[i] = commands[i].name();
    }

    return commandInfo(stringCommands);
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@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);

}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<Long> working(String jobId) {
    return dispatch(commandBuilder.working(jobId));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<List<Object>> hello() {
    return dispatch(commandBuilder.hello());
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<Map<String, Object>> qstat(K queue) {
    return dispatch(commandBuilder.qstat(queue));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<List<Object>> slowlogGet(int count) {
    return dispatch(commandBuilder.slowlogGet(count));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<String> info() {
    return dispatch(commandBuilder.info());
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<String> ping() {
    return dispatch(commandBuilder.ping());
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<KeyScanCursor<String>> jscan(ScanCursor scanCursor, JScanArgs<K> scanArgs) {
    return dispatch(commandBuilder.jscan(scanCursor, scanArgs));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<KeyScanCursor<K>> qscan(ScanCursor scanCursor, QScanArgs scanArgs) {
    return dispatch(commandBuilder.qscan(scanCursor, scanArgs));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<List<Job<K, V>>> getjobs(long duration, TimeUnit timeUnit, long count, K... queues) {
    GetJobArgs args = GetJobArgs.builder().timeout(duration, timeUnit).build();
    return dispatch(commandBuilder.getjobs(count, args, queues));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<String> pause(K queue, PauseArgs pauseArgs) {
    return dispatch(commandBuilder.pause(queue, pauseArgs));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<String> slowlogReset() {
    return dispatch(commandBuilder.slowlogReset());
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<String> quit() {
    return dispatch(commandBuilder.quit());
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<Long> ackjob(String... jobIds) {
    return dispatch(commandBuilder.ackjob(jobIds));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<String> addjob(K queue, V job, long commandTimeout, TimeUnit timeUnit) {
    return dispatch(commandBuilder.addjob(queue, job, commandTimeout, timeUnit, null));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<String> auth(String password) {
    return dispatch(commandBuilder.auth(password));
}
 

import com.lambdaworks.redis.RedisFuture; //导入依赖的package包/类
@Override
public RedisFuture<K> clientGetname() {
    return dispatch(commandBuilder.clientGetname());
}