org.axonframework.axonserver.connector.command

Class AxonServerCommandBus

java.lang.Object

org.axonframework.axonserver.connector.command.AxonServerCommandBus

All Implemented Interfaces:

CommandBus, Lifecycle, Distributed<CommandBus>, MessageDispatchInterceptorSupport<CommandMessage<?>>, MessageHandlerInterceptorSupport<CommandMessage<?>>

public class AxonServerCommandBus
extends Object
implements CommandBus, Distributed<CommandBus>, Lifecycle

Axon CommandBus implementation that connects to Axon Server to submit and receive commands and command responses. Delegates incoming commands to the provided localSegment.

Since:

4.0

Author:

Marc Gathier

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AxonServerCommandBus.Builder Builder class to instantiate an AxonServerCommandBus.

Nested classes/interfaces inherited from interface org.axonframework.lifecycle.Lifecycle

Lifecycle.LifecycleHandler, Lifecycle.LifecycleRegistry

Constructor Summary

Constructors

Constructor and Description
AxonServerCommandBus(AxonServerCommandBus.Builder builder) Instantiate a AxonServerCommandBus based on the fields contained in the AxonServerCommandBus.Builder.

Method Summary

Modifier and Type	Method and Description
static AxonServerCommandBus.Builder	builder() Instantiate a Builder to be able to create an AxonServerCommandBus.
CompletableFuture<Void>	disconnect() Disconnect the command bus for receiving commands from Axon Server, by unsubscribing all registered command handlers.
<C> void	dispatch(CommandMessage<C> command) Dispatch the given command to the CommandHandler subscribed to the given command's name.
<C,R> void	dispatch(CommandMessage<C> commandMessage, CommandCallback<? super C,? super R> commandCallback) Dispatch the given command to the CommandHandler subscribed to the given command's name.
CommandBus	localSegment() Return the message bus of type MessageBus which is regarded as the local segment for this implementation.
Registration	registerDispatchInterceptor(MessageDispatchInterceptor<? super CommandMessage<?>> dispatchInterceptor) Register the given DispatchInterceptor.
Registration	registerHandlerInterceptor(MessageHandlerInterceptor<? super CommandMessage<?>> handlerInterceptor) Register the given handlerInterceptor.
void	registerLifecycleHandlers(Lifecycle.LifecycleRegistry handle) Registers the activities to be executed in the various phases of an application's lifecycle.
CompletableFuture<Void>	shutdownDispatching() Shutdown the command bus asynchronously for dispatching commands to Axon Server.
void	start() Start the Axon Server CommandBus implementation.
Registration	subscribe(String commandName, MessageHandler<? super CommandMessage<?>> messageHandler) Subscribe the given handler to commands with the given commandName.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AxonServerCommandBus

public AxonServerCommandBus(AxonServerCommandBus.Builder builder)

Instantiate a AxonServerCommandBus based on the fields contained in the AxonServerCommandBus.Builder.

Parameters:

builder - the AxonServerCommandBus.Builder used to instantiate a AxonServerCommandBus instance

Method Detail

builder

public static AxonServerCommandBus.Builder builder()

Instantiate a Builder to be able to create an AxonServerCommandBus.

The CommandPriorityCalculator is defaulted to CommandPriorityCalculator.defaultCommandPriorityCalculator(), the TargetContextResolver defaults to a lambda returning the AxonServerConfiguration.getContext() as the context and the CommandBusSpanFactory defaults to a DefaultCommandBusSpanFactory backed by a NoOpSpanFactory. The ExecutorServiceBuilder defaults to ExecutorServiceBuilder.defaultCommandExecutorServiceBuilder(). The AxonServerConnectionManager, the AxonServerConfiguration, the local CommandBus, Serializer and the RoutingStrategy are a hard requirements and as such should be provided.

Returns:

a Builder to be able to create a AxonServerCommandBus

registerLifecycleHandlers

public void registerLifecycleHandlers(@Nonnull
                                      Lifecycle.LifecycleRegistry handle)

Description copied from interface: Lifecycle

Registers the activities to be executed in the various phases of an application's lifecycle. This could either be at startup, shutdown, or both.

Specified by:

registerLifecycleHandlers in interface Lifecycle

Parameters:

handle - the lifecycle instance to register the handlers with

See Also:

Lifecycle.LifecycleRegistry.onShutdown(int, Runnable), LifecycleRegistry#onShutdown(int, LifecycleHandler), Lifecycle.LifecycleRegistry.onStart(int, Runnable), LifecycleRegistry#onStart(int, LifecycleHandler)

start

public void start()

Start the Axon Server CommandBus implementation.

dispatch

public <C> void dispatch(@Nonnull
                         CommandMessage<C> command)

Description copied from interface: CommandBus

Dispatch the given command to the CommandHandler subscribed to the given command's name. No feedback is given about the status of the dispatching process. Implementations may return immediately after asserting a valid handler is registered for the given command.

Specified by:

dispatch in interface CommandBus

Type Parameters:

C - The payload type of the command to dispatch

Parameters:

command - The Command to dispatch

See Also:

GenericCommandMessage.asCommandMessage(Object)

dispatch

public <C,R> void dispatch(@Nonnull
                           CommandMessage<C> commandMessage,
                           @Nonnull
                           CommandCallback<? super C,? super R> commandCallback)

Description copied from interface: CommandBus

Dispatch the given command to the CommandHandler subscribed to the given command's name. When the command is processed, one of the callback's methods is called, depending on the result of the processing.

There are no guarantees about the successful completion of command dispatching or handling after the method returns. Implementations are highly recommended to perform basic validation of the command before returning from this method call.

Implementations must start a UnitOfWork when before dispatching the command, and either commit or rollback after a successful or failed execution, respectively.

Specified by:

dispatch in interface CommandBus

Type Parameters:

C - The payload type of the command to dispatch

R - The type of the expected result

Parameters:

commandMessage - The Command to dispatch

commandCallback - The callback to invoke when command processing is complete

See Also:

GenericCommandMessage.asCommandMessage(Object)

subscribe

public Registration subscribe(@Nonnull
                              String commandName,
                              @Nonnull
                              MessageHandler<? super CommandMessage<?>> messageHandler)

Description copied from interface: CommandBus

Subscribe the given handler to commands with the given commandName.

If a subscription already exists for the given name, the behavior is undefined. Implementations may throw an Exception to refuse duplicate subscription or alternatively decide whether the existing or new handler gets the subscription.

Specified by:

subscribe in interface CommandBus

Parameters:

commandName - The name of the command to subscribe the handler to

messageHandler - The handler instance that handles the given type of command

Returns:

a handle to unsubscribe the handler. When unsubscribed it will no longer receive commands.

localSegment

public CommandBus localSegment()

Description copied from interface: Distributed

Return the message bus of type MessageBus which is regarded as the local segment for this implementation. Would return the message bus used to dispatch and handle messages in a local environment to bridge the gap in a distributed set up.

Specified by:

localSegment in interface Distributed<CommandBus>

Returns:

a MessageBus which is the local segment for this distributed message bus implementation

registerHandlerInterceptor

public Registration registerHandlerInterceptor(@Nonnull
                                               MessageHandlerInterceptor<? super CommandMessage<?>> handlerInterceptor)

Description copied from interface: MessageHandlerInterceptorSupport

Register the given handlerInterceptor. After registration, the interceptor will be invoked for each handled Message on the messaging component that it was registered to, prior to invoking the message's handler.

Specified by:

registerHandlerInterceptor in interface MessageHandlerInterceptorSupport<CommandMessage<?>>

Parameters:

handlerInterceptor - The interceptor to register

Returns:

A Registration, which may be used to deregister the interceptor.

registerDispatchInterceptor

public Registration registerDispatchInterceptor(@Nonnull
                                                MessageDispatchInterceptor<? super CommandMessage<?>> dispatchInterceptor)

Description copied from interface: MessageDispatchInterceptorSupport

Register the given DispatchInterceptor. After registration, the interceptor will be invoked for each Message dispatched on the messaging component that it was registered to.

Specified by:

registerDispatchInterceptor in interface MessageDispatchInterceptorSupport<CommandMessage<?>>

Parameters:

dispatchInterceptor - The interceptor to register

Returns:

A Registration, which may be used to deregister the interceptor.

disconnect

public CompletableFuture<Void> disconnect()

Disconnect the command bus for receiving commands from Axon Server, by unsubscribing all registered command handlers. This shutdown operation is performed in the Phase.INBOUND_COMMAND_CONNECTOR phase.

shutdownDispatching

public CompletableFuture<Void> shutdownDispatching()

Shutdown the command bus asynchronously for dispatching commands to Axon Server. This process will wait for dispatched commands which have not received a response yet. This shutdown operation is performed in the Phase.OUTBOUND_COMMAND_CONNECTORS phase.

Returns:

a completable future which is resolved once all command dispatching activities are completed