|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
ConsumerTemplate
instance with a minimum of XMLCamelContext and install routes either explicitly configured
or found by searching the classpath for Java classes which extend
RouteBuilder.ProducerTemplate
instance with a minimum of XMLExecutorService objectsDataFormat)
interface which leverage the Castor library for XML marshaling and
unmarshalingExchange events.DataFormat) interface which leverage the XStream library for XML or JSON's marshaling and unmarshalingProducerCache.releaseProducer(org.apache.camel.Endpoint, org.apache.camel.Producer) method.
Exchange under the correlation key.
BundleTrackerCustomizer.addingBundle method.
BundleTracker.
InterceptStrategy to apply each Exchange before
its routed to the next Processor.
InterceptStrategy to apply each Exchange before
its routed to the next Processor.
Synchronization to be invoked as callback when
this exchange is completed.
callback to allow you to do custom
logic when an Endpoint is about to be registered to the CamelContext endpoint registry.
includeRoutes instead.
CamelContext have just been started.
Object to the given list
Exchange has been processed (after).
Exchange has been processed which allows implementators
to notify breakpoints.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.MemoryAggregationRepository
Service has already been stopped.Expression object from an annotation on a field, property or method parameter
of a specified type.MailMessage
RouteBuilder instances that can be found in the context
RouteBuilder instances that can be found on the classpath
MailMessage
JmsMessage
JmsMessage
Registry implementation which looks up the objects in the Spring
ApplicationContextNode
MockEndpoint instances registered
in the given context are valid
MockEndpoint instances registered
in the given context are valid
AsyncProcessor so that it can
notify you when an Exchange is done.Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback.AsyncProcessor objects.Processor to an AsyncProcessor.AsyncProcessor capable producer.Feed object is stored on the in message on the exchange.
Exchange in a thread-safe wayMessageScriptContext.ENGINE_SCOPE
GLoginData.setAuthenticationToken(String) (only if needed by
GLoginService.authorize(GLoginData)).
GLoginData.setAuthenticationToken(String).
GLoginData.setAuthorizationCookie(String).
GLoginServiceImpl.authorizeDev(GLoginData) if the
endpoint is configured to run in development mode, otherwise to
GLoginServiceImpl.authorizeStd(GLoginData).
GLoginData.setAuthorizationCookie(String)
.
GLoginData.setAuthorizationCookie(String).
Processor for working on BAM which a derived
class would do the actual persistence such as the JpaBamProcessorBatchResequencerConfig.
EndpointResequencer.BatchResequencerConfig instance using default
values for batchSize (100) and batchTimeout
(1000L).
BatchResequencerConfig instance using the given
values for batchSize and batchTimeout.
BeanELResolver which also supports the resolving of methodsRegistry and use that to handle message dispatching.beanName.methodName which is then invoked using the
beanName to lookup in the bean integration to bind the
Exchange to the method arguments.Processor which converts the inbound exchange to a method
invocation on a POJOExchange is about to be processed (before).
Exchange is about to be processed which allows implementators
to notify breakpoints.
Predicate implementationsWebClient APIs.
WebClient APIs.
MessageContentsList) to allow
an appropriate converter to kick in even through we only read the first
element off the MessageContextList.
Response object.
BindyAbstractFactory implements what its common to all the formats
supported by camel bindyDataFormat) using Bindy to marshal to and from CSV filesDataFormatDataFormat) using Bindy to marshal to and from Fixed LengthDataFormat) using Bindy to marshal to and from CSV filesMessageBreakpoint are used by the Debugger API.Breakpoint implementations to use as base class.Endpoint may choose to implement which allows it to
expose a way of browsing the exchanges available.List of Exchange instances
which can be useful for tooling, debugging and visualising routes.BundleTracker class simplifies tracking bundles much like
the ServiceTracker simplifies tracking services.BundleTracker for bundles whose state is present in
the specified state mask.
BundleTrackerCustomizer interface allows a
BundleTracker to customize the Bundles that are
tracked.Source from a byte[]
which can be read as many times as required.CamelContextResourceProducerTemplate to easily exchange messages with the Server.ConsumerTemplate
instance with a minimum of XMLFactoryBean for creating a new ConsumerTemplate
instance with a minimum of XMLCamelContext such as when working with Spring or GuiceCamelContext
BlueprintCamelContext
and install routes either explicitly configured in
Blueprint XML or found by searching the classpath for Java classes which extend
RouteBuilder using the nested CamelContextFactoryBean.setPackages(String[]).FactoryBean to create and initialize a
SpringCamelContext and install routes either explicitly configured in
Spring XML or found by searching the classpath for Java classes which extend
RouteBuilder using the nested CamelContextFactoryBean.setPackages(String[]).CamelContext from the Spring ApplicationContext.endpoints
or routesPredicate or Expression
to a ProcessorEndpoint objectsFactoryBean which instantiates Endpoint objectsApplicationEvent which contains a Camel ExchangeProcessorExchangeExchange.ProducerTemplate to easily exchange messages with the Server.InvocationHandler which invokes a
message exchange on a camel EndpointCamelContext leaving it up to the users module
to bind a SetRoutesBuilder which are bound to Guice with an optional Matcher to filter out the classes required.RoutesBuilder types - which are then injected by Guice.ProducerTemplate
instance with a minimum of XMLFactoryBean for creating a new ProducerTemplate
instance with a minimum of XMLPropertyPlaceholderDefinition represents a <propertyPlaceholder/> element.FactoryBean to create a Proxy to a a Camel Pojo Endpoint.FactoryBean to create a proxy to a service exposing a given RemoteExporter.getServiceInterface()CamelContext with some routes
along with a ProducerTemplate for use in the test caseCamelContext with some routes
along with a ProducerTemplate for use in the test caseExecutorService objectsFactoryBean which instantiates ExecutorService objectsDataFormat) using Castor to marshal to and from XMLDataFormat.Processors in the route graph.Registry and use that to handle message dispatching.BundleTracker.
IOHelper.close(java.io.Closeable, String, org.apache.commons.logging.Log)
Producer which just appends to a Collection the Exchange object.Exchange is complete.
BatchConsumer
and aggregate the total number of exchanges the BatchConsumer has reported
as total by checking the exchange property Exchange.BATCH_COMPLETE when its complete.
Endpoint objects.DefaultComponentResolverCompositePackageScanFilter allows multiple
PackageScanFilters to be composed into a single filter.Exchange matches when is being routed.Condition implementations to use as base class.DocLiteralInInterceptor.KEEP_PARAMETERS_WRAPPER.JmsConfiguration.setDeliveryPersistent(boolean),
JmsConfiguration.setPriority(int) or JmsConfiguration.setTimeToLive(long) then we should auto default the
setting of JmsConfiguration.setExplicitQosEnabled(boolean) if its not been configured yet
Exchange.
BeanHolderEndpoint either via its
URI or via the name of the endpoint reference
which is then resolved in a registry such as the Spring Application Context.EndpointConsumer.Message instances in an
Exchange from an Endpoint.BundleTracker.
ContextScanDefinition represents a <contextScan/> element.RouteBuilder instances on the
Spring ApplicationContext.Exchange.
Registry to an endpoint using
some kind of transformation or wrapper
InvalidPayloadException is thrown.Integer
ExecResult to the type T.
source exchange to target exchange
preserving the ExchangePattern of target.
Resequencer instance applying the given
config.
EventObject for Camel has been started successfully.
EventObject for Camel is starting.
EventObject for Camel failing to start
EventObject for Camel failing to stop cleanly
EventObject for Camel has been stopped successfully.
EventObject for Camel is stopping.
Channel.
Pipeline but derived classes could change the behaviour
UnsupportedOperationException
ConsumerTemplate which is started and therefore ready to use right away.
ConsumerTemplate which is started and therefore ready to use right away.
Message from a Camel exchange.
CxfEndpoint which, can be a Spring bean endpoint having
URI format cxf:bean:beanId or transport address endpoint having URI format
cxf://transportAddress.
Registry
OnExceptionDefinition should be used.
DataSet
ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange
EventObject when an Exchange has been completed successfully
EventObject when an Exchange has been created
EventObject when an Exchange has failed
EventObject when an Exchange has failed
but was handled by the Camel error handlers such as an dead letter channel.
EventObject when an Exchange is about to be redelivered
EventObject when an Exchange has completely been sent to the endpoint.
HttpClient instance
HttpClient instance
Producers and consumers should use the HttpEndpoint.getHttpClient() method instead.
ConsumerTemplate to be injected into a POJO
PollingConsumer to be injected into a POJO
Producer to be injected into a POJO
ProducerTemplate to be injected into a POJO
JmsOperations object used for one way messaging
JmsOperations object used for request/response using a request timeout value
IOException from the given
exception and message
IOException from the given
exception and message
Map from a MapMessage
ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange
ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange
ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange
PollingConsumer.receive(),
PollingConsumer.receiveNoWait() or
PollingConsumer.receive(long) whenever it is ready to do so
rather than using the Event
Based Consumer returned by Endpoint.createConsumer(Processor)
ProcessorExchangePair which holds the processor and exchange to be send out.
GAuthProducer
GLoginProducer.
ProducerTemplate which is started and therefore ready to use right away.
ProducerTemplate which is started and therefore ready to use right away.
DefaultExchange instance from the given
exchange.
ResultHandler to use
RouteBuilder
to define the routes for testing
RouteBuilder
to define the routes for testing
RouteBuilders to define the routes for testing
RouteBuilders to define the routes for testing
EventObject for Route has been started successfully.
EventObject for Route has been stopped successfully.
EventObject for a Service failed to start cleanly
EventObject for a Service failed to stop cleanly
StreamResequencer instance applying the given
config.
CryptoDataFormat uses a specified key and algorithm to encrypt,
decrypt and verify exchange payloads.DataFormatCxfBeanDestination.CxfBeanEndpoint which represents a
bean.Destination that listens
Camel Exchange from an associated CxfBeanEndpoint.ProcessorEndpoint which associated with
a CxfBeanDestination.Exchange
and Camel Exchange.DataFormat.PAYLOAD is used.DataFormat
options.DataFormat operations.