org.apache.camel.processor
Class CamelInternalProcessor

java.lang.Object
  org.apache.camel.support.ServiceSupport
      org.apache.camel.processor.DelegateAsyncProcessor
          org.apache.camel.processor.CamelInternalProcessor

All Implemented Interfaces:

AsyncProcessor, DelegateProcessor, Navigate<Processor>, Processor, Service, ShutdownableService, StatefulService, SuspendableService

Direct Known Subclasses:

DefaultChannel

public class CamelInternalProcessor
extends DelegateAsyncProcessor

Internal Processor that Camel routing engine used during routing for cross cutting functionality such as:

• Execute UnitOfWork
• Keeping track which route currently is being routed
• Execute RoutePolicy
• Gather JMX performance statics
• Tracing
• Debugging
• Message History
• Stream Caching

... and more.

This implementation executes this cross cutting functionality as a CamelInternalProcessorAdvice advice (before and after advice) by executing the CamelInternalProcessorAdvice.before(org.apache.camel.Exchange) and CamelInternalProcessorAdvice.after(org.apache.camel.Exchange, Object) callbacks in correct order during routing. This reduces number of stack frames needed during routing, and reduce the number of lines in stacktraces, as well makes debugging the routing engine easier for end users.

Debugging tips: Camel end users whom want to debug their Camel applications with the Camel source code, then make sure to read the source code of this class about the debugging tips, which you can find in the process(org.apache.camel.Exchange, org.apache.camel.AsyncCallback) method.

Nested Class Summary

static class	CamelInternalProcessor.BacklogDebuggerAdvice Advice to execute the BacklogDebugger if enabled.
static class	CamelInternalProcessor.BacklogTracerAdvice Advice to execute the BacklogTracer if enabled.
static class	CamelInternalProcessor.ChildUnitOfWorkProcessorAdvice Advice when an EIP uses the shareUnitOfWork functionality.
static class	CamelInternalProcessor.DelayerAdvice Advice for delaying
static class	CamelInternalProcessor.InstrumentationAdvice Advice for JMX instrumentation of the process being invoked.
static class	CamelInternalProcessor.MessageHistoryAdvice Advice when Message History has been enabled.
static class	CamelInternalProcessor.RouteContextAdvice Advice to inject the current RouteContext into the UnitOfWork on the Exchange
static class	CamelInternalProcessor.RouteInflightRepositoryAdvice Advice to keep the InflightRepository up to date.
static class	CamelInternalProcessor.RoutePolicyAdvice Advice to execute any RoutePolicy a route may have been configured with.
static class	CamelInternalProcessor.StreamCachingAdvice Advice for StreamCachingStrategy
static class	CamelInternalProcessor.SubUnitOfWorkProcessorAdvice Advice when an EIP uses the shareUnitOfWork functionality.
static class	CamelInternalProcessor.UnitOfWorkProcessorAdvice Advice to inject new UnitOfWork to the Exchange if needed, and as well to ensure the UnitOfWork is done and stopped.

Field Summary

Fields inherited from class org.apache.camel.processor.DelegateAsyncProcessor

processor

Fields inherited from class org.apache.camel.support.ServiceSupport

shutdown, shuttingdown, started, starting, stopped, stopping, suspended, suspending

Constructor Summary

CamelInternalProcessor()

CamelInternalProcessor(Processor processor)

Method Summary

void	addAdvice(CamelInternalProcessorAdvice advice) Adds an CamelInternalProcessorAdvice advice to the list of advices to execute by this internal processor.
protected boolean	continueProcessing(Exchange exchange) Strategy to determine if we should continue processing the Exchange.
<T> T	getAdvice(Class<T> type) Gets the advice with the given type.
boolean	process(Exchange exchange, AsyncCallback callback) Processes the message exchange.
String	toString()

Methods inherited from class org.apache.camel.processor.DelegateAsyncProcessor

doStart, doStop, getProcessor, hasNext, next, process, processNext, setProcessor, setProcessor

Methods inherited from class org.apache.camel.support.ServiceSupport

doResume, doShutdown, doSuspend, getStatus, getVersion, isRunAllowed, isStarted, isStarting, isStopped, isStopping, isStoppingOrStopped, isSuspended, isSuspending, resume, shutdown, start, stop, suspend

Methods inherited from class java.lang.Object

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

Constructor Detail

CamelInternalProcessor

public CamelInternalProcessor()

CamelInternalProcessor

public CamelInternalProcessor(Processor processor)

Method Detail

addAdvice

public void addAdvice(CamelInternalProcessorAdvice advice)

Adds an CamelInternalProcessorAdvice advice to the list of advices to execute by this internal processor.

Parameters:

advice - the advice to add

getAdvice

public <T> T getAdvice(Class<T> type)

Gets the advice with the given type.

Parameters:

type - the type of the advice

Returns:

the advice if exists, or null if no advices has been added with the given type.

process

public boolean process(Exchange exchange,
                       AsyncCallback callback)

Description copied from interface: AsyncProcessor

Processes the message exchange. Similar to Processor.process(org.apache.camel.Exchange), but the caller supports having the exchange asynchronously processed.

If there was a failure processing then the caused Exception would be set on the Exchange.

Specified by:

process in interface AsyncProcessor

Overrides:

process in class DelegateAsyncProcessor

Parameters:

exchange - the message exchange

callback - the AsyncCallback will be invoked when the processing of the exchange is completed. If the exchange is completed synchronously, then the callback is also invoked synchronously. The callback should therefore be careful of starting recursive loop.

Returns:

(doneSync) true to continue execute synchronously, false to continue being executed asynchronously

toString

public String toString()

Overrides:

toString in class DelegateAsyncProcessor

continueProcessing

protected boolean continueProcessing(Exchange exchange)

Strategy to determine if we should continue processing the Exchange.