|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Exchange | |
---|---|
org.apache.camel | The core Camel API |
org.apache.camel.builder | The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers. |
org.apache.camel.builder.xml | Support for XPath based Expressions and Predicates as well as an XSLT processor |
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.direct | The Direct Component which synchronously invokes all the consumers 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.jmx | The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. |
org.apache.camel.component.log | |
org.apache.camel.component.mock | The Mock Component which is used for testing of routing and mediation rules. |
org.apache.camel.component.seda | The SEDA Component for asynchronous SEDA exchanges on a BlockingQueue within a single CamelContext |
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.impl | Default implementation classes for Camel Core |
org.apache.camel.language | |
org.apache.camel.language.simple | |
org.apache.camel.model | Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. |
org.apache.camel.model.language | Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. |
org.apache.camel.processor | A collection of Processor implementations which are used to implement the Enterprise Integration Patterns |
org.apache.camel.processor.aggregate | Helper classes for the Aggregator pattern. |
org.apache.camel.processor.idempotent | An implementation of the Idempotent Consumer pattern. |
org.apache.camel.processor.loadbalancer | Various load balancer processors |
org.apache.camel.processor.validation | Performs XML validation using JAXP for validating against XSD or RelaxNG |
org.apache.camel.spi | Service Provider Interfaces used internally by the Camel runtime which are plugin strategies. |
org.apache.camel.util | Utility classes used by the core of Camel and useful for Camel component developers |
Uses of Exchange in org.apache.camel |
---|
Classes in org.apache.camel with type parameters of type Exchange | |
---|---|
class |
CamelTemplate<E extends Exchange>
A client helper object (named like Spring's TransactionTemplate & JmsTemplate et al) for working with Camel and sending Message instances in an
Exchange to an Endpoint . |
interface |
Component<E extends Exchange>
A component is a factory of Endpoint objects. |
interface |
Consumer<E extends Exchange>
A consumer of message exchanges from an Endpoint |
interface |
Endpoint<E extends Exchange>
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
interface |
Expression<E extends Exchange>
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
interface |
PollingConsumer<E extends Exchange>
Represents a Polling Consumer where the caller polls for messages when it is ready. |
interface |
Producer<E extends Exchange>
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
interface |
ProducerTemplate<E extends Exchange>
|
class |
Route<E extends Exchange>
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext |
Methods in org.apache.camel that return Exchange | |
---|---|
Exchange |
Exchange.copy()
Creates a copy of the current message exchange so that it can be forwarded to another destination |
Exchange |
ExpectedBodyTypeException.getExchange()
|
Exchange |
CamelExchangeException.getExchange()
Returns the exchange which caused the exception |
Exchange |
Message.getExchange()
Returns the exchange this message is related to |
Methods in org.apache.camel with parameters of type Exchange | |
---|---|
void |
Exchange.copyFrom(Exchange source)
Copies the data into this exchange from the given exchange #param source is the source from which headers and messages will be copied |
E |
Endpoint.createExchange(Exchange exchange)
Creates a new exchange for communicating with this exchange using the given exchange to pre-populate the values of the headers and messages |
void |
Processor.process(Exchange exchange)
Processes the message exchange |
protected static String |
NoSuchPropertyException.reason(Exchange exchange,
String propertyName)
|
E |
Endpoint.toExchangeType(Exchange exchange)
Converts the given exchange to this endpoints required type |
Constructors in org.apache.camel with parameters of type Exchange | |
---|---|
CamelExchangeException(String message,
Exchange exchange)
|
|
ExpectedBodyTypeException(Exchange exchange,
Class expectedBodyType)
|
|
InvalidPayloadException(Exchange exchange,
Class<?> type)
|
|
InvalidTypeException(Exchange exchange,
Object value,
Class<?> type)
|
|
NoSuchPropertyException(Exchange exchange,
String propertyName,
Class<?> type)
|
|
ValidationException(Exchange exchange,
String message)
|
Uses of Exchange in org.apache.camel.builder |
---|
Classes in org.apache.camel.builder with type parameters of type Exchange | |
---|---|
interface |
PredicateFactory<E extends Exchange>
A Factory of Predicate objects typically implemented by a builder such as @{XPathBuilder} |
class |
ValueBuilder<E extends Exchange>
A builder of expressions or predicates based on values. |
Methods in org.apache.camel.builder with type parameters of type Exchange | ||
---|---|---|
static
|
PredicateBuilder.and(Predicate<E> left,
Predicate<E> right)
A helper method to combine multiple predicates by a logical AND |
|
static
|
ExpressionBuilder.append(Expression<E> left,
Expression<E> right)
Appends the String evaluations of the two expressions together |
|
static
|
Builder.body()
Returns a predicate and value builder for the inbound body on an exchange |
|
static
|
Builder.bodyAs(Class<T> type)
Returns a predicate and value builder for the inbound message body as a specific type |
|
static
|
ExpressionBuilder.bodyExpression()
Returns the expression for the exchanges inbound message body |
|
static
|
ExpressionBuilder.bodyExpression(Class<T> type)
Returns the expression for the exchanges inbound message body converted to the given type |
|
static
|
Builder.constant(Object value)
Returns a constant expression |
|
static
|
ExpressionBuilder.constantExpression(Object value)
Returns an expression for the contant value |
|
static
|
PredicateBuilder.contains(Expression<E> left,
Expression<E> right)
|
|
static
|
ExpressionBuilder.convertTo(Expression expression,
Class type)
Returns an expression which converts the given expression to the given type |
|
static
|
ExpressionBuilder.evaluateStringExpression(Expression<E> expression,
E exchange)
Evaluates the expression on the given exchange and returns the String representation |
|
static
|
ExpressionBuilder.exchangeExpression()
Returns the expression for the exchange |
|
static
|
Builder.header(String name)
Returns a predicate and value builder for headers on an exchange |
|
static
|
ExpressionBuilder.headerExpression(String headerName)
Returns an expression for the header value with the given name |
|
static
|
ExpressionBuilder.inMessageExpression()
Returns the expression for the IN message |
|
static
|
PredicateBuilder.isEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isGreaterThan(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isGreaterThanOrEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isInstanceOf(Expression<E> expression,
Class type)
|
|
static
|
PredicateBuilder.isLessThan(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isLessThanOrEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isNotEqualTo(Expression<E> left,
Expression<E> right)
|
|
static
|
PredicateBuilder.isNotNull(Expression<E> expression)
|
|
static
|
PredicateBuilder.isNull(Expression<E> expression)
|
|
static
|
PredicateBuilder.not(Predicate<E> predicate)
A helper method to return the logical not of the given predicate |
|
static
|
PredicateBuilder.or(Predicate<E> left,
Predicate<E> right)
A helper method to combine multiple predicates by a logical OR |
|
static
|
Builder.outBody()
Returns a predicate and value builder for the outbound body on an exchange |
|
static
|
Builder.outBody(Class<T> type)
Returns a predicate and value builder for the outbound message body as a specific type |
|
static
|
ExpressionBuilder.outBodyExpression()
Returns the expression for the out messages body |
|
static
|
ExpressionBuilder.outHeaderExpression(String headerName)
Returns an expression for the out header value with the given name |
|
static
|
ExpressionBuilder.propertyExpression(String propertyName)
Returns an expression for the property value with the given name |
|
static
|
PredicateBuilder.regex(Expression<E> expression,
Pattern pattern)
Returns a predicate which is true if the expression matches the given regular expression |
|
static
|
PredicateBuilder.regex(Expression<E> expression,
String regex)
Returns a predicate which is true if the expression matches the given regular expression |
|
static
|
ExpressionBuilder.regexReplaceAll(Expression<E> expression,
String regex,
Expression<E> replacementExpression)
Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result |
|
static
|
ExpressionBuilder.regexReplaceAll(Expression<E> expression,
String regex,
String replacement)
Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result |
|
static
|
ExpressionBuilder.regexTokenize(Expression<E> expression,
String regexTokenizer)
Returns a tokenize expression which will tokenize the string with the given regex |
|
static
|
Builder.systemProperty(String name)
Returns an expression for the given system property |
|
static
|
ExpressionBuilder.systemProperty(String name)
Returns an expression for the given system property |
|
static
|
Builder.systemProperty(String name,
String defaultValue)
Returns an expression for the given system property |
|
static
|
ExpressionBuilder.systemProperty(String name,
String defaultValue)
Returns an expression for the given system property |
|
static
|
ExpressionBuilder.systemPropertyExpression(String propertyName)
Returns an expression for a system property value with the given name |
|
static
|
ExpressionBuilder.systemPropertyExpression(String propertyName,
String defaultValue)
Returns an expression for a system property value with the given name |
|
static
|
ExpressionBuilder.tokenizeExpression(Expression<E> expression,
String token)
Returns a tokenize expression which will tokenize the string with the given token |
|
static
|
PredicateBuilder.toPredicate(Expression<E> expression)
Converts the given expression into an Predicate |
Uses of Exchange in org.apache.camel.builder.xml |
---|
Classes in org.apache.camel.builder.xml with type parameters of type Exchange | |
---|---|
class |
XPathBuilder<E extends Exchange>
Creates an XPath expression builder |
Methods in org.apache.camel.builder.xml that return Exchange | |
---|---|
Exchange |
MessageVariableResolver.getExchange()
|
Methods in org.apache.camel.builder.xml that return types with arguments of type Exchange | |
---|---|
Expression<Exchange> |
XPathLanguage.createExpression(String expression)
|
Predicate<Exchange> |
XPathLanguage.createPredicate(String expression)
|
Methods in org.apache.camel.builder.xml with parameters of type Exchange | |
---|---|
protected void |
XsltBuilder.configureTransformer(Transformer transformer,
Exchange exchange)
Configures the transformerwith exchange specific parameters |
protected Source |
XsltBuilder.getSource(Exchange exchange)
Converts the inbound body to a Source |
void |
XsltBuilder.process(Exchange exchange)
|
void |
MessageVariableResolver.setExchange(Exchange exchange)
|
Uses of Exchange in org.apache.camel.component.bean |
---|
Classes in org.apache.camel.component.bean that implement Exchange | |
---|---|
class |
BeanExchange
|
Methods in org.apache.camel.component.bean that return Exchange | |
---|---|
Exchange |
BeanExchange.newInstance()
|
Methods in org.apache.camel.component.bean with parameters of type Exchange | |
---|---|
protected MethodInfo |
BeanInfo.chooseMethod(Object pojo,
Exchange exchange)
Lets try choose one of the available methods to invoke if we can match the message body to the body parameter |
MethodInvocation |
BeanInfo.createInvocation(Method method,
Object pojo,
Exchange exchange)
|
MethodInvocation |
BeanInfo.createInvocation(Object pojo,
Exchange exchange)
|
MethodInvocation |
MethodInfo.createMethodInvocation(Object pojo,
Exchange messageExchange)
|
protected Object |
MethodInfo.invoke(Method mth,
Object pojo,
Object[] arguments,
Exchange exchange)
|
void |
BeanInvocation.invoke(Object pojo,
Exchange exchange)
This causes us to invoke the endpoint Pojo using reflection. |
void |
BeanProcessor.process(Exchange exchange)
|
Constructors in org.apache.camel.component.bean with parameters of type Exchange | |
---|---|
AmbiguousMethodCallException(Exchange exchange,
List<MethodInfo> methods)
|
Uses of Exchange in org.apache.camel.component.direct |
---|
Classes in org.apache.camel.component.direct with type parameters of type Exchange | |
---|---|
class |
DirectComponent<E extends Exchange>
Represents the component that manages DirectEndpoint . |
class |
DirectEndpoint<E extends Exchange>
Represents a direct endpoint that synchronously invokes the consumers of the endpoint when a producer sends a message to it. |
Methods in org.apache.camel.component.direct with parameters of type Exchange | |
---|---|
protected void |
DirectEndpoint.process(Exchange exchange)
|
Uses of Exchange in org.apache.camel.component.file |
---|
Classes in org.apache.camel.component.file that implement Exchange | |
---|---|
class |
FileExchange
A Exchange for File |
Methods in org.apache.camel.component.file that return Exchange | |
---|---|
Exchange |
FileExchange.newInstance()
|
Methods in org.apache.camel.component.file with parameters of type Exchange | |
---|---|
void |
FileProducer.process(Exchange exchange)
|
Uses of Exchange in org.apache.camel.component.jmx |
---|
Classes in org.apache.camel.component.jmx that implement Exchange | |
---|---|
class |
JMXExchange
A Exchange for a jmx notification |
Uses of Exchange in org.apache.camel.component.log |
---|
Methods in org.apache.camel.component.log that return types with arguments of type Exchange | |
---|---|
protected Endpoint<Exchange> |
LogComponent.createEndpoint(String uri,
String remaining,
Map parameters)
|
Uses of Exchange in org.apache.camel.component.mock |
---|
Classes in org.apache.camel.component.mock with type parameters of type Exchange | |
---|---|
class |
AssertionClause<E extends Exchange>
A builder of assertions on message exchanges |
Methods in org.apache.camel.component.mock that return Exchange | |
---|---|
Exchange |
MockEndpoint.assertExchangeReceived(int index)
Asserts that the given index of message is received (starting at zero) |
Exchange |
MockEndpoint.createExchange()
|
Methods in org.apache.camel.component.mock that return types with arguments of type Exchange | |
---|---|
Consumer<Exchange> |
MockEndpoint.createConsumer(Processor processor)
|
protected Endpoint<Exchange> |
MockComponent.createEndpoint(String uri,
String remaining,
Map parameters)
|
Producer<Exchange> |
MockEndpoint.createProducer()
|
List<Exchange> |
MockEndpoint.getReceivedExchanges()
|
Methods in org.apache.camel.component.mock with parameters of type Exchange | |
---|---|
protected void |
MockEndpoint.onExchange(Exchange exchange)
|
Method parameters in org.apache.camel.component.mock with type arguments of type Exchange | |
---|---|
void |
MockEndpoint.assertMessagesAscending(Expression<Exchange> expression)
Asserts that the messages have ascending values of the given expression |
void |
MockEndpoint.assertMessagesDescending(Expression<Exchange> expression)
Asserts that the messages have descending values of the given expression |
protected void |
MockEndpoint.assertMessagesSorted(Expression<Exchange> expression,
boolean ascending)
|
void |
MockEndpoint.assertNoDuplicates(Expression<Exchange> expression)
|
void |
MockEndpoint.expectsAscending(Expression<Exchange> expression)
Adds an expectation that messages received should have ascending values of the given expression such as a user generated counter value |
void |
MockEndpoint.expectsDescending(Expression<Exchange> expression)
Adds an expectation that messages received should have descending values of the given expression such as a user generated counter value |
void |
MockEndpoint.expectsNoDuplicates(Expression<Exchange> expression)
Adds an expectation that no duplicate messages should be received using the expression to determine the message ID |
Uses of Exchange in org.apache.camel.component.seda |
---|
Classes in org.apache.camel.component.seda with type parameters of type Exchange | |
---|---|
class |
QueueComponent<E extends Exchange>
An implementation of the Queue components for asynchronous SEDA exchanges on a BlockingQueue within a CamelContext |
class |
SedaComponent<E extends Exchange>
An implementation of the SEDA components for asynchronous SEDA exchanges on a BlockingQueue within a CamelContext |
class |
SedaConsumer<E extends Exchange>
|
class |
SedaEndpoint<E extends Exchange>
An implementation of the Queue components for asynchronous SEDA exchanges on a BlockingQueue within a CamelContext |
Uses of Exchange in org.apache.camel.component.vm |
---|
Classes in org.apache.camel.component.vm with type parameters of type Exchange | |
---|---|
class |
VmComponent<E extends Exchange>
An implementation of the VM components for asynchronous SEDA exchanges on a BlockingQueue within the classloader tree containing
the camel-core.jar. |
Fields in org.apache.camel.component.vm with type parameters of type Exchange | |
---|---|
protected static Map<String,BlockingQueue<Exchange>> |
VmComponent.queues
|
Methods in org.apache.camel.component.vm that return types with arguments of type Exchange | |
---|---|
protected BlockingQueue<Exchange> |
VmComponent.getBlockingQueue(String uri)
|
Uses of Exchange in org.apache.camel.impl |
---|
Classes in org.apache.camel.impl with type parameters of type Exchange | |
---|---|
class |
BinaryPredicateSupport<E extends Exchange>
A useful base class for Predicate implementations |
class |
DefaultComponent<E extends Exchange>
|
class |
DefaultComponentResolver<E extends Exchange>
The default implementation of ComponentResolver which tries to find
components by using the URI scheme prefix and searching for a file of the URI
scheme name in the META-INF/services/org/apache/camel/component/
directory on the classpath. |
class |
DefaultConsumer<E extends Exchange>
|
class |
DefaultEndpoint<E extends Exchange>
A default endpoint useful for implementation inheritance |
class |
DefaultPollingConsumer<E extends Exchange>
A default implementation of the PollingConsumer which uses the normal
asynchronous consumer mechanism along with a BlockingQueue to allow
the caller to pull messages on demand. |
class |
DefaultProducer<E extends Exchange>
A default implementation of @{link Producer} for implementation inheritence |
class |
EventDrivenConsumerRoute<E extends Exchange>
A Route which starts with an
Event Driven Consumer |
class |
ExpressionSupport<E extends Exchange>
A useful base class for Predicate and Expression implementations |
class |
PollingConsumerSupport<E extends Exchange>
A useful base class for implementations of PollingConsumer |
class |
PredicateSupport<E extends Exchange>
A useful base class for Predicate implementations |
class |
ScheduledPollConsumer<E extends Exchange>
A useful base class for any consumer which is polling based |
class |
ScheduledPollEndpoint<E extends Exchange>
A base class for Endpoint which creates a ScheduledPollConsumer |
Classes in org.apache.camel.impl that implement Exchange | |
---|---|
class |
DefaultExchange
A default implementation of Exchange |
Methods in org.apache.camel.impl that return Exchange | |
---|---|
Exchange |
DefaultExchange.copy()
|
Exchange |
ProcessorEndpoint.createExchange()
|
Exchange |
MessageSupport.getExchange()
|
Exchange |
DefaultExchange.newInstance()
|
Methods in org.apache.camel.impl that return types with arguments of type Exchange | |
---|---|
Consumer<Exchange> |
ProcessorEndpoint.createConsumer(Processor processor)
|
Producer<Exchange> |
ProcessorEndpoint.createProducer()
|
Methods in org.apache.camel.impl with parameters of type Exchange | ||
---|---|---|
E |
DefaultEndpoint.convertTo(Class<E> type,
Exchange exchange)
Converts the given exchange to the specified exchange type |
|
|
DefaultExchangeConverter.convertTo(Class<T> type,
Exchange exchange)
|
|
void |
DefaultExchange.copyFrom(Exchange exchange)
|
|
E |
DefaultEndpoint.createExchange(Exchange exchange)
|
|
protected void |
ProcessorEndpoint.onExchange(Exchange exchange)
|
|
void |
DefaultPollingConsumer.process(Exchange exchange)
|
|
void |
MessageSupport.setExchange(Exchange exchange)
|
|
E |
DefaultEndpoint.toExchangeType(Exchange exchange)
|
Uses of Exchange in org.apache.camel.language |
---|
Methods in org.apache.camel.language that return types with arguments of type Exchange | |
---|---|
Expression<Exchange> |
ExpressionEvaluationException.getExpression()
|
Constructors in org.apache.camel.language with parameters of type Exchange | |
---|---|
ExpressionEvaluationException(Expression<Exchange> expression,
Exchange exchange,
Throwable cause)
|
Constructor parameters in org.apache.camel.language with type arguments of type Exchange | |
---|---|
ExpressionEvaluationException(Expression<Exchange> expression,
Exchange exchange,
Throwable cause)
|
Uses of Exchange in org.apache.camel.language.simple |
---|
Methods in org.apache.camel.language.simple that return types with arguments of type Exchange | |
---|---|
Expression<Exchange> |
SimpleLanguage.createExpression(String expression)
|
Predicate<Exchange> |
SimpleLanguage.createPredicate(String expression)
|
Uses of Exchange in org.apache.camel.model |
---|
Method parameters in org.apache.camel.model with type arguments of type Exchange | |
---|---|
DelayerType |
ProcessorType.delayer(Expression<Exchange> processAtExpression)
A builder for the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on |
DelayerType |
ProcessorType.delayer(Expression<Exchange> processAtExpression,
long delay)
A builder for the Delayer pattern where an expression is used to calculate the time which the message will be dispatched on |
ResequencerType |
ProcessorType.resequencer(Expression<Exchange> expression)
A builder for the Resequencer pattern where an expression is evaluated to be able to compare the message exchanges to reorder them. |
Uses of Exchange in org.apache.camel.model.language |
---|
Methods in org.apache.camel.model.language that return types with arguments of type Exchange | |
---|---|
Predicate<Exchange> |
ExpressionType.createPredicate(RouteContext route)
|
Uses of Exchange in org.apache.camel.processor |
---|
Methods in org.apache.camel.processor with type parameters of type Exchange | ||
---|---|---|
static
|
DeadLetterChannel.createDefaultLogger()
|
|
static
|
MulticastProcessor.toProducers(Collection<Endpoint> endpoints)
A helper method to convert a list of endpoints into a list of processors |
Methods in org.apache.camel.processor that return Exchange | |
---|---|
protected Exchange |
Pipeline.copyExchangeStrategy(Exchange exchange)
Strategy method to copy the exchange before sending to another endpoint. |
protected Exchange |
MulticastProcessor.copyExchangeStrategy(Processor processor,
Exchange exchange)
Strategy method to copy the exchange before sending to another endpoint. |
protected Exchange |
Pipeline.createNextExchange(Processor producer,
Exchange previousExchange)
Strategy method to create the next exchange from the |
Methods in org.apache.camel.processor that return types with arguments of type Exchange | |
---|---|
protected static Set<Exchange> |
Resequencer.createSet(Comparator<? super Exchange> comparator)
|
protected static Set<Exchange> |
Resequencer.createSet(Expression<Exchange> expression)
|
protected static Set<Exchange> |
Resequencer.createSet(List<Expression> expressions)
|
protected Collection<Exchange> |
BatchProcessor.getCollection()
|
Predicate<Exchange> |
FilterProcessor.getPredicate()
|
protected Endpoint<Exchange> |
RecipientList.resolveEndpoint(Exchange exchange,
Object recipient)
|
Methods in org.apache.camel.processor with parameters of type Exchange | |
---|---|
protected Exchange |
Pipeline.copyExchangeStrategy(Exchange exchange)
Strategy method to copy the exchange before sending to another endpoint. |
protected Exchange |
MulticastProcessor.copyExchangeStrategy(Processor processor,
Exchange exchange)
Strategy method to copy the exchange before sending to another endpoint. |
protected Exchange |
Pipeline.createNextExchange(Processor producer,
Exchange previousExchange)
Strategy method to create the next exchange from the |
protected boolean |
ErrorHandlerSupport.customProcessorForException(Exchange exchange,
Throwable exception)
Attempts to invoke the handler for this particular exception if one is available |
protected long |
Delayer.defaultProcessTime(Exchange exchange)
A Strategy Method to allow derived implementations to decide the current system time or some other default exchange property |
protected void |
Throttler.delay(Exchange exchange)
|
protected void |
Delayer.delay(Exchange exchange)
Waits for an optional time period before continuing to process the exchange |
protected abstract void |
DelayProcessorSupport.delay(Exchange exchange)
|
protected ExceptionType |
ErrorHandlerSupport.getExceptionPolicy(Exchange exchange,
Throwable exception)
|
protected void |
TryProcessor.handleException(Exchange exchange,
Exception e)
|
protected int |
DeadLetterChannel.incrementRedeliveryCounter(Exchange exchange,
Throwable e)
Increments the redelivery counter and adds the redelivered flag if the message has been redelivered |
protected void |
LoggingErrorHandler.logError(Exchange exchange,
Throwable e)
|
protected Object |
Logger.logMessage(Exchange exchange)
|
protected Object |
LoggingErrorHandler.logMessage(Exchange exchange,
Throwable e)
|
void |
DelegateProcessor.proceed(Exchange exchange)
Proceed with the underlying delegated processor |
void |
ChoiceProcessor.process(Exchange exchange)
|
void |
Splitter.process(Exchange exchange)
|
void |
ProceedProcessor.process(Exchange exchange)
|
void |
SendProcessor.process(Exchange exchange)
|
void |
CompositeProcessor.process(Exchange exchange)
|
void |
DelayProcessorSupport.process(Exchange exchange)
|
void |
RecipientList.process(Exchange exchange)
|
void |
TryProcessor.process(Exchange exchange)
|
void |
LoggingErrorHandler.process(Exchange exchange)
|
void |
DeadLetterChannel.process(Exchange exchange)
|
void |
MulticastProcessor.process(Exchange exchange)
|
void |
Pipeline.process(Exchange exchange)
|
void |
FilterProcessor.process(Exchange exchange)
|
void |
Interceptor.process(Exchange exchange)
|
void |
Logger.process(Exchange exchange)
|
void |
DelegateProcessor.process(Exchange exchange)
|
protected void |
BatchProcessor.processExchange(Exchange exchange)
Strategy Method to process an exchange in the batch. |
protected void |
DelegateProcessor.processNext(Exchange exchange)
|
protected Endpoint<Exchange> |
RecipientList.resolveEndpoint(Exchange exchange,
Object recipient)
|
protected void |
DelayProcessorSupport.waitUntil(long time,
Exchange exchange)
Wait until the given system time before continuing |
Method parameters in org.apache.camel.processor with type arguments of type Exchange | |
---|---|
protected static Set<Exchange> |
Resequencer.createSet(Comparator<? super Exchange> comparator)
|
protected static Set<Exchange> |
Resequencer.createSet(Expression<Exchange> expression)
|
Constructor parameters in org.apache.camel.processor with type arguments of type Exchange | |
---|---|
BatchProcessor(Endpoint endpoint,
Processor processor,
Collection<Exchange> collection)
|
|
Delayer(Processor processor,
Expression<Exchange> timeExpression,
long delay)
|
|
FilterProcessor(Predicate<Exchange> predicate,
Processor processor)
|
|
RecipientList(Expression<Exchange> expression)
|
|
Resequencer(Endpoint endpoint,
Processor processor,
Expression<Exchange> expression)
|
|
Resequencer(Endpoint endpoint,
Processor processor,
Set<Exchange> collection)
|
Uses of Exchange in org.apache.camel.processor.aggregate |
---|
Methods in org.apache.camel.processor.aggregate that return Exchange | |
---|---|
Exchange |
UseLatestAggregationStrategy.aggregate(Exchange oldExchange,
Exchange newExchange)
|
Exchange |
AggregationStrategy.aggregate(Exchange oldExchange,
Exchange newExchange)
Aggregates an old and new exchange together to create a single combined exchange |
Methods in org.apache.camel.processor.aggregate that return types with arguments of type Exchange | |
---|---|
Iterator<Exchange> |
AggregationCollection.iterator()
|
Methods in org.apache.camel.processor.aggregate with parameters of type Exchange | |
---|---|
boolean |
AggregationCollection.add(Exchange exchange)
|
Exchange |
UseLatestAggregationStrategy.aggregate(Exchange oldExchange,
Exchange newExchange)
|
Exchange |
AggregationStrategy.aggregate(Exchange oldExchange,
Exchange newExchange)
Aggregates an old and new exchange together to create a single combined exchange |
Constructor parameters in org.apache.camel.processor.aggregate with type arguments of type Exchange | |
---|---|
AggregationCollection(Expression<Exchange> correlationExpression,
AggregationStrategy aggregationStrategy)
|
Uses of Exchange in org.apache.camel.processor.idempotent |
---|
Methods in org.apache.camel.processor.idempotent that return Exchange | |
---|---|
Exchange |
NoMessageIdException.getExchange()
The exchange which caused this failure |
Methods in org.apache.camel.processor.idempotent that return types with arguments of type Exchange | |
---|---|
Expression<Exchange> |
IdempotentConsumer.getMessageIdExpression()
|
Methods in org.apache.camel.processor.idempotent with parameters of type Exchange | |
---|---|
protected void |
IdempotentConsumer.onDuplicateMessage(Exchange exchange,
String messageId)
A strategy method to allow derived classes to overload the behaviour of processing a duplicate message |
void |
IdempotentConsumer.process(Exchange exchange)
|
Constructors in org.apache.camel.processor.idempotent with parameters of type Exchange | |
---|---|
NoMessageIdException(Exchange exchange,
Expression expression)
|
Constructor parameters in org.apache.camel.processor.idempotent with type arguments of type Exchange | |
---|---|
IdempotentConsumer(Expression<Exchange> messageIdExpression,
MessageIdRepository messageIdRepository,
Processor nextProcessor)
|
Uses of Exchange in org.apache.camel.processor.loadbalancer |
---|
Methods in org.apache.camel.processor.loadbalancer that return Exchange | |
---|---|
protected Exchange |
TopicLoadBalancer.copyExchangeStrategy(Processor processor,
Exchange exchange)
Strategy method to copy the exchange before sending to another endpoint. |
Methods in org.apache.camel.processor.loadbalancer with parameters of type Exchange | |
---|---|
protected Processor |
RandomLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
StickyLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected abstract Processor |
QueueLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Exchange |
TopicLoadBalancer.copyExchangeStrategy(Processor processor,
Exchange exchange)
Strategy method to copy the exchange before sending to another endpoint. |
void |
TopicLoadBalancer.process(Exchange exchange)
|
void |
QueueLoadBalancer.process(Exchange exchange)
|
Constructor parameters in org.apache.camel.processor.loadbalancer with type arguments of type Exchange | |
---|---|
StickyLoadBalancer(Expression<Exchange> correlationExpression)
|
|
StickyLoadBalancer(Expression<Exchange> correlationExpression,
QueueLoadBalancer loadBalancer)
|
Uses of Exchange in org.apache.camel.processor.validation |
---|
Methods in org.apache.camel.processor.validation with parameters of type Exchange | |
---|---|
void |
DefaultValidationErrorHandler.handleErrors(Exchange exchange,
Object schema)
|
void |
DefaultValidationErrorHandler.handleErrors(Exchange exchange,
Schema schema,
DOMResult result)
|
void |
ValidatorErrorHandler.handleErrors(Exchange exchange,
Schema schema,
DOMResult result)
Process any errors which may have occurred during validation |
void |
ValidatingProcessor.process(Exchange exchange)
|
Constructors in org.apache.camel.processor.validation with parameters of type Exchange | |
---|---|
NoXmlBodyValidationException(Exchange exchange)
|
|
SchemaValidationException(Exchange exchange,
Object schema,
List<SAXParseException> fatalErrors,
List<SAXParseException> errors,
List<SAXParseException> warnings)
|
Uses of Exchange in org.apache.camel.spi |
---|
Classes in org.apache.camel.spi with type parameters of type Exchange | |
---|---|
interface |
ComponentResolver<E extends Exchange>
Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like DefaultComponentResolver |
Methods in org.apache.camel.spi that return types with arguments of type Exchange | |
---|---|
Expression<Exchange> |
Language.createExpression(String expression)
|
Predicate<Exchange> |
Language.createPredicate(String expression)
|
Methods in org.apache.camel.spi with parameters of type Exchange | ||
---|---|---|
|
ExchangeConverter.convertTo(Class<T> type,
Exchange exchange)
|
Uses of Exchange in org.apache.camel.util |
---|
Classes in org.apache.camel.util with type parameters of type Exchange | |
---|---|
class |
ExpressionComparator<E extends Exchange>
An implementation of Comparator which takes an Expression which is evaluated
on each exchange to compare |
class |
ProducerCache<E extends Exchange>
|
Methods in org.apache.camel.util with type parameters of type Exchange | ||
---|---|---|
static
|
ExpressionHelper.evaluateAsString(Expression<E> expression,
E exchange)
Evaluates the given expression on the exchange as a String value |
|
static
|
ExpressionHelper.evaluateAsType(Expression<E> expression,
E exchange,
Class<T> resultType)
Evaluates the given expression on the exchange, converting the result to the given type |
|
static
|
ExchangeHelper.resolveEndpoint(E exchange,
Object value)
Attempts to resolve the endpoint for the given value |
Methods in org.apache.camel.util with parameters of type Exchange | ||
---|---|---|
int |
ExpressionListComparator.compare(Exchange e1,
Exchange e2)
|
|
static
|
ExchangeHelper.convertToMandatoryType(Exchange exchange,
Class<T> type,
Object value)
Converts the value to the given expected type or throws an exception |
|
static
|
ExchangeHelper.convertToType(Exchange exchange,
Class<T> type,
Object value)
Converts the value to the given expected type returning null if it could not be converted |
|
static
|
ExchangeHelper.getMandatoryInBody(Exchange exchange,
Class<T> type)
Returns the mandatory inbound message body of the correct type or throws an exception if it is not present |
|
static
|
ExchangeHelper.getMandatoryProperty(Exchange exchange,
String propertyName,
Class<T> type)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |