Package org.apache.camel.model

Class RecipientListDefinition<Type extends ProcessorDefinition<Type>>

java.lang.Object
org.apache.camel.model.OptionalIdentifiedDefinition<ExpressionNode>
org.apache.camel.model.ProcessorDefinition<ExpressionNode>
org.apache.camel.model.ExpressionNode
org.apache.camel.model.RecipientListDefinition<Type>
All Implemented Interfaces:
org.apache.camel.CamelContextAware, org.apache.camel.LineNumberAware, Block, ExecutorServiceAwareDefinition<RecipientListDefinition<Type>>, HasExpressionType, org.apache.camel.NamedNode, org.apache.camel.spi.HasCamelContext, org.apache.camel.spi.HasId, org.apache.camel.spi.IdAware
@Metadata(label="eip,routing") public class RecipientListDefinition<Type extends ProcessorDefinition<Type>> extends ExpressionNode implements ExecutorServiceAwareDefinition<RecipientListDefinition<Type>>
Route messages to a number of dynamically specified recipients

  • Constructor Details

    • RecipientListDefinition

      public RecipientListDefinition()

    • RecipientListDefinition

      public RecipientListDefinition(ExpressionDefinition expression)

    • RecipientListDefinition

      public RecipientListDefinition(org.apache.camel.Expression expression)

  • Method Details

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • getShortName

      public String getShortName()
      Specified by:
      getShortName in interface org.apache.camel.NamedNode

    • getLabel

      public String getLabel()
      Description copied from class: ProcessorDefinition
      Returns a label to describe this node such as the expression if some kind of expression node
      Specified by:
      getLabel in interface org.apache.camel.NamedNode
      Overrides:
      getLabel in class ExpressionNode

    • end

      public Type end()
      Description copied from class: ProcessorDefinition
      Ends the current block
      Overrides:
      end in class ProcessorDefinition<ExpressionNode>
      Returns:
      the builder

    • delimiter

      public RecipientListDefinition<Type> delimiter(String delimiter)
      Delimiter used if the Expression returned multiple endpoints. Can be turned off using the value false.

      The default value is ,

      Parameters:
      delimiter - the delimiter
      Returns:
      the builder

    • aggregationStrategy

      public RecipientListDefinition<Type> aggregationStrategy(org.apache.camel.AggregationStrategy aggregationStrategy)
      Sets the AggregationStrategy to be used to assemble the replies from the recipients, into a single outgoing message from the RecipientList. By default Camel will use the last reply as the outgoing message. You can also use a POJO as the AggregationStrategy

    • aggregationStrategy

      public RecipientListDefinition<Type> aggregationStrategy(String aggregationStrategy)
      Sets a reference to the AggregationStrategy to be used to assemble the replies from the recipients, into a single outgoing message from the RecipientList. By default Camel will use the last reply as the outgoing message. You can also use a POJO as the AggregationStrategy

    • aggregationStrategyMethodName

      public RecipientListDefinition<Type> aggregationStrategyMethodName(String methodName)
      This option can be used to explicit declare the method name to use, when using POJOs as the AggregationStrategy.
      Parameters:
      methodName - the method name to call
      Returns:
      the builder

    • aggregationStrategyMethodAllowNull

      public RecipientListDefinition<Type> aggregationStrategyMethodAllowNull()
      If this option is false then the aggregate method is not used if there was no data to enrich. If this option is true then null values is used as the oldExchange (when no data to enrich), when using POJOs as the AggregationStrategy
      Returns:
      the builder

    • ignoreInvalidEndpoints

      public RecipientListDefinition<Type> ignoreInvalidEndpoints()
      Ignore the invalidate endpoint exception when try to create a producer with that endpoint
      Returns:
      the builder

    • parallelProcessing

      public RecipientListDefinition<Type> parallelProcessing()
      If enabled then sending messages to the recipients occurs concurrently. Note the caller thread will still wait until all messages has been fully processed, before it continues. Its only the sending and processing the replies from the recipients which happens concurrently. When parallel processing is enabled, then the Camel routing engin will continue processing using last used thread from the parallel thread pool. However, if you want to use the original thread that called the recipient list, then make sure to enable the synchronous option as well.
      Returns:
      the builder

    • parallelProcessing

      public RecipientListDefinition<Type> parallelProcessing(String parallelProcessing)
      If enabled then sending messages to the recipients occurs concurrently. Note the caller thread will still wait until all messages has been fully processed, before it continues. Its only the sending and processing the replies from the recipients which happens concurrently. When parallel processing is enabled, then the Camel routing engin will continue processing using last used thread from the parallel thread pool. However, if you want to use the original thread that called the recipient list, then make sure to enable the synchronous option as well.
      Returns:
      the builder

    • parallelProcessing

      public RecipientListDefinition<Type> parallelProcessing(boolean parallelProcessing)
      If enabled then sending messages to the recipients occurs concurrently. Note the caller thread will still wait until all messages has been fully processed, before it continues. Its only the sending and processing the replies from the recipients which happens concurrently. When parallel processing is enabled, then the Camel routing engin will continue processing using last used thread from the parallel thread pool. However, if you want to use the original thread that called the recipient list, then make sure to enable the synchronous option as well.
      Returns:
      the builder

    • parallelAggregate

      public RecipientListDefinition<Type> parallelAggregate()
      If enabled then the aggregate method on AggregationStrategy can be called concurrently. Notice that this would require the implementation of AggregationStrategy to be implemented as thread-safe. By default this is false meaning that Camel synchronizes the call to the aggregate method. Though in some use-cases this can be used to archive higher performance when the AggregationStrategy is implemented as thread-safe.
      Returns:
      the builder

    • parallelAggregate

      public RecipientListDefinition<Type> parallelAggregate(boolean parallelAggregate)
      If enabled then the aggregate method on AggregationStrategy can be called concurrently. Notice that this would require the implementation of AggregationStrategy to be implemented as thread-safe. By default this is false meaning that Camel synchronizes the call to the aggregate method. Though in some use-cases this can be used to archive higher performance when the AggregationStrategy is implemented as thread-safe.
      Returns:
      the builder

    • parallelAggregate

      public RecipientListDefinition<Type> parallelAggregate(String parallelAggregate)
      If enabled then the aggregate method on AggregationStrategy can be called concurrently. Notice that this would require the implementation of AggregationStrategy to be implemented as thread-safe. By default this is false meaning that Camel synchronizes the call to the aggregate method. Though in some use-cases this can be used to archive higher performance when the AggregationStrategy is implemented as thread-safe.
      Returns:
      the builder

    • synchronous

      public RecipientListDefinition<Type> synchronous()
      Sets whether synchronous processing should be strictly used. When enabled then the same thread is used to continue routing after the recipient list is complete, even if parallel processing is enabled.
      Returns:
      the builder

    • synchronous

      public RecipientListDefinition<Type> synchronous(boolean synchronous)
      Sets whether synchronous processing should be strictly used. When enabled then the same thread is used to continue routing after the recipient list is complete, even if parallel processing is enabled.
      Returns:
      the builder

    • synchronous

      public RecipientListDefinition<Type> synchronous(String synchronous)
      Sets whether synchronous processing should be strictly used. When enabled then the same thread is used to continue routing after the recipient list is complete, even if parallel processing is enabled.
      Returns:
      the builder

    • streaming

      public RecipientListDefinition<Type> streaming()
      If enabled then Camel will process replies out-of-order, eg in the order they come back. If disabled, Camel will process replies in the same order as defined by the recipient list.
      Returns:
      the builder

    • stopOnException

      public RecipientListDefinition<Type> stopOnException()
      Will now stop further processing if an exception or failure occurred during processing of an Exchange and the caused exception will be thrown.

      Will also stop if processing the exchange failed (has a fault message) or an exception was thrown and handled by the error handler (such as using onException). In all situations the recipient list will stop further processing. This is the same behavior as in pipeline, which is used by the routing engine.

      The default behavior is to not stop but continue processing till the end

      Returns:
      the builder

    • executorService

      public RecipientListDefinition<Type> executorService(ExecutorService executorService)
      To use a custom Thread Pool to be used for parallel processing. Notice if you set this option, then parallel processing is automatic implied, and you do not have to enable that option as well.
      Specified by:
      executorService in interface ExecutorServiceAwareDefinition<Type extends ProcessorDefinition<Type>>
      Parameters:
      executorService - the executor service
      Returns:
      the builder

    • executorService

      public RecipientListDefinition<Type> executorService(String executorService)
      Refers to a custom Thread Pool to be used for parallel processing. Notice if you set this option, then parallel processing is automatic implied, and you do not have to enable that option as well.
      Specified by:
      executorService in interface ExecutorServiceAwareDefinition<Type extends ProcessorDefinition<Type>>
      Parameters:
      executorService - reference for a ExecutorService to lookup in the Registry
      Returns:
      the builder

    • onPrepare

      public RecipientListDefinition<Type> onPrepare(org.apache.camel.Processor onPrepare)
      Uses the Processor when preparing the Exchange to be used send. This can be used to deep-clone messages that should be send, or any custom logic needed before the exchange is send.
      Parameters:
      onPrepare - the processor
      Returns:
      the builder

    • onPrepare

      public ProcessClause<RecipientListDefinition<Type>> onPrepare()
      Sets the Processor when preparing the Exchange to be used send using a fluent buidler.

    • onPrepare

      public RecipientListDefinition<Type> onPrepare(String ref)
      Uses the Processor when preparing the Exchange to be send. This can be used to deep-clone messages that should be send, or any custom logic needed before the exchange is send.
      Parameters:
      ref - reference to the processor to lookup in the Registry
      Returns:
      the builder

    • timeout

      public RecipientListDefinition<Type> timeout(long timeout)
      Sets a total timeout specified in millis, when using parallel processing. If the Recipient List hasn't been able to send and process all replies within the given timeframe, then the timeout triggers and the Recipient List breaks out and continues. Notice if you provide a TimeoutAwareAggregationStrategy then the timeout method is invoked before breaking out. If the timeout is reached with running tasks still remaining, certain tasks for which it is difficult for Camel to shut down in a graceful manner may continue to run. So use this option with a bit of care.
      Parameters:
      timeout - timeout in millis
      Returns:
      the builder

    • shareUnitOfWork

      public RecipientListDefinition<Type> shareUnitOfWork()
      Shares the UnitOfWork with the parent and each of the sub messages. Recipient List will by default not share unit of work between the parent exchange and each recipient exchange. This means each sub exchange has its own individual unit of work.
      Returns:
      the builder.

    • cacheSize

      public RecipientListDefinition<Type> cacheSize(int cacheSize)
      Sets the maximum size used by the ProducerCache which is used to cache and reuse producers when using this recipient list, when uris are reused.

      Beware that when using dynamic endpoints then it affects how well the cache can be utilized. If each dynamic endpoint is unique then its best to turn off caching by setting this to -1, which allows Camel to not cache both the producers and endpoints; they are regarded as prototype scoped and will be stopped and discarded after use. This reduces memory usage as otherwise producers/endpoints are stored in memory in the caches.

      However if there are a high degree of dynamic endpoints that have been used before, then it can benefit to use the cache to reuse both producers and endpoints and therefore the cache size can be set accordingly or rely on the default size (1000).

      If there is a mix of unique and used before dynamic endpoints, then setting a reasonable cache size can help reduce memory usage to avoid storing too many non frequent used producers.

      Parameters:
      cacheSize - the cache size, use 0 for default cache size, or -1 to turn cache off.
      Returns:
      the builder

    • cacheSize

      public RecipientListDefinition<Type> cacheSize(String cacheSize)
      Sets the maximum size used by the ProducerCache which is used to cache and reuse producers when using this recipient list, when uris are reused.

      Beware that when using dynamic endpoints then it affects how well the cache can be utilized. If each dynamic endpoint is unique then its best to turn off caching by setting this to -1, which allows Camel to not cache both the producers and endpoints; they are regarded as prototype scoped and will be stopped and discarded after use. This reduces memory usage as otherwise producers/endpoints are stored in memory in the caches.

      However if there are a high degree of dynamic endpoints that have been used before, then it can benefit to use the cache to reuse both producers and endpoints and therefore the cache size can be set accordingly or rely on the default size (1000).

      If there is a mix of unique and used before dynamic endpoints, then setting a reasonable cache size can help reduce memory usage to avoid storing too many non frequent used producers.

      Parameters:
      cacheSize - the cache size, use 0 for default cache size, or -1 to turn cache off.
      Returns:
      the builder

    • getAggregationStrategyBean

      public org.apache.camel.AggregationStrategy getAggregationStrategyBean()

    • getExecutorServiceBean

      public ExecutorService getExecutorServiceBean()
      Description copied from interface: ExecutorServiceAwareDefinition
      Gets the executor service for executing
      Specified by:
      getExecutorServiceBean in interface ExecutorServiceAwareDefinition<Type extends ProcessorDefinition<Type>>

    • getExecutorServiceRef

      public String getExecutorServiceRef()
      Description copied from interface: ExecutorServiceAwareDefinition
      Gets a reference id to lookup the executor service from the registry
      Specified by:
      getExecutorServiceRef in interface ExecutorServiceAwareDefinition<Type extends ProcessorDefinition<Type>>

    • setExpression

      public void setExpression(ExpressionDefinition expression)
      Expression that returns which endpoints (url) to send the message to (the recipients). If the expression return an empty value then the message is not sent to any recipients.
      Overrides:
      setExpression in class ExpressionNode

    • getDelimiter

      public String getDelimiter()

    • setDelimiter

      public void setDelimiter(String delimiter)

    • getParallelProcessing

      public String getParallelProcessing()

    • setParallelProcessing

      public void setParallelProcessing(String parallelProcessing)

    • getSynchronous

      public String getSynchronous()

    • setSynchronous

      public void setSynchronous(String synchronous)

    • getIgnoreInvalidEndpoints

      public String getIgnoreInvalidEndpoints()

    • setIgnoreInvalidEndpoints

      public void setIgnoreInvalidEndpoints(String ignoreInvalidEndpoints)

    • getStopOnException

      public String getStopOnException()

    • setStopOnException

      public void setStopOnException(String stopOnException)

    • getAggregationStrategy

      public String getAggregationStrategy()

    • setAggregationStrategy

      public void setAggregationStrategy(String aggregationStrategy)

    • setAggregationStrategy

      public void setAggregationStrategy(org.apache.camel.AggregationStrategy aggregationStrategy)

    • getAggregationStrategyMethodName

      public String getAggregationStrategyMethodName()

    • setAggregationStrategyMethodName

      public void setAggregationStrategyMethodName(String aggregationStrategyMethodName)

    • getAggregationStrategyMethodAllowNull

      public String getAggregationStrategyMethodAllowNull()

    • setAggregationStrategyMethodAllowNull

      public void setAggregationStrategyMethodAllowNull(String aggregationStrategyMethodAllowNull)

    • getStreaming

      public String getStreaming()

    • setStreaming

      public void setStreaming(String streaming)

    • getTimeout

      public String getTimeout()

    • setTimeout

      public void setTimeout(String timeout)

    • getOnPrepare

      public String getOnPrepare()

    • setOnPrepare

      public void setOnPrepare(String onPrepare)

    • getOnPrepareProcessor

      public org.apache.camel.Processor getOnPrepareProcessor()

    • setOnPrepareProcessor

      public void setOnPrepareProcessor(org.apache.camel.Processor onPrepareProcessor)

    • getShareUnitOfWork

      public String getShareUnitOfWork()

    • setShareUnitOfWork

      public void setShareUnitOfWork(String shareUnitOfWork)

    • getCacheSize

      public String getCacheSize()

    • setCacheSize

      public void setCacheSize(String cacheSize)

    • getParallelAggregate

      public String getParallelAggregate()

    • setParallelAggregate

      public void setParallelAggregate(String parallelAggregate)

    • getExecutorService

      public String getExecutorService()

    • setExecutorService

      public void setExecutorService(String executorService)