Package io.vertx.reactivex.redis.client

Class Redis

  • All Implemented Interfaces:
    io.vertx.lang.rx.RxDelegate
    public class Redis
extends Object
implements io.vertx.lang.rx.RxDelegate
    A simple Redis client.

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

    • 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

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • getDelegate

        public Redis getDelegate()
        Specified by:
        getDelegate in interface io.vertx.lang.rx.RxDelegate

      • 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,
                                           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,
                                            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,
                                         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,
                                        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)