Package org.axonframework.messaging.unitofwork

Class DefaultUnitOfWork<T extends Message<?>>

java.lang.Object
org.axonframework.messaging.unitofwork.AbstractUnitOfWork<T>
org.axonframework.messaging.unitofwork.DefaultUnitOfWork<T>
All Implemented Interfaces:
UnitOfWork<T>
public class DefaultUnitOfWork<T extends Message<?>> extends AbstractUnitOfWork<T>
Implementation of the UnitOfWork that processes a single message.
Since:
0.6
Author:
Allard Buijze

  • Constructor Details

    • DefaultUnitOfWork

      public DefaultUnitOfWork(T message)
      Initializes a Unit of Work (without starting it).
      Parameters:
      message - the message that will be processed in the context of the unit of work

  • Method Details

    • startAndGet

      public static <T extends Message<?>> DefaultUnitOfWork<T> startAndGet(T message)
      Starts a new DefaultUnitOfWork instance, registering it a CurrentUnitOfWork. This methods returns the started UnitOfWork instance.

      Note that this Unit Of Work type is not meant to be shared among different Threads. A single DefaultUnitOfWork instance should be used exclusively by the Thread that created it.

      Parameters:
      message - the message that will be processed in the context of the unit of work
      Returns:
      the started UnitOfWork instance

    • executeWithResult

      public <R> ResultMessage<R> executeWithResult(Callable<R> task, @Nonnull RollbackConfiguration rollbackConfiguration)
      Description copied from interface: UnitOfWork
      Execute the given task in the context of this Unit of Work. If the Unit of Work is not started yet it will be started.

      If the task executes successfully the Unit of Work is committed and the result of the task is returned. If execution fails, the rollbackConfiguration determines if the Unit of Work should be rolled back or committed.

      Type Parameters:
      R - the type of result that is returned after successful execution
      Parameters:
      task - the task to execute
      rollbackConfiguration - configuration that determines whether or not to rollback the unit of work when task execution fails
      Returns:
      The result of the task wrapped in Result Message

    • setRollbackCause

      protected void setRollbackCause(Throwable cause)
      Description copied from class: AbstractUnitOfWork
      Sets the cause for rolling back this Unit of Work.
      Specified by:
      setRollbackCause in class AbstractUnitOfWork<T extends Message<?>>
      Parameters:
      cause - The cause for rolling back this Unit of Work

    • notifyHandlers

      protected void notifyHandlers(UnitOfWork.Phase phase)
      Description copied from class: AbstractUnitOfWork
      Notify the handlers attached to the given phase.
      Specified by:
      notifyHandlers in class AbstractUnitOfWork<T extends Message<?>>
      Parameters:
      phase - The phase for which to invoke registered handlers.

    • addHandler

      protected void addHandler(UnitOfWork.Phase phase, Consumer<UnitOfWork<T>> handler)
      Description copied from class: AbstractUnitOfWork
      Register the given handler with the Unit of Work. The handler will be invoked when the Unit of Work changes its phase to the given phase.
      Specified by:
      addHandler in class AbstractUnitOfWork<T extends Message<?>>
      Parameters:
      phase - the Phase of the Unit of Work at which to invoke the handler
      handler - the handler to add

    • getMessage

      public T getMessage()
      Description copied from interface: UnitOfWork
      Get the message that is being processed by the Unit of Work. A Unit of Work processes a single Message over its life cycle.
      Returns:
      the Message being processed by this Unit of Work

    • transformMessage

      public UnitOfWork<T> transformMessage(Function<T,? extends Message<?>> transformOperator)
      Description copied from interface: UnitOfWork
      Transform the Message being processed using the given operator and stores the result.

      Implementations should take caution not to change the message type to a type incompatible with the current Unit of Work. For example, do not return a CommandMessage when transforming an EventMessage.

      Parameters:
      transformOperator - The transform operator to apply to the stored message
      Returns:
      this Unit of Work

    • getExecutionResult

      public ExecutionResult getExecutionResult()
      Description copied from interface: UnitOfWork
      Get the result of the task that was executed by this Unit of Work. If the Unit of Work has not been given a task to execute this method returns null.

      Note that the value of the returned ExecutionResult's ExecutionResult.isExceptionResult() does not determine whether or not the UnitOfWork has been rolled back. To check whether or not the UnitOfWork was rolled back check UnitOfWork.isRolledBack().

      Returns:
      The result of the task executed by this Unit of Work, or null if the Unit of Work has not been given a task to execute.

    • setExecutionResult

      protected void setExecutionResult(ExecutionResult executionResult)
      Description copied from class: AbstractUnitOfWork
      Set the execution result of processing the current Message.
      Specified by:
      setExecutionResult in class AbstractUnitOfWork<T extends Message<?>>
      Parameters:
      executionResult - the ExecutionResult of the currently handled Message