Package io.vertx.reactivex.redis.client

Class Redis

java.lang.Object

io.vertx.reactivex.redis.client.Redis

public class Redis
extends Object

A simple Redis client.

NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field	Description
static io.vertx.lang.rx.TypeArg<Redis>	__TYPE_ARG

Constructor Summary

Constructors

Constructor	Description
Redis(Redis delegate)
Redis(Object delegate)

Method Summary

Modifier and Type	Method	Description
Future<List<Response>>	batch(List<Request> commands)	Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
Future<Void>	close()	Closes the client and terminates any connection.
Future<RedisConnection>	connect()	Connects to the Redis server.
static Redis	createClient(Vertx vertx)	Create a new Redis client using the default client options.
static Redis	createClient(Vertx vertx, RedisOptions options)	Create a new Redis client using the given client options.
static Redis	createClient(Vertx vertx, String connectionString)	Create a new Redis client using the default client options.
static Redis	createClusterClient(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisClusterConnectOptions>> connectOptions)	Creates a new cluster Redis client.
static Redis	createReplicationClient(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisReplicationConnectOptions>> connectOptions)	Creates a new replication Redis client.
static Redis	createSentinelClient(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisSentinelConnectOptions>> connectOptions)	Creates a new sentinel Redis client.
static Redis	createStandaloneClient(Vertx vertx, RedisOptions options, java.util.function.Supplier<Future<RedisStandaloneConnectOptions>> connectOptions)	Creates a new standalone Redis client.
boolean	equals(Object o)
Redis	getDelegate()
int	hashCode()
static Redis	newInstance(Redis arg)
Single<List<Response>>	rxBatch(List<Request> commands)	Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
Completable	rxClose()	Closes the client and terminates any connection.
Single<RedisConnection>	rxConnect()	Connects to the Redis server.
Maybe<Response>	rxSend(Request command)	Send the given command to the Redis server or cluster.
Future<Response>	send(Request command)	Send the given command to the Redis server or cluster.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final io.vertx.lang.rx.TypeArg<Redis> __TYPE_ARG

Constructor Detail

Redis

public Redis(Redis delegate)

Redis

public Redis(Object delegate)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

getDelegate

public Redis getDelegate()

createClient

public static Redis createClient(Vertx vertx)

Create a new Redis client using the default client options.

Parameters:

vertx - the vertx instance

Returns:

the client

createClient

public static Redis createClient(Vertx vertx,
                                 String connectionString)

Create a new Redis client using the default client options. Does not support rediss (redis over ssl scheme) for now.

Parameters:

vertx - the vertx instance

connectionString - a string URI following the scheme: redis://[username:password@][host][:port][/database]

Returns:

the client

createClient

public static Redis createClient(Vertx vertx,
                                 RedisOptions options)

Create a new Redis client using the given client options.

Parameters:

vertx - the Vert.x instance

options - the user provided options

Returns:

the client

createStandaloneClient

public static Redis createStandaloneClient(Vertx vertx,
                                           RedisOptions options,
                                           java.util.function.Supplier<Future<RedisStandaloneConnectOptions>> connectOptions)

Creates a new standalone Redis client. The options are used to obtain RedisOptions, RedisOptions, RedisOptions and RedisOptions. The connectOptions are queried for every connection attempt.

If options.getType() != RedisClientType.STANDALONE, an exception is thrown.

Parameters:

vertx - the Vert.x instance

options - the static options

connectOptions - supplier of the dynamic options

Returns:

the standalone client

createReplicationClient

public static Redis createReplicationClient(Vertx vertx,
                                            RedisOptions options,
                                            java.util.function.Supplier<Future<RedisReplicationConnectOptions>> connectOptions)

Creates a new replication Redis client. The options are used to obtain RedisOptions, RedisOptions, RedisOptions and RedisOptions. The connectOptions are queried for every connection attempt.

If options.getType() != RedisClientType.REPLICATION, an exception is thrown.

Parameters:

vertx - the Vert.x instance

options - the static options

connectOptions - supplier of the dynamic options

Returns:

the replication client

createSentinelClient

public static Redis createSentinelClient(Vertx vertx,
                                         RedisOptions options,
                                         java.util.function.Supplier<Future<RedisSentinelConnectOptions>> connectOptions)

Creates a new sentinel Redis client. The options are used to obtain RedisOptions, RedisOptions, RedisOptions and RedisOptions. The connectOptions are queried for every connection attempt.

If options.getType() != RedisClientType.SENTINEL, an exception is thrown.

Parameters:

vertx - the Vert.x instance

options - the static options

connectOptions - supplier of the dynamic options

Returns:

the sentinel client

createClusterClient

public static Redis createClusterClient(Vertx vertx,
                                        RedisOptions options,
                                        java.util.function.Supplier<Future<RedisClusterConnectOptions>> connectOptions)

Creates a new cluster Redis client. The options are used to obtain RedisOptions, RedisOptions, RedisOptions and RedisOptions. The connectOptions are queried for every connection attempt.

If options.getType() != RedisClientType.CLUSTER, an exception is thrown.

Parameters:

vertx - the Vert.x instance

options - the static options

connectOptions - supplier of the dynamic options

Returns:

the cluster client

connect

public Future<RedisConnection> connect()

Connects to the Redis server.

Returns:

a future with the result of the operation

rxConnect

public Single<RedisConnection> rxConnect()

Connects to the Redis server.

Returns:

a future with the result of the operation

close

public Future<Void> close()

Closes the client and terminates any connection.

Returns:

rxClose

public Completable rxClose()

Closes the client and terminates any connection.

Returns:

send

public Future<Response> send(Request command)

Send the given command to the Redis server or cluster.

Parameters:

command - the command to send

Returns:

a future with the result of the operation

rxSend

public Maybe<Response> rxSend(Request command)

Send the given command to the Redis server or cluster.

Parameters:

command - the command to send

Returns:

a future with the result of the operation

batch

public Future<List<Response>> batch(List<Request> commands)

Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.

Parameters:

commands - list of command to send

Returns:

a future with the result of the operation

rxBatch

public Single<List<Response>> rxBatch(List<Request> commands)

Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.

Parameters:

commands - list of command to send

Returns:

a future with the result of the operation

newInstance

public static Redis newInstance(Redis arg)