Package | Description |
---|---|
org.apache.camel |
The core Camel API.
|
org.apache.camel.builder | |
org.apache.camel.component |
Base classes for Components
|
org.apache.camel.component.bean |
The Bean Component which will look up the
bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO
|
org.apache.camel.component.beanclass |
The Class Component for invoking Java classes from Camel
|
org.apache.camel.component.binding |
The Binding Component which is
a way of wrapping an Endpoint in a contract; such as a Data Format, a Content Enricher or validation step.
|
org.apache.camel.component.browse |
The Browse Component which is a simple in memory
component which maintains a list of all message exchanges which can be useful for debugging, tooling or visualistion.
|
org.apache.camel.component.controlbus |
The Control Bus Component which
allows to manage Camel at runtime.
|
org.apache.camel.component.dataformat |
The DataFormat Component
allows to use Data Format as a Camel Component.
|
org.apache.camel.component.dataset |
A DataSet Endpoint for testing of endpoints using defined DataSets
|
org.apache.camel.component.direct |
The Direct Component which synchronously invokes
all the consumers when a producer sends an exchange to the endpoint.
|
org.apache.camel.component.directvm |
The Direct VM Component which synchronously invokes
the consumer when a producer sends an exchange to the endpoint.
|
org.apache.camel.component.file |
The File Component for working with file systems.
|
org.apache.camel.component.language |
The Language Component to send messages to language endpoints executing
the script.
|
org.apache.camel.component.log |
The Log Component uses Jakarta Commons Logging to log message exchanges.
|
org.apache.camel.component.mock |
The Mock Component which is used for testing of routing and mediation rules.
|
org.apache.camel.component.properties |
The Properties Component for lookup of property
placeholders for endpoint URI.
|
org.apache.camel.component.ref |
The Ref Component for lookup of existing
endpoints bound in the
Registry . |
org.apache.camel.component.rest |
The REST Component for defining REST services, supporting
the Camel Rest DSL.
|
org.apache.camel.component.saga | |
org.apache.camel.component.scheduler |
The Scheduler Component to schedule routes
|
org.apache.camel.component.seda | |
org.apache.camel.component.stub |
The Stub Component which is used for stubbing endpoints.
|
org.apache.camel.component.test |
A Test Endpoint for Pattern Based Testing
|
org.apache.camel.component.timer |
The Timer Component provides a
simple timer
|
org.apache.camel.component.validator |
The Validator Component for validating XML against some schema
|
org.apache.camel.component.vm |
The VM Component for asynchronous
SEDA exchanges on a
BlockingQueue
within the current JVM; so across CamelContext instances.
|
org.apache.camel.component.xslt |
The XSLT Component for transforming messages with XSLT
|
org.apache.camel.impl |
Default implementation classes for Camel Core
|
org.apache.camel.impl.saga | |
org.apache.camel.management |
Camel management
|
org.apache.camel.management.event |
Camel management events
|
org.apache.camel.management.mbean |
Camel management JMX MBeans
|
org.apache.camel.model |
The JAXB POJOs for the
XML Configuration
of the routing rules.
|
org.apache.camel.processor |
A collection of Processor
implementations which are used to implement the
Enterprise Integration Patterns
|
org.apache.camel.processor.interceptor |
Helper classes for interceptors.
|
org.apache.camel.processor.loadbalancer |
Various load balancer processors
|
org.apache.camel.saga | |
org.apache.camel.spi |
Service Provider Interfaces used internally by the Camel runtime which are plugin strategies.
|
org.apache.camel.support |
Base classes that help to implement the camel API and are expected to be extended by the user
|
org.apache.camel.util |
Utility classes used by the core of Camel.
|
org.apache.camel.util.component |
Base classes and utilities for API based components
|
Modifier and Type | Interface and Description |
---|---|
interface |
AsyncEndpoint
Marks the
Endpoint as support asynchronous non-blocking routing in its consumer and producer. |
interface |
DelegateEndpoint
An interface to represent an
Endpoint which are delegated. |
Modifier and Type | Method and Description |
---|---|
<T extends Endpoint> |
CamelContext.getEndpoint(String name,
Class<T> endpointType)
Resolves the given name to an
Endpoint of the specified type. |
Modifier and Type | Method and Description |
---|---|
Endpoint |
CamelContext.addEndpoint(String uri,
Endpoint endpoint)
Adds the endpoint to the
EndpointRegistry using the given URI. |
Endpoint |
ComponentConfiguration.createEndpoint()
Deprecated.
Converts the configuration into a URI and then looks up the endpoint in the
CamelContext
which typically results in a new Endpoint instance being created. |
Endpoint |
Component.createEndpoint(String uri)
Attempt to resolve an endpoint for the given URI if the component is
capable of handling the URI.
|
Endpoint |
FluentProducerTemplate.getDefaultEndpoint()
Get the default endpoint to use if none is specified
|
Endpoint |
ProducerTemplate.getDefaultEndpoint()
Get the default endpoint to use if none is specified
|
Endpoint |
ProxyInstantiationException.getEndpoint() |
Endpoint |
EndpointAware.getEndpoint()
Gets the endpoint associated with an object.
|
Endpoint |
DelegateEndpoint.getEndpoint()
Gets the delegated
Endpoint . |
Endpoint |
CamelContext.getEndpoint(String uri)
Resolves the given name to an
Endpoint of the specified type. |
Endpoint |
Exchange.getFromEndpoint()
Returns the endpoint which originated this message exchange if a consumer on an endpoint
created the message exchange, otherwise this property will be null
|
Endpoint |
CamelContext.hasEndpoint(String uri)
Is the given endpoint already registered in the
EndpointRegistry |
Modifier and Type | Method and Description |
---|---|
Map<String,Endpoint> |
CamelContext.getEndpointMap()
Returns a new
Map containing all of the endpoints from the EndpointRegistry |
Collection<Endpoint> |
CamelContext.getEndpoints()
Returns a new
Collection of all of the endpoints from the EndpointRegistry |
ServicePool<Endpoint,PollingConsumer> |
CamelContext.getPollingConsumerServicePool()
Gets the service pool for
Producer pooling. |
ServicePool<Endpoint,Producer> |
CamelContext.getProducerServicePool()
Gets the service pool for
Producer pooling. |
Collection<Endpoint> |
CamelContext.removeEndpoints(String pattern)
Removes all endpoints with the given URI from the
EndpointRegistry . |
Modifier and Type | Method and Description |
---|---|
Endpoint |
CamelContext.addEndpoint(String uri,
Endpoint endpoint)
Adds the endpoint to the
EndpointRegistry using the given URI. |
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(Endpoint endpoint,
Exchange exchange,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(Endpoint endpoint,
Processor processor,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint using a supplied processor.
|
CompletableFuture<Object> |
ProducerTemplate.asyncCallbackRequestBody(Endpoint endpoint,
Object body,
Synchronization onCompletion)
Sends an asynchronous body to the given endpoint.
|
CompletableFuture<Object> |
ProducerTemplate.asyncCallbackSendBody(Endpoint endpoint,
Object body,
Synchronization onCompletion)
Sends an asynchronous body to the given endpoint.
|
CompletableFuture<Object> |
ProducerTemplate.asyncRequestBody(Endpoint endpoint,
Object body)
Sends an asynchronous body to the given endpoint.
|
<T> CompletableFuture<T> |
ProducerTemplate.asyncRequestBody(Endpoint endpoint,
Object body,
Class<T> type)
Sends an asynchronous body to the given endpoint.
|
CompletableFuture<Object> |
ProducerTemplate.asyncRequestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue)
Sends an asynchronous body to the given endpoint.
|
<T> CompletableFuture<T> |
ProducerTemplate.asyncRequestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue,
Class<T> type)
Sends an asynchronous body to the given endpoint.
|
CompletableFuture<Object> |
ProducerTemplate.asyncRequestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers)
Sends an asynchronous body to the given endpoint.
|
<T> CompletableFuture<T> |
ProducerTemplate.asyncRequestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers,
Class<T> type)
Sends an asynchronous body to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(Endpoint endpoint,
Exchange exchange)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(Endpoint endpoint,
Processor processor)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Object> |
ProducerTemplate.asyncSendBody(Endpoint endpoint,
Object body)
Sends an asynchronous body to the given endpoint.
|
void |
ComponentConfiguration.configureEndpoint(Endpoint endpoint)
Deprecated.
Applies the current set of parameters to the given endpoint instance.
|
Object |
ComponentConfiguration.getEndpointParameter(Endpoint endpoint,
String name)
Deprecated.
Gets the named URI parameter value on the given endpoint
|
Exchange |
ConsumerTemplate.receive(Endpoint endpoint)
Receives from the endpoint, waiting until there is a response.
|
Exchange |
ConsumerTemplate.receive(Endpoint endpoint,
long timeout)
Receives from the endpoint, waiting until there is a response
or the timeout occurs
Important: See
ConsumerTemplate.doneUoW(Exchange) |
Object |
ConsumerTemplate.receiveBody(Endpoint endpoint)
Receives from the endpoint, waiting until there is a response
|
<T> T |
ConsumerTemplate.receiveBody(Endpoint endpoint,
Class<T> type)
Receives from the endpoint, waiting until there is a response
|
Object |
ConsumerTemplate.receiveBody(Endpoint endpoint,
long timeout)
Receives from the endpoint, waiting until there is a response
or the timeout occurs
|
<T> T |
ConsumerTemplate.receiveBody(Endpoint endpoint,
long timeout,
Class<T> type)
Receives from the endpoint, waiting until there is a response
or the timeout occurs
|
Object |
ConsumerTemplate.receiveBodyNoWait(Endpoint endpoint)
Receives from the endpoint, not waiting for a response if non exists.
|
<T> T |
ConsumerTemplate.receiveBodyNoWait(Endpoint endpoint,
Class<T> type)
Receives from the endpoint, not waiting for a response if non exists.
|
Exchange |
ConsumerTemplate.receiveNoWait(Endpoint endpoint)
Receives from the endpoint, not waiting for a response if non exists.
|
void |
CamelContext.removeEndpoint(Endpoint endpoint)
Removes the endpoint from the
EndpointRegistry . |
Exchange |
ProducerTemplate.request(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Uses an
ExchangePattern.InOut message exchange pattern. |
Object |
ProducerTemplate.requestBody(Endpoint endpoint,
Object body)
Send the body to an endpoint returning any result output body.
|
<T> T |
ProducerTemplate.requestBody(Endpoint endpoint,
Object body,
Class<T> type)
Send the body to an endpoint returning any result output body.
|
Object |
ProducerTemplate.requestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue)
Send the body to an endpoint returning any result output body.
|
<T> T |
ProducerTemplate.requestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue,
Class<T> type)
Send the body to an endpoint returning any result output body.
|
Object |
ProducerTemplate.requestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers)
Sends the body to an endpoint with the specified headers and header values.
|
<T> T |
ProducerTemplate.requestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers,
Class<T> type)
Sends the body to an endpoint with the specified headers and header values.
|
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Exchange exchange)
Sends the exchange to the given endpoint
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Object |
ProducerTemplate.sendBody(Endpoint endpoint,
ExchangePattern pattern,
Object body)
Send the body to an endpoint with the given
ExchangePattern
returning any result output body
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
void |
ProducerTemplate.sendBody(Endpoint endpoint,
Object body)
Send the body to an endpoint
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
Object |
ProducerTemplate.sendBodyAndHeader(Endpoint endpoint,
ExchangePattern pattern,
Object body,
String header,
Object headerValue)
Sends the body to an endpoint with a specified header and header value
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
void |
ProducerTemplate.sendBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue)
Sends the body to an endpoint with a specified header and header value
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
Object |
ProducerTemplate.sendBodyAndHeaders(Endpoint endpoint,
ExchangePattern pattern,
Object body,
Map<String,Object> headers)
Sends the body to an endpoint with the specified headers and header values
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
void |
ProducerTemplate.sendBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers)
Sends the body to an endpoint with the specified headers and header values
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
Object |
ProducerTemplate.sendBodyAndProperty(Endpoint endpoint,
ExchangePattern pattern,
Object body,
String property,
Object propertyValue)
Sends the body to an endpoint with a specified property and property value
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
void |
ProducerTemplate.sendBodyAndProperty(Endpoint endpoint,
Object body,
String property,
Object propertyValue)
Sends the body to an endpoint with a specified property and property value
Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with
the caused exception wrapped. |
void |
FluentProducerTemplate.setDefaultEndpoint(Endpoint defaultEndpoint)
Sets the default endpoint to use if none is specified
|
void |
ProducerTemplate.setDefaultEndpoint(Endpoint defaultEndpoint)
Sets the default endpoint to use if none is specified
|
void |
ComponentConfiguration.setEndpointParameter(Endpoint endpoint,
String name,
Object value)
Deprecated.
Sets the named URI query parameter value on the given endpoint
|
void |
Exchange.setFromEndpoint(Endpoint fromEndpoint)
Sets the endpoint which originated this message exchange.
|
FluentProducerTemplate |
FluentProducerTemplate.to(Endpoint endpoint)
Endpoint to send to
|
Modifier and Type | Method and Description |
---|---|
void |
CamelContext.setPollingConsumerServicePool(ServicePool<Endpoint,PollingConsumer> servicePool)
Sets a pluggable service pool to use for
PollingConsumer pooling. |
void |
CamelContext.setProducerServicePool(ServicePool<Endpoint,Producer> servicePool)
Sets a pluggable service pool to use for
Producer pooling. |
Constructor and Description |
---|
FailedToCreateConsumerException(Endpoint endpoint,
String message) |
FailedToCreateConsumerException(Endpoint endpoint,
String message,
Throwable cause) |
FailedToCreateConsumerException(Endpoint endpoint,
Throwable cause) |
FailedToCreateProducerException(Endpoint endpoint,
Throwable cause) |
ProxyInstantiationException(Class<?> type,
Endpoint endpoint,
Throwable cause) |
Modifier and Type | Field and Description |
---|---|
protected Endpoint |
DefaultErrorHandlerBuilder.deadLetter |
Modifier and Type | Method and Description |
---|---|
<T extends Endpoint> |
BuilderSupport.endpoint(String uri,
Class<T> type)
Resolves the given URI to an endpoint of the specified type
|
Modifier and Type | Method and Description |
---|---|
Endpoint |
BuilderSupport.endpoint(String uri)
Resolves the given URI to an endpoint
|
Endpoint |
DefaultErrorHandlerBuilder.getDeadLetter() |
Endpoint |
DefaultFluentProducerTemplate.getDefaultEndpoint() |
Modifier and Type | Method and Description |
---|---|
List<Endpoint> |
BuilderSupport.endpoints(Endpoint... endpoints)
Helper method to create a list of
Endpoint instances |
List<Endpoint> |
BuilderSupport.endpoints(String... uris)
Resolves the list of URIs into a list of
Endpoint instances |
Modifier and Type | Method and Description |
---|---|
DeadLetterChannelBuilder |
BuilderSupport.deadLetterChannel(Endpoint deadLetterEndpoint)
Dead Letter Channel EIP:
is a error handler for handling messages that could not be delivered to it's intended destination.
|
ProxyBuilder |
ProxyBuilder.endpoint(Endpoint endpoint)
Send the proxied message to this endpoint
|
List<Endpoint> |
BuilderSupport.endpoints(Endpoint... endpoints)
Helper method to create a list of
Endpoint instances |
RouteDefinition |
RouteBuilder.from(Endpoint... endpoints)
Creates a new route from the given endpoint
|
RouteDefinition |
RouteBuilder.from(Endpoint endpoint)
Creates a new route from the given endpoint
|
static AdviceWithTask |
AdviceWithTasks.replaceFrom(RouteDefinition route,
Endpoint endpoint) |
void |
AdviceWithRouteBuilder.replaceFromWith(Endpoint endpoint)
Replaces the route from endpoint with a new endpoint
|
void |
DefaultErrorHandlerBuilder.setDeadLetter(Endpoint deadLetter) |
void |
DefaultFluentProducerTemplate.setDefaultEndpoint(Endpoint defaultEndpoint) |
FluentProducerTemplate |
DefaultFluentProducerTemplate.to(Endpoint endpoint) |
Constructor and Description |
---|
DeadLetterChannelBuilder(Endpoint deadLetter) |
Modifier and Type | Class and Description |
---|---|
class |
ResourceEndpoint
A useful base class for endpoints which depend on a resource
such as things like Velocity or XQuery based components.
|
Modifier and Type | Class and Description |
---|---|
class |
BeanEndpoint
The bean component is for invoking Java beans from Camel.
|
Modifier and Type | Field and Description |
---|---|
protected Endpoint |
AbstractCamelInvocationHandler.endpoint |
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
BeanComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Method and Description |
---|---|
protected static MethodInfoCache |
ProxyHelper.createMethodInfoCache(Endpoint endpoint) |
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
boolean binding,
Class<T>... interfaceClasses)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
boolean binding,
ClassLoader cl,
Class<T>... interfaceClasses)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
boolean binding,
ClassLoader cl,
Class<T>[] interfaceClasses,
MethodInfoCache methodCache)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
boolean binding,
ClassLoader cl,
Class<T> interfaceClass,
MethodInfoCache methodCache)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
boolean binding,
Producer producer,
Class<T>... interfaceClasses)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
PojoProxyHelper.createProxy(Endpoint endpoint,
Class<?>... interfaceClasses) |
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
Class<T>... interfaceClasses)
Deprecated.
use the same method name with binding as parameter
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
Class<T> interfaceClass)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
ClassLoader cl,
Class<T>... interfaceClasses)
Deprecated.
use the same method name with binding as parameter
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
ClassLoader cl,
Class<T> interfaceClass)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
ClassLoader cl,
Class<T>[] interfaceClasses,
MethodInfoCache methodCache)
Deprecated.
use the same method name with binding as parameter
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
ClassLoader cl,
Class<T> interfaceClass,
MethodInfoCache methodCache)
Deprecated.
use the same method name with binding as parameter
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
Producer producer,
Class<T>... interfaceClasses)
Deprecated.
use the same method name with binding as parameter
|
static <T> T |
ProxyHelper.createProxy(Endpoint endpoint,
Producer producer,
Class<T> interfaceClass)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxyObject(Endpoint endpoint,
boolean binding,
Producer producer,
ClassLoader classLoader,
Class<T>[] interfaces,
MethodInfoCache methodCache)
Creates a Proxy which sends the exchange to the endpoint.
|
static <T> T |
ProxyHelper.createProxyObject(Endpoint endpoint,
Producer producer,
ClassLoader classLoader,
Class<T>[] interfaces,
MethodInfoCache methodCache)
Deprecated.
use the same method name with binding as parameter
|
Constructor and Description |
---|
AbstractCamelInvocationHandler(Endpoint endpoint,
Producer producer) |
CamelInvocationHandler(Endpoint endpoint,
boolean binding,
Producer producer,
MethodInfoCache methodInfoCache) |
CamelInvocationHandler(Endpoint endpoint,
Producer producer,
MethodInfoCache methodInfoCache)
Deprecated.
|
PojoMessageInvocationHandler(Endpoint endpoint,
Producer producer) |
Constructor and Description |
---|
BeanComponent(Class<? extends Endpoint> endpointClass) |
Modifier and Type | Class and Description |
---|---|
class |
ClassEndpoint
The Class Component is for invoking Java Classes (Java beans) from Camel.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
ClassComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
BindingEndpoint
Deprecated.
use
Contract instead |
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
BindingNameComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
protected Endpoint |
BindingComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters)
Deprecated.
|
Endpoint |
BindingEndpoint.getDelegate()
Deprecated.
|
Constructor and Description |
---|
BindingEndpoint(String uri,
Component component,
Binding binding,
Endpoint delegate)
Deprecated.
|
Modifier and Type | Class and Description |
---|---|
class |
BrowseEndpoint
The browse component is used for viewing the messages received on endpoints that supports
BrowsableEndpoint . |
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
BrowseComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
ControlBusEndpoint
The controlbus component provides easy management of Camel applications based on the Control Bus EIP pattern.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
ControlBusComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Constructor and Description |
---|
ControlBusProducer(Endpoint endpoint,
CamelLogger logger) |
Modifier and Type | Class and Description |
---|---|
class |
DataFormatEndpoint
The dataformat component is used for working with Data Formats as if it was a regular Component supporting Endpoints and URIs.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
DataFormatComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
DataSetEndpoint
The dataset component provides a mechanism to easily perform load & soak testing of your system.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
DataSetComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
DirectEndpoint
The direct component provides direct, synchronous call to another endpoint from the same CamelContext.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
DirectComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Constructor and Description |
---|
DirectConsumer(Endpoint endpoint,
Processor processor) |
Modifier and Type | Class and Description |
---|---|
class |
DirectVmEndpoint
The direct-vm component provides direct, synchronous call to another endpoint from any CamelContext in the same JVM.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
DirectVmComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Method and Description |
---|---|
static Collection<Endpoint> |
DirectVmComponent.getConsumerEndpoints()
Gets all the consumer endpoints.
|
Modifier and Type | Class and Description |
---|---|
class |
FileEndpoint
The file component is used for reading or writing files.
|
class |
GenericFileEndpoint<T>
Base class for file endpoints
|
Modifier and Type | Class and Description |
---|---|
class |
LanguageEndpoint
The language component allows you to send a message to an endpoint which executes a script by any of the supported Languages in Camel.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
LanguageComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
LogEndpoint
The log component logs message exchanges to the underlying logging mechanism.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
LogComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Constructor and Description |
---|
LogProducer(Endpoint endpoint,
Processor logger) |
Modifier and Type | Class and Description |
---|---|
class |
MockEndpoint
The mock component is used for testing routes and mediation rules using mocks.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
MockComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
PropertiesEndpoint
The properties component is used for using property placeholders in endpoint uris.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
PropertiesComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Endpoint |
PropertiesEndpoint.getEndpoint() |
Constructor and Description |
---|
PropertiesEndpoint(String endpointUri,
Endpoint delegate,
Component component) |
Modifier and Type | Class and Description |
---|---|
class |
RefEndpoint
The ref component is used for lookup of existing endpoints bound in the Registry.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
RefComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Endpoint |
RefEndpoint.getEndpoint() |
Modifier and Type | Class and Description |
---|---|
class |
RestApiEndpoint
The rest-api component is used for providing Swagger API of the REST services which has been defined using the rest-dsl in Camel.
|
class |
RestEndpoint
The rest component is used for either hosting REST services (consumer) or calling external REST services (producer).
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
RestComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
protected Endpoint |
RestApiComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Constructor and Description |
---|
RestApiProducer(Endpoint endpoint,
Processor processor) |
RestProducer(Endpoint endpoint,
Producer producer,
RestConfiguration configuration) |
Modifier and Type | Class and Description |
---|---|
class |
SagaEndpoint
The saga component provides access to advanced options for managing the flow in the Saga EIP.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
SagaComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
SchedulerEndpoint
The scheduler component is used for generating message exchanges when a scheduler fires.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
SchedulerComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
SedaEndpoint
The seda component provides asynchronous call to another endpoint from any CamelContext in the same JVM.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
SedaComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Endpoint |
SedaConsumer.getEndpoint() |
Constructor and Description |
---|
CollectionProducer(Endpoint endpoint,
Collection<Exchange> queue)
Deprecated.
|
SedaPollingConsumer(Endpoint endpoint) |
Constructor and Description |
---|
SedaComponent(Class<? extends Endpoint> endpointClass) |
Modifier and Type | Class and Description |
---|---|
class |
StubEndpoint
The stub component provides a simple way to stub out any physical endpoints while in development or testing.
|
Modifier and Type | Class and Description |
---|---|
class |
TestEndpoint
The test component extends the mock component by on startup to pull messages from another endpoint to set the expected message bodies.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
TestComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Method and Description |
---|---|
void |
TestEndpoint.setExpectedMessageEndpoint(Endpoint expectedMessageEndpoint) |
Modifier and Type | Class and Description |
---|---|
class |
TimerEndpoint
The timer component is used for generating message exchanges when a timer fires.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
TimerComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
ValidatorEndpoint
Validates the payload of a message using XML Schema and JAXP Validation.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
ValidatorComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Constructor and Description |
---|
ValidatorProducer(Endpoint endpoint,
ValidatingProcessor validatingProcessor) |
Constructor and Description |
---|
ValidatorComponent(Class<? extends Endpoint> endpointClass) |
Modifier and Type | Class and Description |
---|---|
class |
VmEndpoint
The vm component provides asynchronous call to another endpoint from the same CamelContext.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
VmComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Constructor and Description |
---|
VmComponent(Class<? extends Endpoint> endpointClass) |
Modifier and Type | Class and Description |
---|---|
class |
XsltEndpoint
Transforms the message using a XSLT template.
|
Modifier and Type | Method and Description |
---|---|
protected Endpoint |
XsltComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Modifier and Type | Class and Description |
---|---|
class |
DefaultEndpoint
A default endpoint useful for implementation inheritance.
|
class |
DefaultPollingEndpoint
A base class for an endpoint which the default consumer mode is to use a
PollingConsumer |
class |
InterceptSendToEndpoint
This is an endpoint when sending to it, is intercepted and is routed in a detour
|
class |
ProcessorEndpoint
An endpoint which allows exchanges to be sent into it which just invokes a
given
Processor . |
class |
ScheduledPollEndpoint
A base class for
Endpoint which creates a ScheduledPollConsumer |
Modifier and Type | Method and Description |
---|---|
<T extends Endpoint> |
DefaultCamelContext.getEndpoint(String name,
Class<T> endpointType) |
<T extends Endpoint> |
DefaultProducerTemplate.getResolvedEndpoint(String endpointUri,
Class<T> expectedClass)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
Endpoint |
DefaultCamelContext.addEndpoint(String uri,
Endpoint endpoint) |
protected Endpoint |
DefaultCamelContext.addEndpointToRegistry(String uri,
Endpoint endpoint)
Strategy to add the given endpoint to the internal endpoint registry
|
protected Endpoint |
DefaultCamelContext.convertBeanToEndpoint(String uri,
Object bean)
Strategy method for attempting to convert the bean from a
Registry to an endpoint using
some kind of transformation or wrapper |
Endpoint |
ComponentConfigurationSupport.createEndpoint()
Deprecated.
|
protected Endpoint |
DefaultCamelContext.createEndpoint(String uri)
A pluggable strategy to allow an endpoint to be created without requiring
a component to be its factory, such as for looking up the URI inside some
Registry |
Endpoint |
DefaultComponent.createEndpoint(String uri) |
protected abstract Endpoint |
DefaultComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters)
A factory method allowing derived components to create a new endpoint
from the given URI, remaining path and optional parameters
|
Endpoint |
DefaultEndpointRegistry.get(Object o) |
Endpoint |
DefaultProducerTemplate.getDefaultEndpoint() |
Endpoint |
InterceptSendToEndpoint.getDelegate() |
Endpoint |
SynchronousDelegateProducer.getEndpoint() |
Endpoint |
InterceptSendToEndpointProcessor.getEndpoint() |
Endpoint |
DefaultRouteContext.getEndpoint() |
Endpoint |
PollingConsumerSupport.getEndpoint() |
Endpoint |
DefaultConsumer.getEndpoint() |
Endpoint |
DeferProducer.getEndpoint() |
Endpoint |
DefaultProducer.getEndpoint() |
Endpoint |
SubscribeMethodProcessor.getEndpoint() |
Endpoint |
DefaultRoute.getEndpoint() |
Endpoint |
DefaultCamelContext.getEndpoint(String uri) |
Endpoint |
CamelPostProcessorHelper.getEndpointInjection(Object bean,
String uri,
String name,
String propertyName,
String injectionPointName,
boolean mandatory) |
Endpoint |
DefaultExchange.getFromEndpoint() |
protected Endpoint |
DefaultProducerTemplate.getMandatoryDefaultEndpoint() |
Endpoint |
DefaultCamelContext.hasEndpoint(String uri) |
Endpoint |
DefaultEndpointRegistry.put(org.apache.camel.impl.EndpointKey key,
Endpoint endpoint) |
Endpoint |
InterceptSendToMockEndpointStrategy.registerEndpoint(String uri,
Endpoint endpoint) |
Endpoint |
DefaultEndpointRegistry.remove(Object o) |
Endpoint |
DefaultRouteContext.resolveEndpoint(String uri) |
Endpoint |
DefaultRouteContext.resolveEndpoint(String uri,
String ref) |
protected Endpoint |
DefaultProducerTemplate.resolveMandatoryEndpoint(String endpointUri) |
protected Endpoint |
DefaultConsumerTemplate.resolveMandatoryEndpoint(String endpointUri) |
Modifier and Type | Method and Description |
---|---|
Set<Map.Entry<org.apache.camel.impl.EndpointKey,Endpoint>> |
DefaultEndpointRegistry.entrySet() |
Set<Endpoint> |
RouteService.gatherEndpoints()
Gather all the endpoints this route service uses
This implementation finds the endpoints by searching all the child services
for
EndpointAware processors which uses an endpoint. |
Class<? extends Endpoint> |
UriEndpointComponent.getEndpointClass()
Deprecated.
|
Class<? extends Endpoint> |
UriComponentConfiguration.getEndpointClass()
Deprecated.
|
Class<? extends Endpoint> |
UriEndpointConfiguration.getEndpointClass()
Deprecated.
|
Map<String,Endpoint> |
DefaultCamelContext.getEndpointMap() |
Collection<Endpoint> |
DefaultCamelContext.getEndpoints() |
ServicePool<Endpoint,PollingConsumer> |
DefaultCamelContext.getPollingConsumerServicePool() |
ServicePool<Endpoint,Producer> |
DefaultCamelContext.getProducerServicePool() |
Collection<Endpoint> |
DefaultCamelContext.removeEndpoints(String uri) |
Collection<Endpoint> |
DefaultEndpointRegistry.values() |
Modifier and Type | Method and Description |
---|---|
PollingConsumer |
ConsumerCache.acquirePollingConsumer(Endpoint endpoint)
Acquires a pooled PollingConsumer which you must release back again after usage using the
ConsumerCache.releasePollingConsumer(org.apache.camel.Endpoint, org.apache.camel.PollingConsumer) method. |
PollingConsumer |
EmptyConsumerCache.acquirePollingConsumer(Endpoint endpoint) |
Producer |
EmptyProducerCache.acquireProducer(Endpoint endpoint) |
Producer |
ProducerCache.acquireProducer(Endpoint endpoint)
Acquires a pooled producer which you must release back again after usage using the
ProducerCache.releaseProducer(org.apache.camel.Endpoint, org.apache.camel.Producer) method. |
Endpoint |
DefaultCamelContext.addEndpoint(String uri,
Endpoint endpoint) |
protected Endpoint |
DefaultCamelContext.addEndpointToRegistry(String uri,
Endpoint endpoint)
Strategy to add the given endpoint to the internal endpoint registry
|
protected void |
SubscribeMethodProcessor.addMethod(Object pojo,
Method method,
Endpoint endpoint,
String predicate) |
protected void |
DefaultComponent.afterConfiguration(String uri,
String remaining,
Endpoint endpoint,
Map<String,Object> parameters)
Strategy to do post configuration logic.
|
protected CompletableFuture<Object> |
DefaultProducerTemplate.asyncCallback(Endpoint endpoint,
ExchangePattern pattern,
Object body,
Synchronization onCompletion) |
CompletableFuture<Exchange> |
DefaultProducerTemplate.asyncCallback(Endpoint endpoint,
Exchange exchange,
Synchronization onCompletion) |
CompletableFuture<Exchange> |
DefaultProducerTemplate.asyncCallback(Endpoint endpoint,
Processor processor,
Synchronization onCompletion) |
CompletableFuture<Object> |
DefaultProducerTemplate.asyncCallbackRequestBody(Endpoint endpoint,
Object body,
Synchronization onCompletion) |
CompletableFuture<Object> |
DefaultProducerTemplate.asyncCallbackSendBody(Endpoint endpoint,
Object body,
Synchronization onCompletion) |
protected boolean |
ProducerCache.asyncDispatchExchange(Endpoint endpoint,
Producer producer,
Processor resultProcessor,
Exchange exchange,
AsyncCallback callback) |
protected CompletableFuture<Exchange> |
DefaultProducerTemplate.asyncRequest(Endpoint endpoint,
Processor processor,
Processor resultProcessor) |
CompletableFuture<Object> |
DefaultProducerTemplate.asyncRequestBody(Endpoint endpoint,
Object body) |
<T> CompletableFuture<T> |
DefaultProducerTemplate.asyncRequestBody(Endpoint endpoint,
Object body,
Class<T> type) |
protected CompletableFuture<Object> |
DefaultProducerTemplate.asyncRequestBody(Endpoint endpoint,
Processor processor) |
protected <T> CompletableFuture<T> |
DefaultProducerTemplate.asyncRequestBody(Endpoint endpoint,
Processor processor,
Class<T> type) |
protected CompletableFuture<Object> |
DefaultProducerTemplate.asyncRequestBody(Endpoint endpoint,
Processor processor,
Processor resultProcessor) |
CompletableFuture<Object> |
DefaultProducerTemplate.asyncRequestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue) |
<T> CompletableFuture<T> |
DefaultProducerTemplate.asyncRequestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue,
Class<T> type) |
CompletableFuture<Object> |
DefaultProducerTemplate.asyncRequestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers) |
<T> CompletableFuture<T> |
DefaultProducerTemplate.asyncRequestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers,
Class<T> type) |
CompletableFuture<Exchange> |
DefaultProducerTemplate.asyncSend(Endpoint endpoint,
Exchange exchange) |
protected CompletableFuture<Exchange> |
DefaultProducerTemplate.asyncSend(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor) |
CompletableFuture<Exchange> |
ProducerCache.asyncSend(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
CompletableFuture<Exchange> future)
Asynchronously sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
CompletableFuture<Exchange> |
DefaultProducerTemplate.asyncSend(Endpoint endpoint,
Processor processor) |
CompletableFuture<Object> |
DefaultProducerTemplate.asyncSendBody(Endpoint endpoint,
Object body) |
protected CompletableFuture<Exchange> |
DefaultProducerTemplate.asyncSendExchange(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
Exchange inExchange) |
CompletableFuture<Exchange> |
ProducerCache.asyncSendExchange(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
Exchange exchange,
CompletableFuture<Exchange> future)
Asynchronously sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
boolean |
DefaultPollingConsumerPollStrategy.begin(Consumer consumer,
Endpoint endpoint) |
void |
DefaultPollingConsumerPollStrategy.commit(Consumer consumer,
Endpoint endpoint,
int polledMessages) |
void |
LimitedPollingConsumerPollStrategy.commit(Consumer consumer,
Endpoint endpoint,
int polledMessages) |
void |
ComponentConfigurationSupport.configureEndpoint(Endpoint endpoint)
Deprecated.
Configures the properties on the given endpoint
|
protected PollingConsumer |
CamelPostProcessorHelper.createInjectionPollingConsumer(Endpoint endpoint,
Object bean,
String beanName)
Factory method to create a started
PollingConsumer to be injected into a POJO |
protected Producer |
CamelPostProcessorHelper.createInjectionProducer(Endpoint endpoint,
Object bean,
String beanName)
A Factory method to create a started
Producer to
be injected into a POJO |
protected RuntimeException |
CamelPostProcessorHelper.createProxyInstantiationRuntimeException(Class<?> type,
Endpoint endpoint,
Exception e) |
protected PollingConsumer |
ConsumerCache.doGetPollingConsumer(Endpoint endpoint,
boolean pooled) |
protected Producer |
ProducerCache.doGetProducer(Endpoint endpoint,
boolean pooled) |
boolean |
ProducerCache.doInAsyncProducer(Endpoint endpoint,
Exchange exchange,
ExchangePattern pattern,
AsyncCallback callback,
AsyncProducerCallback producerCallback)
Sends an exchange to an endpoint using a supplied callback supporting the asynchronous routing engine.
|
<T> T |
ProducerCache.doInProducer(Endpoint endpoint,
Exchange exchange,
ExchangePattern pattern,
ProducerCallback<T> callback)
Sends an exchange to an endpoint using a supplied callback, using the synchronous processing.
|
PollingConsumer |
ConsumerCache.getConsumer(Endpoint endpoint) |
protected SubscribeMethodProcessor |
CamelPostProcessorHelper.getConsumerProcessor(Endpoint endpoint) |
protected org.apache.camel.impl.EndpointKey |
DefaultCamelContext.getEndpointKey(String uri,
Endpoint endpoint)
Gets the endpoint key to use for lookup or whe adding endpoints to the
DefaultEndpointRegistry |
Object |
UriComponentConfiguration.getEndpointParameter(Endpoint endpoint,
String name)
Deprecated.
|
Object |
DefaultComponentConfiguration.getEndpointParameter(Endpoint endpoint,
String name)
Deprecated.
|
protected boolean |
InterceptSendToMockEndpointStrategy.matchPattern(String uri,
Endpoint endpoint,
String pattern)
Does the pattern match the endpoint?
|
protected Producer |
InterceptSendToMockEndpointStrategy.onInterceptEndpoint(String uri,
Endpoint endpoint,
MockEndpoint mockEndpoint,
Producer mockProducer)
Callback when an endpoint was intercepted with the given mock endpoint
|
protected boolean |
LimitedPollingConsumerPollStrategy.onRollback(Consumer consumer,
Endpoint endpoint)
Rollback occurred.
|
protected void |
LimitedPollingConsumerPollStrategy.onSuspend(Consumer consumer,
Endpoint endpoint)
The consumer is to be suspended because it exceeded the limit
|
Endpoint |
DefaultEndpointRegistry.put(org.apache.camel.impl.EndpointKey key,
Endpoint endpoint) |
Exchange |
ConsumerCache.receive(Endpoint endpoint) |
Exchange |
DefaultConsumerTemplate.receive(Endpoint endpoint) |
Exchange |
ConsumerCache.receive(Endpoint endpoint,
long timeout) |
Exchange |
DefaultConsumerTemplate.receive(Endpoint endpoint,
long timeout) |
Object |
DefaultConsumerTemplate.receiveBody(Endpoint endpoint) |
<T> T |
DefaultConsumerTemplate.receiveBody(Endpoint endpoint,
Class<T> type) |
Object |
DefaultConsumerTemplate.receiveBody(Endpoint endpoint,
long timeout) |
<T> T |
DefaultConsumerTemplate.receiveBody(Endpoint endpoint,
long timeout,
Class<T> type) |
Object |
DefaultConsumerTemplate.receiveBodyNoWait(Endpoint endpoint) |
<T> T |
DefaultConsumerTemplate.receiveBodyNoWait(Endpoint endpoint,
Class<T> type) |
Exchange |
ConsumerCache.receiveNoWait(Endpoint endpoint) |
Exchange |
DefaultConsumerTemplate.receiveNoWait(Endpoint endpoint) |
Endpoint |
InterceptSendToMockEndpointStrategy.registerEndpoint(String uri,
Endpoint endpoint) |
void |
ConsumerCache.releasePollingConsumer(Endpoint endpoint,
PollingConsumer pollingConsumer)
Releases an acquired producer back after usage.
|
void |
EmptyConsumerCache.releasePollingConsumer(Endpoint endpoint,
PollingConsumer pollingConsumer) |
void |
EmptyProducerCache.releaseProducer(Endpoint endpoint,
Producer producer) |
void |
ProducerCache.releaseProducer(Endpoint endpoint,
Producer producer)
Releases an acquired producer back after usage.
|
void |
DefaultCamelContext.removeEndpoint(Endpoint endpoint) |
Exchange |
DefaultProducerTemplate.request(Endpoint endpoint,
Processor processor) |
Object |
DefaultProducerTemplate.requestBody(Endpoint endpoint,
Object body) |
<T> T |
DefaultProducerTemplate.requestBody(Endpoint endpoint,
Object body,
Class<T> type) |
Object |
DefaultProducerTemplate.requestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue) |
<T> T |
DefaultProducerTemplate.requestBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue,
Class<T> type) |
Object |
DefaultProducerTemplate.requestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers) |
<T> T |
DefaultProducerTemplate.requestBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers,
Class<T> type) |
boolean |
DefaultPollingConsumerPollStrategy.rollback(Consumer consumer,
Endpoint endpoint,
int retryCounter,
Exception e) |
boolean |
LimitedPollingConsumerPollStrategy.rollback(Consumer consumer,
Endpoint endpoint,
int retryCounter,
Exception cause) |
Exchange |
DefaultProducerTemplate.send(Endpoint endpoint,
Exchange exchange) |
void |
ProducerCache.send(Endpoint endpoint,
Exchange exchange)
Sends the exchange to the given endpoint.
|
Exchange |
DefaultProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor) |
Exchange |
ProducerCache.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
Exchange |
DefaultProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor) |
Exchange |
ProducerCache.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor)
Sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
Exchange |
DefaultProducerTemplate.send(Endpoint endpoint,
Processor processor) |
Exchange |
ProducerCache.send(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
Object |
DefaultProducerTemplate.sendBody(Endpoint endpoint,
ExchangePattern pattern,
Object body) |
void |
DefaultProducerTemplate.sendBody(Endpoint endpoint,
Object body) |
Object |
DefaultProducerTemplate.sendBodyAndHeader(Endpoint endpoint,
ExchangePattern pattern,
Object body,
String header,
Object headerValue) |
void |
DefaultProducerTemplate.sendBodyAndHeader(Endpoint endpoint,
Object body,
String header,
Object headerValue) |
Object |
DefaultProducerTemplate.sendBodyAndHeaders(Endpoint endpoint,
ExchangePattern pattern,
Object body,
Map<String,Object> headers) |
void |
DefaultProducerTemplate.sendBodyAndHeaders(Endpoint endpoint,
Object body,
Map<String,Object> headers) |
Object |
DefaultProducerTemplate.sendBodyAndProperty(Endpoint endpoint,
ExchangePattern pattern,
Object body,
String property,
Object propertyValue) |
void |
DefaultProducerTemplate.sendBodyAndProperty(Endpoint endpoint,
Object body,
String property,
Object propertyValue) |
protected Exchange |
ProducerCache.sendExchange(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
Exchange exchange) |
void |
DefaultProducerTemplate.setDefaultEndpoint(Endpoint defaultEndpoint) |
void |
HeaderFilterStrategyComponent.setEndpointHeaderFilterStrategy(Endpoint endpoint)
Sets the header filter strategy to use from the given endpoint if the endpoint is a
HeaderFilterStrategyAware type. |
void |
UriComponentConfiguration.setEndpointParameter(Endpoint endpoint,
String name,
Object value)
Deprecated.
|
void |
DefaultComponentConfiguration.setEndpointParameter(Endpoint endpoint,
String name,
Object value)
Deprecated.
|
void |
DefaultExchange.setFromEndpoint(Endpoint fromEndpoint) |
int |
DefaultInflightRepository.size(Endpoint endpoint)
Deprecated.
|
void |
ProducerCache.startProducer(Endpoint endpoint)
|
Modifier and Type | Method and Description |
---|---|
static SortedMap<String,ParameterConfiguration> |
UriEndpointComponent.createParameterConfigurationMap(Class<? extends Endpoint> endpointClass)
Deprecated.
Returns a newly created sorted map, indexed by name of all the parameter configurations
of the given endpoint class using introspection for the various annotations like
UriEndpoint , UriParam , UriParams |
void |
DefaultEndpointRegistry.putAll(Map<? extends org.apache.camel.impl.EndpointKey,? extends Endpoint> map) |
void |
UriEndpointComponent.setEndpointClass(Class<? extends Endpoint> endpointClass)
Deprecated.
To use a specific endpoint class, instead of what has been provided by the constructors.
|
void |
DefaultCamelContext.setPollingConsumerServicePool(ServicePool<Endpoint,PollingConsumer> pollingConsumerServicePool) |
void |
DefaultCamelContext.setProducerServicePool(ServicePool<Endpoint,Producer> producerServicePool) |
Constructor and Description |
---|
ConsumerCache(Object source,
CamelContext camelContext,
Map<String,PollingConsumer> cache,
ServicePool<Endpoint,PollingConsumer> pool) |
DefaultEndpointRegistry(CamelContext context,
Map<org.apache.camel.impl.EndpointKey,Endpoint> endpoints) |
HeaderFilterStrategyComponent(CamelContext context,
Class<? extends Endpoint> endpointClass) |
HeaderFilterStrategyComponent(Class<? extends Endpoint> endpointClass) |
ProducerCache(Object source,
CamelContext camelContext,
ServicePool<Endpoint,Producer> producerServicePool,
Map<String,Producer> cache) |
UriComponentConfiguration(Component component,
Class<? extends Endpoint> endpointClass)
Deprecated.
|
UriComponentConfiguration(Component component,
Class<? extends Endpoint> endpointClass,
SortedMap<String,ParameterConfiguration> parameterConfigurationMap)
Deprecated.
|
UriEndpointComponent(CamelContext context,
Class<? extends Endpoint> endpointClass)
Deprecated.
|
UriEndpointComponent(Class<? extends Endpoint> endpointClass)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
CompletableFuture<Boolean> |
InMemorySagaCoordinator.doFinalize(Function<CamelSagaStep,Optional<Endpoint>> endpointExtractor,
String description) |
Modifier and Type | Method and Description |
---|---|
Endpoint |
PublishEventNotifier.getEndpoint() |
Modifier and Type | Method and Description |
---|---|
protected String |
DefaultManagementNamingStrategy.getEndpointId(Endpoint ep) |
Object |
DefaultManagementObjectStrategy.getManagedObjectForEndpoint(CamelContext context,
Endpoint endpoint) |
ObjectName |
DefaultManagementNamingStrategy.getObjectNameForEndpoint(Endpoint endpoint) |
void |
DefaultManagementLifecycleStrategy.onEndpointAdd(Endpoint endpoint)
If the endpoint is an instance of ManagedResource then register it with the
mbean server, if it is not then wrap the endpoint in a
ManagedEndpoint and
register that with the mbean server. |
void |
DefaultManagementLifecycleStrategy.onEndpointRemove(Endpoint endpoint) |
void |
PublishEventNotifier.setEndpoint(Endpoint endpoint) |
Modifier and Type | Method and Description |
---|---|
Endpoint |
ExchangeSentEvent.getEndpoint() |
Endpoint |
ExchangeSendingEvent.getEndpoint() |
Modifier and Type | Method and Description |
---|---|
EventObject |
DefaultEventFactory.createExchangeSendingEvent(Exchange exchange,
Endpoint endpoint) |
EventObject |
DefaultEventFactory.createExchangeSentEvent(Exchange exchange,
Endpoint endpoint,
long timeTaken) |
Constructor and Description |
---|
ExchangeSendingEvent(Exchange source,
Endpoint endpoint) |
ExchangeSentEvent(Exchange source,
Endpoint endpoint,
long timeTaken) |
Modifier and Type | Method and Description |
---|---|
Endpoint |
ManagedEndpoint.getEndpoint() |
Endpoint |
ManagedEndpoint.getInstance() |
Constructor and Description |
---|
ManagedEndpoint(Endpoint endpoint) |
Modifier and Type | Field and Description |
---|---|
protected Endpoint |
SendDefinition.endpoint |
Modifier and Type | Method and Description |
---|---|
Endpoint |
FromDefinition.getEndpoint()
Gets tne endpoint if an
Endpoint instance was set. |
Endpoint |
SendDefinition.getEndpoint()
Gets tne endpoint if an
Endpoint instance was set. |
Endpoint |
RouteDefinition.resolveEndpoint(CamelContext camelContext,
String uri) |
Endpoint |
FromDefinition.resolveEndpoint(RouteContext context) |
Endpoint |
SendDefinition.resolveEndpoint(RouteContext context) |
Modifier and Type | Method and Description |
---|---|
protected static String |
FromDefinition.description(String uri,
String ref,
Endpoint endpoint) |
RouteDefinition |
RouteDefinition.from(Endpoint... endpoints)
Creates inputs to the route
|
RouteDefinition |
RoutesDefinition.from(Endpoint... endpoints)
Creates a new route from the given endpoints
|
RouteDefinition |
RouteDefinition.from(Endpoint endpoint)
Creates an input to the route
|
RouteDefinition |
RoutesDefinition.from(Endpoint endpoint)
Creates a new route from the given endpoint
|
static RouteDefinition |
RouteDefinition.fromEndpoint(Endpoint endpoint) |
Type |
ProcessorDefinition.inOnly(Endpoint... endpoints)
Sends the message to the given endpoints using an
Event Message or
InOnly exchange pattern
Notice the existing MEP is restored after the message has been sent to the given endpoint.
|
Type |
ProcessorDefinition.inOnly(Endpoint endpoint)
Sends the message to the given endpoint using an
Event Message or
InOnly exchange pattern
Notice the existing MEP is restored after the message has been sent to the given endpoint.
|
Type |
ProcessorDefinition.inOut(Endpoint... endpoints)
Sends the message to the given endpoints using an
Request Reply or
InOut exchange pattern
Notice the existing MEP is restored after the message has been sent to the given endpoint.
|
Type |
ProcessorDefinition.inOut(Endpoint endpoint)
Sends the message to the given endpoint using an
Request Reply or
InOut exchange pattern
Notice the existing MEP is restored after the message has been sent to the given endpoint.
|
Type |
ProcessorDefinition.pipeline(Endpoint... endpoints)
Pipes and Filters EIP:
Creates a
Pipeline of the list of endpoints so that the message
will get processed by each endpoint in turn and for request/response the
output of one endpoint will be the input of the next endpoint |
void |
FromDefinition.setEndpoint(Endpoint endpoint) |
void |
SendDefinition.setEndpoint(Endpoint endpoint) |
Type |
ProcessorDefinition.to(Endpoint... endpoints)
Sends the exchange to a list of endpoints
|
Type |
ProcessorDefinition.to(Endpoint endpoint)
Sends the exchange to the given endpoint
|
Type |
ProcessorDefinition.to(ExchangePattern pattern,
Endpoint... endpoints)
Sends the exchange to a list of endpoints
Notice the existing MEP is preserved
|
Type |
ProcessorDefinition.to(ExchangePattern pattern,
Endpoint endpoint)
Sends the exchange with certain exchange pattern to the given endpoint
Notice the existing MEP is preserved
|
WireTapDefinition<Type> |
ProcessorDefinition.wireTap(Endpoint endpoint)
WireTap EIP:
Sends messages to all its child outputs; so that each processor and
destination gets a copy of the original message to avoid the processors
interfering with each other using
ExchangePattern.InOnly . |
Modifier and Type | Method and Description |
---|---|
Type |
ProcessorDefinition.inOnly(Iterable<Endpoint> endpoints)
Sends the message to the given endpoints using an
Event Message or
InOnly exchange pattern
Notice the existing MEP is restored after the message has been sent to the given endpoint.
|
Type |
ProcessorDefinition.inOut(Iterable<Endpoint> endpoints)
Sends the message to the given endpoints using an
Request Reply or
InOut exchange pattern
Notice the existing MEP is restored after the message has been sent to the given endpoint.
|
Type |
ProcessorDefinition.pipeline(Collection<Endpoint> endpoints)
Pipes and Filters EIP:
Creates a
Pipeline of the list of endpoints so that the message
will get processed by each endpoint in turn and for request/response the
output of one endpoint will be the input of the next endpoint |
Type |
ProcessorDefinition.to(ExchangePattern pattern,
Iterable<Endpoint> endpoints)
Sends the exchange to a list of endpoints
|
Type |
ProcessorDefinition.to(Iterable<Endpoint> endpoints)
Sends the exchange to a list of endpoints
|
Constructor and Description |
---|
FromDefinition(Endpoint endpoint) |
InOnlyDefinition(Endpoint endpoint) |
InOutDefinition(Endpoint endpoint) |
RouteDefinition(Endpoint endpoint) |
ToDefinition(Endpoint endpoint) |
ToDefinition(Endpoint endpoint,
ExchangePattern pattern) |
Modifier and Type | Field and Description |
---|---|
protected Endpoint |
SendProcessor.destination |
Modifier and Type | Method and Description |
---|---|
Endpoint |
SendProcessor.getDestination() |
Endpoint |
UnitOfWorkProducer.getEndpoint() |
Endpoint |
SendProcessor.getEndpoint() |
protected static Endpoint |
RecipientListProcessor.resolveEndpoint(Exchange exchange,
Object recipient) |
protected Endpoint |
RecipientList.resolveEndpoint(Exchange exchange,
Object recipient) |
protected Endpoint |
Enricher.resolveEndpoint(Exchange exchange,
Object recipient) |
protected Endpoint |
PollEnricher.resolveEndpoint(Exchange exchange,
Object recipient) |
protected static Endpoint |
SendDynamicProcessor.resolveEndpoint(Exchange exchange,
Object recipient) |
protected Endpoint |
RoutingSlip.resolveEndpoint(RoutingSlip.RoutingSlipIterator iter,
Exchange exchange) |
Modifier and Type | Method and Description |
---|---|
protected Exchange |
SendDynamicProcessor.configureExchange(Exchange exchange,
ExchangePattern pattern,
ExchangePattern destinationExchangePattern,
Endpoint endpoint) |
protected AsyncProcessor |
RoutingSlip.createErrorHandler(RouteContext routeContext,
Exchange exchange,
AsyncProcessor processor,
Endpoint endpoint) |
protected ProcessorExchangePair |
RecipientListProcessor.createProcessorExchangePair(int index,
Endpoint endpoint,
Producer producer,
Exchange exchange,
ExchangePattern pattern)
This logic is similar to MulticastProcessor but we have to return a RecipientProcessorExchangePair instead
|
static Producer |
DeferServiceFactory.createProducer(Endpoint endpoint)
Creates the
Producer which is deferred started until CamelContext is being started. |
protected Exchange |
RoutingSlip.prepareExchangeForRoutingSlip(Exchange current,
Endpoint endpoint) |
protected boolean |
RoutingSlip.processExchange(Endpoint endpoint,
Exchange exchange,
Exchange original,
AsyncCallback originalCallback,
RoutingSlip.RoutingSlipIterator iter) |
void |
SendProcessor.setDestination(Endpoint destination)
Deprecated.
not longer supported.
|
Constructor and Description |
---|
SendProcessor(Endpoint destination) |
SendProcessor(Endpoint destination,
ExchangePattern pattern) |
Modifier and Type | Method and Description |
---|---|
Endpoint |
Tracer.getDestination()
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
void |
Tracer.setDestination(Endpoint destination)
Deprecated.
|
Constructor and Description |
---|
LoadBalancerConsumer(Endpoint endpoint,
Processor processor,
LoadBalancer loadBalancer) |
Modifier and Type | Method and Description |
---|---|
Optional<Endpoint> |
CamelSagaStep.getCompensation() |
Optional<Endpoint> |
CamelSagaStep.getCompletion() |
Constructor and Description |
---|
CamelSagaStep(Optional<Endpoint> compensation,
Optional<Endpoint> completion,
Map<String,Expression> options,
Optional<Long> timeoutInMilliseconds) |
CamelSagaStep(Optional<Endpoint> compensation,
Optional<Endpoint> completion,
Map<String,Expression> options,
Optional<Long> timeoutInMilliseconds) |
Modifier and Type | Interface and Description |
---|---|
interface |
BrowsableEndpoint
An optional interface an
Endpoint may choose to implement which allows it to
expose a way of browsing the exchanges available. |
Modifier and Type | Method and Description |
---|---|
Endpoint |
EndpointStrategy.registerEndpoint(String uri,
Endpoint endpoint)
Register the endpoint.
|
Endpoint |
RouteContext.resolveEndpoint(String uri)
Resolves an endpoint from the URI
|
Endpoint |
RouteContext.resolveEndpoint(String uri,
String ref)
Resolves an endpoint from either a URI or a named reference
|
Modifier and Type | Method and Description |
---|---|
boolean |
PollingConsumerPollStrategy.begin(Consumer consumer,
Endpoint endpoint)
Called when poll is about to begin
|
void |
PollingConsumerPollStrategy.commit(Consumer consumer,
Endpoint endpoint,
int polledMessages)
Called when poll is completed successfully
|
EventObject |
EventFactory.createExchangeSendingEvent(Exchange exchange,
Endpoint endpoint)
Creates an
EventObject when an Exchange is about to be sent to the endpoint (eg before). |
EventObject |
EventFactory.createExchangeSentEvent(Exchange exchange,
Endpoint endpoint,
long timeTaken)
Creates an
EventObject when an Exchange has completely been sent to the endpoint (eg after). |
Object |
ManagementObjectStrategy.getManagedObjectForEndpoint(CamelContext context,
Endpoint endpoint) |
ObjectName |
ManagementNamingStrategy.getObjectNameForEndpoint(Endpoint endpoint) |
void |
LifecycleStrategy.onEndpointAdd(Endpoint endpoint)
Notification on adding an
Endpoint . |
void |
LifecycleStrategy.onEndpointRemove(Endpoint endpoint)
Notification on removing an
Endpoint . |
Endpoint |
EndpointStrategy.registerEndpoint(String uri,
Endpoint endpoint)
Register the endpoint.
|
boolean |
PollingConsumerPollStrategy.rollback(Consumer consumer,
Endpoint endpoint,
int retryCounter,
Exception cause)
Called when poll failed
|
int |
InflightRepository.size(Endpoint endpoint)
Deprecated.
will be removed in a future Camel release.
|
Modifier and Type | Method and Description |
---|---|
void |
LifecycleStrategySupport.onEndpointAdd(Endpoint endpoint) |
void |
LifecycleStrategySupport.onEndpointRemove(Endpoint endpoint) |
Modifier and Type | Method and Description |
---|---|
static <T extends Endpoint> |
CamelContextHelper.getMandatoryEndpoint(CamelContext camelContext,
String uri,
Class<T> type)
Returns the mandatory endpoint for the given URI and type or the
NoSuchEndpointException is thrown |
Modifier and Type | Method and Description |
---|---|
static Endpoint |
CamelContextHelper.getEndpointInjection(CamelContext camelContext,
String uri,
String ref,
String injectionPointName,
boolean mandatory)
Evaluates the @EndpointInject annotation using the given context
|
static Endpoint |
CamelContextHelper.getMandatoryEndpoint(CamelContext camelContext,
String uri)
Returns the mandatory endpoint for the given URI or the
NoSuchEndpointException is thrown |
static Endpoint |
ExchangeHelper.resolveEndpoint(Exchange exchange,
Object value)
Attempts to resolve the endpoint for the given value
|
Modifier and Type | Method and Description |
---|---|
static String |
EndpointHelper.getRouteIdFromEndpoint(Endpoint endpoint)
Gets the route id for the given endpoint in which there is a consumer listening.
|
static String |
EndpointHelper.lookupEndpointRegistryId(Endpoint endpoint)
Lookup the id the given endpoint has been enlisted with in the
Registry . |
static boolean |
EventHelper.notifyExchangeSending(CamelContext context,
Exchange exchange,
Endpoint endpoint) |
static boolean |
EventHelper.notifyExchangeSent(CamelContext context,
Exchange exchange,
Endpoint endpoint,
long timeTaken) |
static void |
EndpointHelper.pollEndpoint(Endpoint endpoint,
Processor processor)
Creates a
PollingConsumer and polls all pending messages on the
endpoint and invokes the given Processor to process each
Exchange and then closes down the consumer and throws any
exceptions thrown. |
static void |
EndpointHelper.pollEndpoint(Endpoint endpoint,
Processor processor,
long timeout)
Creates a
PollingConsumer and polls all pending messages on the endpoint
and invokes the given Processor to process each Exchange and then closes
down the consumer and throws any exceptions thrown. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractApiEndpoint<E extends ApiName,T>
Abstract base class for API Component Endpoints.
|
Modifier and Type | Method and Description |
---|---|
protected abstract Endpoint |
AbstractApiComponent.createEndpoint(String uri,
String methodName,
E apiName,
T endpointConfiguration) |
protected Endpoint |
AbstractApiComponent.createEndpoint(String uri,
String remaining,
Map<String,Object> parameters) |
Constructor and Description |
---|
AbstractApiComponent(CamelContext context,
Class<? extends Endpoint> endpointClass,
Class<E> apiNameClass,
S collection) |
AbstractApiComponent(Class<? extends Endpoint> endpointClass,
Class<E> apiNameClass,
S collection) |
Apache Camel