Module dk.cloudcreate.essentials.reactive
Package dk.cloudcreate.essentials.reactive.command

Interface CommandBus

All Known Implementing Classes:
AbstractCommandBus, LocalCommandBus
public interface CommandBus
The CommandBus provides an indirection between a command and the CommandHandler that's capable of handling the command.
Commands can be sent synchronously using send(Object) or asynchronously using sendAsync(Object) that returns a Mono.
The handling of a command usually doesn't return any value (according to the principles of CQRS), however the LocalCommandBus API allows a CommandHandler to return a value if needed (e.g. such as a server generated id)
One important rule is that there can only be one CommandHandler instance that can handle any given command type.
If multiple CommandHandler claim that they all can handle a given command type then send(Object)/sendAsync(Object) will throw MultipleCommandHandlersFoundException
If no CommandHandler's can handle the given command type then send(Object)/sendAsync(Object) will throw NoCommandHandlerFoundException

Example: 

  var commandBus = new LocalCommandBus();
  commandBus.addCommandHandler(new CreateOrderCommandHandler(...));
  commandBus.addCommandHandler(new ImburseOrderCommandHandler(...));

  var optionalResult = commandBus.send(new CreateOrder(...));
  // or
  var monoWithOptionalResult = commandBus.sendAsync(new ImbuseOrder(...))
                                         .block(Duration.ofMillis(1000));

In case you need to colocate multiple related command handling methods inside a single class then you should have your command handling class extend AnnotatedCommandHandler.
Example: 

 public class OrdersCommandHandler extends AnnotatedCommandHandler {

      @Handler
      private OrderId handle(CreateOrder cmd) {
         ...
      }

      @Handler
      private void someMethod(ReimburseOrder cmd) {
         ...
      }
 }
See Also:

  • Method Details

    • getInterceptors

      List<CommandBusInterceptor> getInterceptors()
      Returns an immutable list of interceptors
      Returns:
      Returns an immutable list of interceptors

    • addInterceptor

      CommandBus addInterceptor(CommandBusInterceptor interceptor)
      Add a new interceptor
      Parameters:
      interceptor - the interceptor to add
      Returns:
      this bus instance

    • addInterceptors

      default CommandBus addInterceptors(List<CommandBusInterceptor> interceptors)
      Add new interceptors
      Parameters:
      interceptors - the interceptors to add
      Returns:
      this bus instance

    • hasInterceptor

      boolean hasInterceptor(CommandBusInterceptor interceptor)
      Guard method to test if the CommandBus already contains the interceptor
      Parameters:
      interceptor - the interceptor to check
      Returns:
      true if the CommandBus already contains the interceptor, otherwise false

    • removeInterceptor

      CommandBus removeInterceptor(CommandBusInterceptor interceptor)
      Remove an interceptor
      Parameters:
      interceptor - the interceptor to remove
      Returns:
      this bus instance

    • addCommandHandler

      CommandBus addCommandHandler(CommandHandler commandHandler)
      Add a new command handler.
      Parameters:
      commandHandler - the command handler to add
      Returns:
      this bus instance

    • removeCommandHandler

      CommandBus removeCommandHandler(CommandHandler commandHandler)
      Remove a command handler.
      Parameters:
      commandHandler - the command handler to remove
      Returns:
      this bus instance

    • send

      <R, C> R send(C command)
      The send command synchronously and process the command on the sending thread
      Type Parameters:
      R - the return type
      C - the command type
      Parameters:
      command - the command to send
      Returns:
      the result of the command processing (if any)
      Throws:
      MultipleCommandHandlersFoundException - If multiple CommandHandler claim that they can handle a given command
      NoCommandHandlerFoundException - If no CommandHandler's can handle the given command

    • sendAsync

      <R, C> reactor.core.publisher.Mono<R> sendAsync(C command)
      The send command asynchronously and process the command on a Schedulers.boundedElastic() thread
      Type Parameters:
      R - the return type
      C - the command type
      Parameters:
      command - the command to send
      Returns:
      a Mono that will contain the result of the command processing (if any)
      Throws:
      MultipleCommandHandlersFoundException - If multiple CommandHandler claim that they can handle a given command
      NoCommandHandlerFoundException - If no CommandHandler's can handle the given command

    • sendAndDontWait

      <C> void sendAndDontWait(C command)
      The send command asynchronously without waiting for the result of processing the Command.
      The command handler cannot return any value when invoked using this method.
      Type Parameters:
      C - the command type
      Parameters:
      command - the command to send
      Throws:
      MultipleCommandHandlersFoundException - If multiple CommandHandler claim that they can handle a given command
      NoCommandHandlerFoundException - If no CommandHandler's can handle the given command

    • sendAndDontWait

      <C> void sendAndDontWait(C command, Duration delayMessageDelivery)
      The send command asynchronously without waiting for the result of processing the Command.
      The command handler cannot return any value when invoked using this method.
      Type Parameters:
      C - the command type
      Parameters:
      command - the command to send
      delayMessageDelivery - how long should we delay the command message sending
      Throws:
      MultipleCommandHandlersFoundException - If multiple CommandHandler claim that they can handle a given command
      NoCommandHandlerFoundException - If no CommandHandler's can handle the given command

    • findCommandHandlerCapableOfHandling

      CommandHandler findCommandHandlerCapableOfHandling(Object command)
      Find a CommandHandler capable of handling the given command
      Parameters:
      command - the command to handle
      Returns:
      the single CommandHandler that's capable of handling the given command
      Throws:
      MultipleCommandHandlersFoundException - If multiple CommandHandler claim that they can handle a given command
      NoCommandHandlerFoundException - If no CommandHandler's can handle the given command

    • hasCommandHandler

      boolean hasCommandHandler(CommandHandler commandHandler)
      Guard method to test if the CommandBus already contains the commandHandler
      Parameters:
      commandHandler - the commandHandler to check
      Returns:
      true if the CommandBus already contains the commandHandler, otherwise false