io.vertx.rxjava.redis.client

## Class Redis

- java.lang.Object
- - io.vertx.rxjava.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 and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<Redis>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Redis(Object delegate)`
    `Redis(Redis delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `Redis` | `batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `Observable<List<Response>>` | `batchObservable(List<Request> commands)` Deprecated. use `rxBatch(java.util.List<io.vertx.rxjava.redis.client.Request>)` instead
    `void` | `close()` Closes the client and terminates any connection.
    `Redis` | `connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `Observable<RedisConnection>` | `connectObservable()` Deprecated. use `rxConnect()` instead
    `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.
    `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.
    `Single<RedisConnection>` | `rxConnect()` Connects to the redis server.
    `Single<Response>` | `rxSend(Request command)` Send the given command to the redis server or cluster.
    `Redis` | `send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `Observable<Response>` | `sendObservable(Request command)` Deprecated. use `rxSend(io.vertx.rxjava.redis.client.Request)` instead
    `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 vertx instance
        `options` - the user provided options
      Returns:
        the client

    - #### connect

          public Redis connect(Handler<AsyncResult<RedisConnection>> handler)

      Connects to the redis server.
      Parameters:
        `handler` - the async result handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### connectObservable

          @Deprecated
          public Observable<RedisConnection> connectObservable()

      Deprecated. use `rxConnect()` instead
      Connects to the redis server.
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxConnect

          public Single<RedisConnection> rxConnect()

      Connects to the redis server.
      Returns:
        a reference to this, so the API can be used fluently

    - #### close

          public void close()

      Closes the client and terminates any connection.

    - #### send

          public Redis send(Request command,
                            Handler<AsyncResult<Response>> onSend)

      Send the given command to the redis server or cluster.
      Parameters:
        `command` - the command to send
        `onSend` - the asynchronous result handler.
      Returns:
        fluent self.

    - #### sendObservable

          @Deprecated
          public Observable<Response> sendObservable(Request command)

      Deprecated. use `rxSend(io.vertx.rxjava.redis.client.Request)` instead
      Send the given command to the redis server or cluster.
      Parameters:
        `command` - the command to send
      Returns:
        fluent self.

    - #### rxSend

          public Single<Response> rxSend(Request command)

      Send the given command to the redis server or cluster.
      Parameters:
        `command` - the command to send
      Returns:
        fluent self.

    - #### batch

          public Redis batch(List<Request> commands,
                             Handler<AsyncResult<List<Response>>> onSend)

      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
        `onSend` - the asynchronous result handler.
      Returns:
        fluent self.

    - #### batchObservable

          @Deprecated
          public Observable<List<Response>> batchObservable(List<Request> commands)

      Deprecated. use `rxBatch(java.util.List<io.vertx.rxjava.redis.client.Request>)` instead
      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:
        fluent self.

    - #### 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:
        fluent self.

    - #### newInstance

          public static Redis newInstance(Redis arg)

Copyright © 2021 Eclipse. All rights reserved.