Class EventBusService

  • All Implemented Interfaces:
    io.vertx.lang.rx.RxDelegate

    public class EventBusService
    extends Object
    implements io.vertx.lang.rx.RxDelegate
    for event bus services (service proxies). Consumers receive a service proxy to use the service.

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

    • Constructor Detail

      • EventBusService

        public EventBusService​(Object delegate)
    • Method Detail

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object
      • getDelegate

        public EventBusService getDelegate()
        Specified by:
        getDelegate in interface io.vertx.lang.rx.RxDelegate
      • createRecord

        public static Record createRecord​(String name,
                                          String address,
                                          String itf,
                                          JsonObject metadata)
        Sugar method to creates a record for this type.

        The java interface is added to the metadata in the `service.interface` key.

        Parameters:
        name - the name of the service.
        address - the event bus address on which the service available
        itf - the Java interface (name)
        metadata - the metadata
        Returns:
        the created record
      • getServiceProxy

        public static <T> Single<T> getServiceProxy​(ServiceDiscovery discovery,
                                                    Function<Record,​Boolean> filter,
                                                    Class<T> clientClass)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter
        clientClass - the client class
        Returns:
        a future notified with the client
      • rxGetServiceProxy

        public static <T> Single<T> rxGetServiceProxy​(ServiceDiscovery discovery,
                                                      Function<Record,​Boolean> filter,
                                                      Class<T> clientClass)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter
        clientClass - the client class
        Returns:
        a future notified with the client
      • getServiceProxy

        public static <T> Single<T> getServiceProxy​(ServiceDiscovery discovery,
                                                    Function<Record,​Boolean> filter,
                                                    Class<T> clientClass,
                                                    JsonObject conf)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter
        clientClass - the client class
        conf - the configuration for message delivery
        Returns:
        a future notified with the client
      • rxGetServiceProxy

        public static <T> Single<T> rxGetServiceProxy​(ServiceDiscovery discovery,
                                                      Function<Record,​Boolean> filter,
                                                      Class<T> clientClass,
                                                      JsonObject conf)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter
        clientClass - the client class
        conf - the configuration for message delivery
        Returns:
        a future notified with the client
      • getServiceProxyWithJsonFilter

        public static <T> Single<T> getServiceProxyWithJsonFilter​(ServiceDiscovery discovery,
                                                                  JsonObject filter,
                                                                  Class<T> clientClass)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter as json object
        clientClass - the client class
        Returns:
        a future notified with the client
      • rxGetServiceProxyWithJsonFilter

        public static <T> Single<T> rxGetServiceProxyWithJsonFilter​(ServiceDiscovery discovery,
                                                                    JsonObject filter,
                                                                    Class<T> clientClass)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter as json object
        clientClass - the client class
        Returns:
        a future notified with the client
      • getServiceProxyWithJsonFilter

        public static <T> Single<T> getServiceProxyWithJsonFilter​(ServiceDiscovery discovery,
                                                                  JsonObject filter,
                                                                  Class<T> clientClass,
                                                                  JsonObject conf)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter as json object
        clientClass - the client class
        conf - the configuration for message delivery
        Returns:
        a future notified with the client
      • rxGetServiceProxyWithJsonFilter

        public static <T> Single<T> rxGetServiceProxyWithJsonFilter​(ServiceDiscovery discovery,
                                                                    JsonObject filter,
                                                                    Class<T> clientClass,
                                                                    JsonObject conf)
        Lookup for a service record and if found, retrieve it and return the service object (used to consume the service). This is a convenient method to avoid explicit lookup and then retrieval of the service. This method requires to have the clientClass set with the expected set of client. This is important for usages not using Java so you can pass the expected type.
        Parameters:
        discovery - the service discovery
        filter - the filter as json object
        clientClass - the client class
        conf - the configuration for message delivery
        Returns:
        a future notified with the client
      • createRecord

        public static Record createRecord​(String name,
                                          String address,
                                          String classname)
        Creates a record based on the parameters.
        Parameters:
        name - the service name
        address - the address
        classname - the payload class
        Returns:
        the record