|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Exchange | |
---|---|
org.apache.camel | The JAXB POJOs for the XML Configuration of the routing rules. |
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.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.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.file | The File Component for working with file systems. |
org.apache.camel.component.file.strategy | Strategies for the File Component. |
org.apache.camel.component.jmx | The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. |
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.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.converter | A set of helper classes for converting from different types of Java object to be used by the Type Conversion Support |
org.apache.camel.converter.jaxp | A number of JAXP related helper classes for converting to and from various JAXP related classes like Document and Source to be used by a TypeConverter |
org.apache.camel.converter.stream | Package with converters for dealing with stream-based messages |
org.apache.camel.impl | Default implementation classes for Camel Core |
org.apache.camel.impl.converter | Default implementation classes the Type Conversion Strategies |
org.apache.camel.language.bean | Camel Bean language. |
org.apache.camel.management | Camel JMX export services. |
org.apache.camel.model.language | The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration. |
org.apache.camel.model.loadbalancer | The LoadBalancer and the LoadBalancerStrategy JAXB Objects |
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.exceptionpolicy | Exception policy startegies for Dead Letter Channel pattern. |
org.apache.camel.processor.idempotent | An implementation of the Idempotent Consumer pattern. |
org.apache.camel.processor.interceptor | Helper classes for interceptors. |
org.apache.camel.processor.loadbalancer | Various load balancer processors |
org.apache.camel.processor.resequencer | Helper classes for the Resequencer pattern. |
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 |
---|
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 |
Producer.createExchange()
Creates a new exchange to send to this endpoint |
Exchange |
Endpoint.createExchange()
Create a new exchange for communicating with this endpoint |
Exchange |
Producer.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 |
Exchange |
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 |
Exchange |
Producer.createExchange(ExchangePattern pattern)
Creates a new exchange of the given pattern to send to this endpoint |
Exchange |
Endpoint.createExchange(ExchangePattern pattern)
Create a new exchange for communicating with this endpoint with the specified ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange |
Exchange |
RuntimeExchangeException.getExchange()
Returns the exchange which caused the exception |
Exchange |
Message.getExchange()
Returns the exchange this message is related to |
Exchange |
ExpressionEvaluationException.getExchange()
|
Exchange |
ExpectedBodyTypeException.getExchange()
|
Exchange |
CamelExchangeException.getExchange()
Returns the exchange which caused the exception |
Exchange |
Exchange.newInstance()
Creates a new exchange instance with empty messages, headers and properties |
Exchange |
PollingConsumer.receive()
Waits until a message is available and then returns it. |
Exchange |
PollingConsumer.receive(long timeout)
Attempts to receive a message exchange, waiting up to the given timeout to expire if a message is not yet available |
Exchange |
PollingConsumer.receiveNoWait()
Attempts to receive a message exchange immediately without waiting and returning null if a message exchange is not available yet. |
Exchange |
ProducerTemplate.request(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern. |
Exchange |
ProducerTemplate.request(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern. |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Exchange exchange)
Sends the exchange to the given endpoint |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(Exchange exchange)
Sends the exchange to the default endpoint |
Exchange |
ProducerTemplate.send(Processor processor)
Sends an exchange to the default endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(String endpointUri,
Exchange exchange)
Sends the exchange to the given endpoint |
Exchange |
ProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(String endpointUri,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied processor |
Methods in org.apache.camel with parameters of type Exchange | ||
---|---|---|
|
TypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
Converts the value to the specified type in the context of an exchange Used when conversion requires extra information from the current exchange (such as encoding). |
|
void |
Exchange.copyFrom(Exchange source)
Copies the data into this exchange from the given exchange |
|
Exchange |
Producer.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 |
|
Exchange |
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 |
|
protected static String |
CamelExchangeException.createMessage(String message,
Exchange exchange)
|
|
Object |
Expression.evaluate(Exchange exchange)
Returns the value of the expression on the given exchange |
|
|
Expression.evaluate(Exchange exchange,
Class<T> type)
Returns the value of the expression on the given exchange |
|
T |
ExchangeProperty.get(Exchange exchange)
|
|
boolean |
Predicate.matches(Exchange exchange)
Evaluates the predicate on the message exchange and returns true if this exchange matches the predicate |
|
void |
Processor.process(Exchange exchange)
Processes the message exchange |
|
boolean |
AsyncProcessor.process(Exchange exchange,
AsyncCallback callback)
Processes the message exchange. |
|
protected static String |
NoSuchPropertyException.reason(Exchange exchange,
String propertyName)
|
|
protected static String |
NoSuchHeaderException.reason(Exchange exchange,
String propertyName)
|
|
T |
ExchangeProperty.remove(Exchange exchange)
|
|
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Exchange exchange)
Sends the exchange to the given endpoint |
|
Exchange |
ProducerTemplate.send(Exchange exchange)
Sends the exchange to the default endpoint |
|
Exchange |
ProducerTemplate.send(String endpointUri,
Exchange exchange)
Sends the exchange to the given endpoint |
|
T |
ExchangeProperty.set(Exchange exchange,
T value)
|
Uses of Exchange in org.apache.camel.builder |
---|
Methods in org.apache.camel.builder with type parameters of type Exchange | ||
---|---|---|
static
|
Builder.bodyAs(Class<T> type)
Returns a predicate and value builder for the inbound message body as a specific type |
|
static
|
Builder.faultBodyAs(Class<T> type)
Returns a predicate and value builder for the fault message body as a specific type |
|
static
|
Builder.outBodyAs(Class<T> type)
Returns a predicate and value builder for the outbound message body as a specific type |
Methods in org.apache.camel.builder with parameters of type Exchange | ||
---|---|---|
protected String |
BinaryPredicateSupport.assertionFailureMessage(Exchange exchange,
Object leftValue,
Object rightValue)
|
|
void |
BinaryPredicateSupport.assertMatches(String text,
Exchange exchange)
|
|
Object |
ValueBuilder.evaluate(Exchange exchange)
|
|
|
ValueBuilder.evaluate(Exchange exchange,
Class<T> type)
|
|
boolean |
BinaryPredicateSupport.matches(Exchange exchange)
|
|
protected abstract boolean |
BinaryPredicateSupport.matches(Exchange exchange,
Object leftValue,
Object rightValue)
|
Uses of Exchange in org.apache.camel.builder.xml |
---|
Methods in org.apache.camel.builder.xml that return Exchange | |
---|---|
Exchange |
MessageVariableResolver.getExchange()
|
Methods in org.apache.camel.builder.xml with parameters of type Exchange | ||
---|---|---|
void |
XPathBuilder.assertMatches(String text,
Exchange exchange)
|
|
protected void |
XsltBuilder.configureTransformer(Transformer transformer,
Exchange exchange)
Configures the transformer with exchange specific parameters |
|
Object |
XPathBuilder.evaluate(Exchange exchange)
|
|
|
XPathBuilder.evaluate(Exchange exchange,
Class<T> type)
|
|
protected Object |
XPathBuilder.evaluateAs(Exchange exchange,
QName resultQName)
Evaluates the expression as the given result type |
|
protected Object |
XPathBuilder.getDocument(Exchange exchange)
Strategy method to extract the document from the exchange |
|
protected Source |
XsltBuilder.getSource(Exchange exchange)
Converts the inbound body to a Source |
|
boolean |
XPathBuilder.matches(Exchange exchange)
|
|
void |
XsltBuilder.process(Exchange exchange)
|
|
void |
MessageVariableResolver.setExchange(Exchange exchange)
|
Uses of Exchange in org.apache.camel.component.bean |
---|
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 |
protected MethodInfo |
BeanInfo.chooseMethodWithCustomAnnotations(Exchange exchange,
Collection<MethodInfo> possibles)
|
protected MethodInfo |
BeanInfo.chooseMethodWithMatchingBody(Exchange exchange,
Collection<MethodInfo> operationList)
|
MethodInvocation |
BeanInfo.createInvocation(Method method,
Object pojo,
Exchange exchange)
|
MethodInvocation |
BeanInfo.createInvocation(Object pojo,
Exchange exchange)
|
MethodInvocation |
MethodInfo.createMethodInvocation(Object pojo,
Exchange exchange)
|
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,
Collection<MethodInfo> methods)
|
Uses of Exchange in org.apache.camel.component.browse |
---|
Methods in org.apache.camel.component.browse that return types with arguments of type Exchange | |
---|---|
protected List<Exchange> |
BrowseEndpoint.createExchangeList()
|
List<Exchange> |
BrowseEndpoint.getExchanges()
|
Methods in org.apache.camel.component.browse with parameters of type Exchange | |
---|---|
protected void |
BrowseEndpoint.onExchange(Exchange exchange)
Invoked on a message exchange being sent by a producer |
Uses of Exchange in org.apache.camel.component.dataset |
---|
Methods in org.apache.camel.component.dataset that return Exchange | |
---|---|
Exchange |
DataSetEndpoint.createExchange(long messageIndex)
Creates a message exchange for the given index in the DataSet |
Methods in org.apache.camel.component.dataset with parameters of type Exchange | |
---|---|
protected void |
DataSetSupport.applyHeaders(Exchange exchange,
long messageIndex)
Allows derived classes to add some custom headers for a given message |
static void |
DataSetEndpoint.assertEquals(String description,
Object expected,
Object actual,
Exchange exchange)
|
void |
DataSetSupport.assertMessageExpected(DataSetEndpoint dataSetEndpoint,
Exchange expected,
Exchange actual,
long index)
|
void |
DataSet.assertMessageExpected(DataSetEndpoint dataSetEndpoint,
Exchange expected,
Exchange actual,
long index)
Asserts that the expected message has been received for the given index |
protected void |
DataSetEndpoint.assertMessageExpected(long index,
Exchange expected,
Exchange actual)
|
protected void |
DataSetEndpoint.performAssertions(Exchange actual)
|
void |
DataSetSupport.populateMessage(Exchange exchange,
long messageIndex)
|
void |
DataSet.populateMessage(Exchange exchange,
long messageIndex)
Populates a message exchange when using the DataSet as a source of messages |
protected void |
DataSetEndpoint.reportProgress(Exchange actual,
int receivedCount)
|
Uses of Exchange in org.apache.camel.component.direct |
---|
Methods in org.apache.camel.component.direct with parameters of type Exchange | |
---|---|
void |
DirectProducer.process(Exchange exchange)
|
boolean |
DirectProducer.process(Exchange exchange,
AsyncCallback callback)
|
Uses of Exchange in org.apache.camel.component.file |
---|
Classes in org.apache.camel.component.file that implement Exchange | |
---|---|
class |
GenericFileExchange<T>
|
Methods in org.apache.camel.component.file that return Exchange | |
---|---|
Exchange |
GenericFileExchange.newInstance()
|
Methods in org.apache.camel.component.file with parameters of type Exchange | |
---|---|
boolean |
GenericFileExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<T> operations,
GenericFile<T> file,
Exchange exchange)
Acquires exclusive read lock to the file. |
static Object |
GenericFileConverter.convertTo(Class<?> type,
Exchange exchange,
Object value,
TypeConverterRegistry registry)
|
protected String |
GenericFileProducer.createFileName(Exchange exchange)
|
void |
GenericFileProducer.process(Exchange exchange)
|
void |
GenericFileExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<T> operations,
GenericFile<T> file,
Exchange exchange)
Releases the exclusive read lock granted by the acquireExclusiveReadLock method. |
Constructors in org.apache.camel.component.file with parameters of type Exchange | |
---|---|
GenericFileExchange(Exchange parent)
|
Uses of Exchange in org.apache.camel.component.file.strategy |
---|
Methods in org.apache.camel.component.file.strategy with parameters of type Exchange | |
---|---|
boolean |
MarkerFileExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> fileGenericFileOperations,
GenericFile<File> file,
Exchange exchange)
|
boolean |
FileLockExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<File> operations,
GenericFile<File> file,
Exchange exchange)
|
boolean |
GenericFileRenameExclusiveReadLockStrategy.acquireExclusiveReadLock(GenericFileOperations<T> operations,
GenericFile<T> file,
Exchange exchange)
|
void |
MarkerFileExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<File> fileGenericFileOperations,
GenericFile<File> fileGenericFile,
Exchange exchange)
|
void |
FileLockExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<File> fileGenericFileOperations,
GenericFile<File> fileGenericFile,
Exchange exchange)
|
void |
GenericFileRenameExclusiveReadLockStrategy.releaseExclusiveReadLock(GenericFileOperations<T> opeations,
GenericFile<T> file,
Exchange exchange)
|
Uses of Exchange in org.apache.camel.component.jmx |
---|
Methods in org.apache.camel.component.jmx that return Exchange | |
---|---|
Exchange |
JMXEndpoint.createExchange(Notification notification)
|
Exchange |
JMXMessage.getExchange()
|
Uses of Exchange in org.apache.camel.component.log |
---|
Methods in org.apache.camel.component.log with parameters of type Exchange | |
---|---|
Object |
LogFormatter.format(Exchange exchange)
|
Uses of Exchange in org.apache.camel.component.mock |
---|
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) |
Methods in org.apache.camel.component.mock that return types with arguments of type Exchange | |
---|---|
List<Exchange> |
MockEndpoint.getExchanges()
|
List<Exchange> |
MockEndpoint.getReceivedExchanges()
|
Methods in org.apache.camel.component.mock with parameters of type Exchange | |
---|---|
protected void |
AssertionClause.applyAssertionOn(MockEndpoint endpoint,
int index,
Exchange exchange)
Performs any assertions on the given exchange |
protected void |
MockEndpoint.onExchange(Exchange exchange)
|
protected void |
MockEndpoint.performAssertions(Exchange exchange)
|
Uses of Exchange in org.apache.camel.component.seda |
---|
Methods in org.apache.camel.component.seda that return types with arguments of type Exchange | |
---|---|
BlockingQueue<Exchange> |
SedaComponent.createQueue(String uri,
Map parameters)
|
List<Exchange> |
SedaEndpoint.getExchanges()
Returns the current pending exchanges |
BlockingQueue<Exchange> |
SedaEndpoint.getQueue()
|
Methods in org.apache.camel.component.seda with parameters of type Exchange | |
---|---|
void |
CollectionProducer.process(Exchange exchange)
|
boolean |
CollectionProducer.process(Exchange exchange,
AsyncCallback callback)
|
Method parameters in org.apache.camel.component.seda with type arguments of type Exchange | |
---|---|
void |
SedaEndpoint.setQueue(BlockingQueue<Exchange> queue)
|
Constructor parameters in org.apache.camel.component.seda with type arguments of type Exchange | |
---|---|
CollectionProducer(Endpoint endpoint,
Collection<Exchange> queue)
|
|
SedaEndpoint(String endpointUri,
BlockingQueue<Exchange> queue)
|
|
SedaEndpoint(String endpointUri,
BlockingQueue<Exchange> queue,
int concurrentConsumers)
|
|
SedaEndpoint(String endpointUri,
Component component,
BlockingQueue<Exchange> queue)
|
|
SedaEndpoint(String endpointUri,
Component component,
BlockingQueue<Exchange> queue,
int concurrentConsumers)
|
|
SedaProducer(SedaEndpoint endpoint,
BlockingQueue<Exchange> queue)
|
Uses of Exchange in org.apache.camel.component.vm |
---|
Methods in org.apache.camel.component.vm that return types with arguments of type Exchange | |
---|---|
protected BlockingQueue<Exchange> |
VmComponent.getBlockingQueue(String uri,
Map parameters)
|
Uses of Exchange in org.apache.camel.converter |
---|
Methods in org.apache.camel.converter with parameters of type Exchange | |
---|---|
static ByteBuffer |
NIOConverter.toByteBuffer(String value,
Exchange exchange)
|
static InputStream |
IOConverter.toInputStream(BufferedReader buffer,
Exchange exchange)
|
static InputStream |
IOConverter.toInputStream(String text,
Exchange exchange)
|
static String |
IOConverter.toString(byte[] data,
Exchange exchange)
|
static String |
NIOConverter.toString(ByteBuffer buffer,
Exchange exchange)
|
Uses of Exchange in org.apache.camel.converter.jaxp |
---|
Methods in org.apache.camel.converter.jaxp with parameters of type Exchange | |
---|---|
StreamSource |
XmlConverter.toStreamSource(byte[] in,
Exchange exchange)
|
StreamSource |
XmlConverter.toStreamSource(ByteBuffer in,
Exchange exchange)
|
Uses of Exchange in org.apache.camel.converter.stream |
---|
Methods in org.apache.camel.converter.stream with parameters of type Exchange | |
---|---|
StreamCache |
StreamCacheConverter.convertToStreamCache(InputStream stream,
Exchange exchange)
|
StreamCache |
StreamCacheConverter.convertToStreamCache(Reader reader,
Exchange exchange)
|
StreamCache |
StreamCacheConverter.convertToStreamCache(SAXSource source,
Exchange exchange)
|
StreamCache |
StreamCacheConverter.convertToStreamCache(StreamSource source,
Exchange exchange)
|
Uses of Exchange in org.apache.camel.impl |
---|
Classes in org.apache.camel.impl that implement Exchange | |
---|---|
class |
DefaultExchange
A default implementation of Exchange |
class |
GroupedExchange
A grouped exchange that groups together other exchanges, as a holder object. |
Methods in org.apache.camel.impl that return Exchange | |
---|---|
Exchange |
DefaultEndpoint.convertTo(Class<Exchange> type,
Exchange exchange)
Converts the given exchange to the specified exchange type |
Exchange |
DefaultExchange.copy()
|
Exchange |
DefaultProducer.createExchange()
|
Exchange |
DefaultEndpoint.createExchange()
|
Exchange |
DefaultProducer.createExchange(Exchange exchange)
|
Exchange |
DefaultEndpoint.createExchange(Exchange exchange)
|
Exchange |
DefaultProducer.createExchange(ExchangePattern pattern)
|
Exchange |
DefaultEndpoint.createExchange(ExchangePattern pattern)
|
Exchange |
GroupedExchange.get(int index)
|
Exchange |
MessageSupport.getExchange()
|
Exchange |
DefaultExchange.newInstance()
|
Exchange |
ProcessorPollingConsumer.receive()
|
Exchange |
EventDrivenPollingConsumer.receive()
|
Exchange |
ProcessorPollingConsumer.receive(long timeout)
|
Exchange |
EventDrivenPollingConsumer.receive(long timeout)
|
Exchange |
ProcessorPollingConsumer.receiveNoWait()
|
Exchange |
EventDrivenPollingConsumer.receiveNoWait()
|
Exchange |
DefaultProducerTemplate.request(Endpoint endpoint,
Processor processor)
|
Exchange |
DefaultProducerTemplate.request(String endpoint,
Processor processor)
|
Exchange |
DefaultProducerTemplate.send(Endpoint endpoint,
Exchange exchange)
|
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)
|
Exchange |
ProducerCache.send(Endpoint endpoint,
Processor processor)
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,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied Processor to populate the exchange. |
Exchange |
DefaultProducerTemplate.send(Endpoint endpoint,
Processor processor,
AsyncCallback callback)
|
Exchange |
DefaultProducerTemplate.send(Exchange exchange)
|
Exchange |
DefaultProducerTemplate.send(Processor processor)
|
Exchange |
DefaultProducerTemplate.send(String endpointUri,
Exchange exchange)
|
Exchange |
DefaultProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
|
Exchange |
DefaultProducerTemplate.send(String endpointUri,
Processor processor)
|
Exchange |
DefaultProducerTemplate.send(String endpointUri,
Processor processor,
AsyncCallback callback)
|
protected Exchange |
ProducerCache.sendExchange(Endpoint endpoint,
Producer producer,
Processor processor,
Exchange exchange)
|
Methods in org.apache.camel.impl that return types with arguments of type Exchange | |
---|---|
List<Exchange> |
GroupedExchange.getExchanges()
|
Class<Exchange> |
DefaultEndpoint.getExchangeType()
Returns the type of the exchange which is generated by this component |
Methods in org.apache.camel.impl with parameters of type Exchange | ||
---|---|---|
void |
GroupedExchange.addExchange(Exchange exchange)
|
|
protected abstract String |
ExpressionSupport.assertionFailureMessage(Exchange exchange)
|
|
protected String |
ExpressionAdapter.assertionFailureMessage(Exchange exchange)
|
|
void |
ExpressionSupport.assertMatches(String text,
Exchange exchange)
|
|
Exchange |
DefaultEndpoint.convertTo(Class<Exchange> type,
Exchange exchange)
Converts the given exchange to the specified exchange type |
|
|
DefaultExchangeConverter.convertTo(Class<T> type,
Exchange exchange)
|
|
void |
DefaultExchange.copyFrom(Exchange exchange)
|
|
Exchange |
DefaultProducer.createExchange(Exchange exchange)
|
|
Exchange |
DefaultEndpoint.createExchange(Exchange exchange)
|
|
void |
DefaultUnitOfWork.done(Exchange exchange)
|
|
Object |
ExpressionAdapter.evaluate(Exchange exchange)
|
|
|
ExpressionSupport.evaluate(Exchange exchange,
Class<T> type)
|
|
protected Object |
DefaultProducerTemplate.extractResultBody(Exchange result)
Extracts the body from the given result. |
|
protected Object |
DefaultProducerTemplate.extractResultBody(Exchange result,
ExchangePattern pattern)
Extracts the body from the given result. |
|
Object |
DefaultExchangeFormatter.format(Exchange exchange)
|
|
protected boolean |
DefaultProducerTemplate.hasFaultMessage(Exchange result)
|
|
static boolean |
ProducerCache.isProcessedSync(Exchange exchange)
|
|
void |
ZipDataFormat.marshal(Exchange exchange,
Object graph,
OutputStream stream)
|
|
void |
StringDataFormat.marshal(Exchange exchange,
Object graph,
OutputStream stream)
|
|
void |
SerializationDataFormat.marshal(Exchange exchange,
Object graph,
OutputStream stream)
|
|
boolean |
ExpressionSupport.matches(Exchange exchange)
|
|
protected void |
ProcessorEndpoint.onExchange(Exchange exchange)
|
|
void |
ProducerTemplateProcessor.process(Exchange exchange)
|
|
void |
EventDrivenPollingConsumer.process(Exchange exchange)
|
|
void |
ProducerCache.send(Endpoint endpoint,
Exchange exchange)
Sends the exchange to the given endpoint |
|
Exchange |
DefaultProducerTemplate.send(Endpoint endpoint,
Exchange exchange)
|
|
Exchange |
DefaultProducerTemplate.send(Exchange exchange)
|
|
Exchange |
DefaultProducerTemplate.send(String endpointUri,
Exchange exchange)
|
|
protected Exchange |
ProducerCache.sendExchange(Endpoint endpoint,
Producer producer,
Processor processor,
Exchange exchange)
|
|
protected boolean |
ProducerCache.sendExchange(Endpoint endpoint,
Producer producer,
Processor processor,
Exchange exchange,
AsyncCallback callback)
|
|
void |
MessageSupport.setExchange(Exchange exchange)
|
|
static void |
ProducerCache.setProcessedSync(Exchange exchange,
boolean sync)
|
|
Object |
ZipDataFormat.unmarshal(Exchange exchange,
InputStream stream)
|
|
Object |
StringDataFormat.unmarshal(Exchange exchange,
InputStream stream)
|
|
Object |
SerializationDataFormat.unmarshal(Exchange exchange,
InputStream stream)
|
Method parameters in org.apache.camel.impl with type arguments of type Exchange | |
---|---|
Exchange |
DefaultEndpoint.convertTo(Class<Exchange> type,
Exchange exchange)
Converts the given exchange to the specified exchange type |
void |
GroupedExchange.setExchanges(List<Exchange> exchanges)
|
Constructors in org.apache.camel.impl with parameters of type Exchange | |
---|---|
DefaultExchange(Exchange parent)
|
|
GroupedExchange(Exchange parent)
|
Constructor parameters in org.apache.camel.impl with type arguments of type Exchange | |
---|---|
EventDrivenPollingConsumer(Endpoint endpoint,
BlockingQueue<Exchange> queue)
|
Uses of Exchange in org.apache.camel.impl.converter |
---|
Methods in org.apache.camel.impl.converter with parameters of type Exchange | ||
---|---|---|
|
ToStringTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
StaticMethodTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
StaticMethodFallbackTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
PropertyEditorTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
InstanceMethodTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
InstanceMethodFallbackTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
EnumTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
DefaultTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
AsyncProcessorTypeConverter.convertTo(Class<T> toType,
Exchange exchange,
Object value)
|
|
|
ArrayTypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
|
|
|
DefaultTypeConverter.doConvertTo(Class<T> type,
Exchange exchange,
Object value)
|
Uses of Exchange in org.apache.camel.language.bean |
---|
Methods in org.apache.camel.language.bean that return Exchange | |
---|---|
Exchange |
RuntimeBeanExpressionException.getExchange()
|
Methods in org.apache.camel.language.bean with parameters of type Exchange | ||
---|---|---|
protected String |
BeanExpression.assertionFailureMessage(Exchange exchange)
|
|
void |
BeanExpression.assertMatches(String text,
Exchange exchange)
|
|
Object |
BeanExpression.evaluate(Exchange exchange)
|
|
|
BeanExpression.evaluate(Exchange exchange,
Class<T> type)
|
|
boolean |
BeanExpression.matches(Exchange exchange)
|
Constructors in org.apache.camel.language.bean with parameters of type Exchange | |
---|---|
RuntimeBeanExpressionException(Exchange exchange,
String bean,
String method,
Throwable e)
|
Uses of Exchange in org.apache.camel.management |
---|
Methods in org.apache.camel.management with parameters of type Exchange | |
---|---|
void |
InstrumentationProcessor.process(Exchange exchange)
|
boolean |
InstrumentationProcessor.process(Exchange exchange,
AsyncCallback callback)
|
protected void |
InstrumentationProcessor.recordTime(Exchange exchange,
double duration)
|
Uses of Exchange in org.apache.camel.model.language |
---|
Methods in org.apache.camel.model.language with parameters of type Exchange | ||
---|---|---|
void |
ExpressionDefinition.assertMatches(String text,
Exchange exchange)
|
|
Object |
ExpressionDefinition.evaluate(Exchange exchange)
|
|
|
ExpressionDefinition.evaluate(Exchange exchange,
Class<T> type)
|
|
boolean |
ExpressionDefinition.matches(Exchange exchange)
|
Uses of Exchange in org.apache.camel.model.loadbalancer |
---|
Methods in org.apache.camel.model.loadbalancer with parameters of type Exchange | |
---|---|
void |
LoadBalancerDefinition.process(Exchange exchange)
|
boolean |
LoadBalancerDefinition.process(Exchange exchange,
AsyncCallback callback)
|
Uses of Exchange in org.apache.camel.processor |
---|
Methods in org.apache.camel.processor with type parameters of type Exchange | ||
---|---|---|
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 |
WireTapProcessor.configureExchange(Exchange exchange)
|
protected Exchange |
SendProcessor.configureExchange(Exchange exchange)
|
protected Exchange |
Pipeline.createNextExchange(Processor producer,
Exchange previousExchange)
Strategy method to create the next exchange from the previous exchange. |
protected Exchange |
Enricher.createResourceExchange(Exchange source,
ExchangePattern pattern)
Creates a new DefaultExchange instance from the given
exchange . |
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 expression)
|
protected static Set<Exchange> |
Resequencer.createSet(List<Expression> expressions)
|
protected Collection<Exchange> |
BatchProcessor.getCollection()
|
Methods in org.apache.camel.processor with parameters of type Exchange | |
---|---|
protected void |
DeadLetterChannel.asyncProcess(Exchange exchange,
AsyncCallback callback,
org.apache.camel.processor.DeadLetterChannel.RedeliveryData data)
|
protected Exchange |
WireTapProcessor.configureExchange(Exchange exchange)
|
protected Exchange |
SendProcessor.configureExchange(Exchange exchange)
|
protected String |
ThroughputLogger.createLogMessage(Exchange exchange,
int receivedCount)
|
protected Exchange |
Pipeline.createNextExchange(Processor producer,
Exchange previousExchange)
Strategy method to create the next exchange from the previous exchange. |
protected Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> |
Splitter.createProcessorExchangePairs(Exchange exchange)
|
protected Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> |
MulticastProcessor.createProcessorExchangePairs(Exchange exchange)
|
protected Exchange |
Enricher.createResourceExchange(Exchange source,
ExchangePattern pattern)
Creates a new DefaultExchange instance from the given
exchange . |
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 abstract void |
DelayProcessorSupport.delay(Exchange exchange)
|
protected void |
Delayer.delay(Exchange exchange)
Waits for an optional time period before continuing to process the exchange |
protected void |
MulticastProcessor.doAggregate(AtomicExchange result,
Exchange exchange)
Aggregate the Exchange with the current result |
protected OnExceptionDefinition |
ErrorHandlerSupport.getExceptionPolicy(Exchange exchange,
Throwable exception)
Attempts to find the best suited OnExceptionDefinition to be used for handling the given thrown exception. |
protected void |
TryProcessor.handleException(Exchange exchange,
Throwable 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 |
ThroughputLogger.logMessage(Exchange exchange)
|
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 |
WireTapProcessor.process(Exchange exchange)
|
void |
UnmarshalProcessor.process(Exchange exchange)
|
void |
TryProcessor.process(Exchange exchange)
|
void |
TransformProcessor.process(Exchange exchange)
|
void |
ThrowFaultProcessor.process(Exchange exchange)
Set the fault message in the exchange |
void |
ThroughputLogger.process(Exchange exchange)
|
void |
ThreadProcessor.process(Exchange exchange)
|
void |
StreamResequencer.process(Exchange exchange)
|
void |
SortProcessor.process(Exchange exchange)
|
void |
SendProcessor.process(Exchange exchange)
|
void |
RoutingSlip.process(Exchange exchange)
|
void |
RecipientList.process(Exchange exchange)
|
void |
ProceedProcessor.process(Exchange exchange)
|
void |
Pipeline.process(Exchange exchange)
|
void |
MulticastProcessor.process(Exchange exchange)
|
void |
MarshalProcessor.process(Exchange exchange)
|
void |
LoopProcessor.process(Exchange exchange)
|
void |
LoggingErrorHandler.process(Exchange exchange)
|
void |
Logger.process(Exchange exchange)
|
void |
Interceptor.process(Exchange exchange)
|
void |
HandleFaultProcessor.process(Exchange exchange)
|
void |
FilterProcessor.process(Exchange exchange)
|
void |
ExchangePatternProcessor.process(Exchange exchange)
|
void |
Enricher.process(Exchange exchange)
Enriches the input data ( exchange ) by first obtaining
additional data from an endpoint represented by an endpoint
producer and second by aggregating input data and additional
data. |
void |
DelegateProcessor.process(Exchange exchange)
|
void |
DelegateAsyncProcessor.process(Exchange exchange)
|
void |
DelayProcessorSupport.process(Exchange exchange)
|
void |
DeadLetterChannel.process(Exchange exchange)
|
void |
ConvertBodyProcessor.process(Exchange exchange)
|
void |
CompositeProcessor.process(Exchange exchange)
|
void |
ChoiceProcessor.process(Exchange exchange)
|
void |
BatchProcessor.process(Exchange exchange)
Enqueues an exchange for later batch processing. |
boolean |
WireTapProcessor.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
UnitOfWorkProcessor.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
ThreadProcessor.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
SendProcessor.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
Pipeline.process(Exchange original,
AsyncCallback callback)
|
boolean |
HandleFaultProcessor.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
ExchangePatternProcessor.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
DelegateAsyncProcessor.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
DeadLetterChannel.process(Exchange exchange,
AsyncCallback callback)
|
protected boolean |
DeadLetterChannel.process(Exchange exchange,
AsyncCallback callback,
org.apache.camel.processor.DeadLetterChannel.RedeliveryData data)
Processes the exchange using decorated with this dead letter channel. |
void |
Logger.process(Exchange exchange,
Throwable exception)
|
protected void |
BatchProcessor.processExchange(Exchange exchange)
Strategy Method to process an exchange in the batch. |
protected void |
TryProcessor.processFinally(Exchange exchange)
|
protected void |
DelegateProcessor.processNext(Exchange exchange)
|
protected Endpoint |
RoutingSlip.resolveEndpoint(Exchange exchange,
Object recipient)
|
protected Endpoint |
RecipientList.resolveEndpoint(Exchange exchange,
Object recipient)
|
protected static void |
DeadLetterChannel.restoreExceptionOnExchange(Exchange exchange,
Predicate handledPredicate)
|
void |
StreamResequencer.sendElement(Exchange exchange)
Sends the exchange to the next processor . |
void |
RecipientList.sendToRecipientList(Exchange exchange,
Object receipientList)
Sends the given exchange to the recipient list |
boolean |
RedeliveryPolicy.shouldRedeliver(Exchange exchange,
int redeliveryCounter,
Predicate retryUntil)
Returns true if the policy decides that the message exchange should be redelivered. |
protected void |
Splitter.updateNewExchange(Exchange exchange,
int index,
Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> allPairs)
|
protected void |
MulticastProcessor.updateNewExchange(Exchange exchange,
int i,
Iterable<org.apache.camel.processor.MulticastProcessor.ProcessorExchangePair> allPairs)
|
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)
|
Constructor parameters in org.apache.camel.processor with type arguments of type Exchange | |
---|---|
BatchProcessor(Processor processor,
Collection<Exchange> collection)
|
|
Resequencer(Processor processor,
Set<Exchange> collection)
|
|
StreamResequencer(Processor processor,
SequenceElementComparator<Exchange> comparator)
Creates a new StreamResequencer instance. |
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 | |
---|---|
protected Map<Object,Exchange> |
DefaultAggregationCollection.getAggregated()
|
Iterator<Exchange> |
PredicateAggregationCollection.iterator()
|
Iterator<Exchange> |
DefaultAggregationCollection.iterator()
|
Iterator<Exchange> |
AggregationCollection.iterator()
Gets the iterator to iterate this collection. |
Methods in org.apache.camel.processor.aggregate with parameters of type Exchange | |
---|---|
boolean |
DefaultAggregationCollection.add(Exchange exchange)
|
boolean |
AggregationCollection.add(Exchange exchange)
Adds the given exchange to this collection |
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 |
protected Exception |
UseLatestAggregationStrategy.checkException(Exchange oldExchange,
Exchange newExchange)
|
void |
PredicateAggregationCollection.onAggregation(Object correlationKey,
Exchange newExchange)
|
void |
DefaultAggregationCollection.onAggregation(Object correlationKey,
Exchange newExchange)
|
void |
AggregationCollection.onAggregation(Object correlationKey,
Exchange newExchange)
A strategy method allowing derived classes such as PredicateAggregationCollection
to check to see if the aggregation has completed |
Uses of Exchange in org.apache.camel.processor.exceptionpolicy |
---|
Methods in org.apache.camel.processor.exceptionpolicy with parameters of type Exchange | |
---|---|
OnExceptionDefinition |
ExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,OnExceptionDefinition> exceptionPolicices,
Exchange exchange,
Throwable exception)
Resolves the OnExceptionDefinition that should handle the thrown exception. |
OnExceptionDefinition |
DefaultExceptionPolicyStrategy.getExceptionPolicy(Map<ExceptionPolicyKey,OnExceptionDefinition> exceptionPolicices,
Exchange exchange,
Throwable exception)
|
protected boolean |
DefaultExceptionPolicyStrategy.matchesWhen(OnExceptionDefinition type,
Exchange exchange)
Strategy method for matching the exception type with the current exchange. |
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 with parameters of type Exchange | |
---|---|
protected void |
IdempotentConsumer.onCompletedMessage(Exchange exchange,
String messageId)
A strategy method to allow derived classes to overload the behaviour of processing a completed message |
protected void |
IdempotentConsumer.onDuplicateMessage(Exchange exchange,
String messageId)
A strategy method to allow derived classes to overload the behaviour of processing a duplicate message |
protected void |
IdempotentConsumer.onFailedMessage(Exchange exchange,
String messageId)
A strategy method to allow derived classes to overload the behaviour of processing a failed message |
void |
IdempotentConsumer.process(Exchange exchange)
|
Constructors in org.apache.camel.processor.idempotent with parameters of type Exchange | |
---|---|
NoMessageIdException(Exchange exchange,
Expression expression)
|
Uses of Exchange in org.apache.camel.processor.interceptor |
---|
Classes in org.apache.camel.processor.interceptor that implement Exchange | |
---|---|
class |
TraceEventExchange
Represents a trace of an Exchange , intercepted at the given node
that occured during routing. |
Methods in org.apache.camel.processor.interceptor that return Exchange | |
---|---|
protected Exchange |
DebugInterceptor.copyExchange(Exchange previousExchange)
|
Exchange |
ExceptionEvent.getExchange()
|
Exchange |
TraceEventExchange.getTracedExchange()
|
Exchange |
TraceEventExchange.newInstance()
|
Methods in org.apache.camel.processor.interceptor that return types with arguments of type Exchange | |
---|---|
protected List<Exchange> |
Debugger.createExchangeList()
|
List<Exchange> |
DebugInterceptor.getExchanges()
|
List<Exchange> |
Debugger.getExchanges(String id)
Returns the list of exchanges sent to the given node in the DSL |
Methods in org.apache.camel.processor.interceptor with parameters of type Exchange | |
---|---|
protected void |
DebugInterceptor.addTraceExchange(Exchange exchange)
Strategy method to store the exchange in a trace log if it is enabled |
protected void |
DebugInterceptor.checkForBreakpoint(Exchange exchange)
Stategy method to wait for a breakpoint if one is set |
protected Exchange |
DebugInterceptor.copyExchange(Exchange previousExchange)
|
void |
DelayInterceptor.delay(Exchange exchange)
|
protected String |
DefaultTraceFormatter.extractBreadCrumb(TraceInterceptor interceptor,
ProcessorDefinition currentNode,
Exchange exchange)
Creates the breadcrumb based on whether this was a trace of an exchange coming out of or into a processing step. |
Object |
TraceInterceptor.format(Exchange exchange)
|
Object |
TraceFormatter.format(TraceInterceptor interceptor,
ProcessorDefinition node,
Exchange exchange)
Formats a log message at given point of interception. |
Object |
DefaultTraceFormatter.format(TraceInterceptor interceptor,
ProcessorDefinition node,
Exchange exchange)
|
protected Object |
DefaultTraceFormatter.getBreadCrumbID(Exchange exchange)
|
protected void |
TraceInterceptor.logException(Exchange exchange,
Throwable throwable)
|
protected void |
TraceInterceptor.logExchange(Exchange exchange)
|
protected void |
DebugInterceptor.onException(Exchange exchange,
Throwable e)
Fired when an exception is thrown when processing the underlying processor |
boolean |
StreamCachingInterceptor.proceed(Exchange exchange,
AsyncCallback callback)
|
void |
TraceInterceptor.process(Exchange exchange)
|
void |
StreamCachingInterceptor.process(Exchange exchange)
|
void |
DebugInterceptor.process(Exchange exchange)
|
boolean |
StreamCachingInterceptor.process(Exchange exchange,
AsyncCallback callback)
|
void |
TraceEventExchange.setTracedExchange(Exchange tracedExchange)
|
protected boolean |
TraceInterceptor.shouldLogException(Exchange exchange)
Returns true if the given exchange should be logged when an exception was thrown |
protected boolean |
TraceInterceptor.shouldLogExchange(Exchange exchange)
Returns true if the given exchange should be logged in the trace list |
protected boolean |
DebugInterceptor.shouldTraceExchange(Exchange exchange)
Returns true if the given exchange should be logged in the trace list |
protected void |
TraceInterceptor.traceExchange(Exchange exchange)
|
void |
Breakpoint.waitForBreakpoint(Exchange exchange)
|
Constructors in org.apache.camel.processor.interceptor with parameters of type Exchange | |
---|---|
DefaultTraceEventMessage(Date timestamp,
ProcessorDefinition toNode,
Exchange exchange)
Creates a DefaultTraceEventMessage based on the given node it was traced while processing
the current Exchange |
|
ExceptionEvent(DebugInterceptor interceptor,
Exchange exchange,
Throwable exception)
|
|
TraceEventExchange(Exchange parent)
|
Constructor parameters in org.apache.camel.processor.interceptor with type arguments of type Exchange | |
---|---|
DebugInterceptor(ProcessorDefinition node,
Processor target,
List<Exchange> exchanges,
List<ExceptionEvent> exceptions)
|
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 |
StickyLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RandomLoadBalancer.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. |
protected boolean |
FailOverLoadBalancer.isCheckedException(Exchange exchange)
|
void |
TopicLoadBalancer.process(Exchange exchange)
|
void |
QueueLoadBalancer.process(Exchange exchange)
|
void |
FailOverLoadBalancer.process(Exchange exchange)
|
boolean |
TopicLoadBalancer.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
QueueLoadBalancer.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
FailOverLoadBalancer.process(Exchange exchange,
AsyncCallback callback)
|
boolean |
FailOverLoadBalancer.processExchange(int index,
Exchange exchange,
AsyncCallback callback)
|
Uses of Exchange in org.apache.camel.processor.resequencer |
---|
Methods in org.apache.camel.processor.resequencer with parameters of type Exchange | |
---|---|
int |
DefaultExchangeComparator.compare(Exchange o1,
Exchange o2)
|
boolean |
DefaultExchangeComparator.predecessor(Exchange o1,
Exchange o2)
|
boolean |
DefaultExchangeComparator.successor(Exchange o1,
Exchange o2)
|
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 |
ValidatorErrorHandler.handleErrors(Exchange exchange,
Schema schema,
DOMResult result)
Process any errors which may have occurred during validation |
void |
DefaultValidationErrorHandler.handleErrors(Exchange exchange,
Schema schema,
DOMResult result)
|
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 |
---|
Methods in org.apache.camel.spi that return types with arguments of type Exchange | |
---|---|
List<Exchange> |
BrowsableEndpoint.getExchanges()
Return the exchanges available on this endpoint |
Methods in org.apache.camel.spi with parameters of type Exchange | ||
---|---|---|
|
ExchangeConverter.convertTo(Class<T> type,
Exchange exchange)
Converts the given exchange to the new type |
|
void |
UnitOfWork.done(Exchange exchange)
Invoked when this unit of work has been completed, whether it has failed or completed |
|
Object |
ExchangeFormatter.format(Exchange exchange)
Generates a string representation of the exchange |
|
void |
DataFormat.marshal(Exchange exchange,
Object graph,
OutputStream stream)
Marshals the object to the given Stream. |
|
void |
Synchronization.onComplete(Exchange exchange)
Called when the processing of the message exchange is complete |
|
void |
Synchronization.onFailure(Exchange exchange)
Called when the processing of the message exchange has failed for some reason. |
|
Object |
DataFormat.unmarshal(Exchange exchange,
InputStream stream)
Unmarshals the given stream into an object. |
Uses of Exchange in org.apache.camel.util |
---|
Methods in org.apache.camel.util that return Exchange | |
---|---|
static Exchange |
ExchangeHelper.getExchangeById(Iterable<Exchange> exchanges,
String exchangeId)
Returns the first exchange in the given collection of exchanges which has the same exchange ID as the one given or null if none could be found |
Methods in org.apache.camel.util with parameters of type Exchange | ||
---|---|---|
static void |
PredicateAssertHelper.assertMatches(Predicate predicate,
String text,
Exchange exchange)
|
|
int |
ExpressionListComparator.compare(Exchange e1,
Exchange e2)
|
|
int |
ExpressionComparator.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 void |
ExchangeHelper.copyResults(Exchange result,
Exchange source)
Copies the results of a message exchange from the source exchange to the result exchange which will copy the out and fault message contents and the exception |
|
static void |
ExchangeHelper.copyResultsPreservePattern(Exchange result,
Exchange source)
Copies the source exchange to target exchange
preserving the ExchangePattern of target . |
|
static Map |
ExchangeHelper.createVariableMap(Exchange exchange)
Creates a Map of the variables which are made available to a script or template |
|
static String |
ExchangeHelper.getContentType(Exchange exchange)
Returns the MIME content type on the input message or null if one is not defined |
|
static
|
ExchangeHelper.getExchangeProperty(Exchange exchange,
String propertyName,
Class<T> type,
T defaultValue)
Extracts the exchange property of the given name and type; if it is not present then the default value will be used |
|
static
|
ExchangeHelper.getMandatoryHeader(Exchange exchange,
String propertyName,
Class<T> type)
|
|
static Object |
ExchangeHelper.getMandatoryInBody(Exchange exchange)
Returns the mandatory inbound message body of the correct type or throws an exception if it is not present |
|
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 Object |
ExchangeHelper.getMandatoryOutBody(Exchange exchange)
Returns the mandatory outbound message body of the correct type or throws an exception if it is not present |
|
static
|
ExchangeHelper.getMandatoryOutBody(Exchange exchange,
Class<T> type)
Returns the mandatory outbound 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)
|
|
static Message |
ExchangeHelper.getResultMessage(Exchange exchange)
Returns the message where to write results in an exchange-pattern-sensitive way. |
|
static boolean |
ExchangeHelper.isFailureHandled(Exchange exchange)
|
|
static boolean |
ExchangeHelper.isInCapable(Exchange exchange)
Returns true if the given exchange pattern (if defined) can support IN messagea |
|
static boolean |
ExchangeHelper.isOutCapable(Exchange exchange)
Returns true if the given exchange pattern (if defined) can support OUT messagea |
|
static Object |
ExchangeHelper.lookupBean(Exchange exchange,
String name)
Performs a lookup in the registry of the bean name |
|
static
|
ExchangeHelper.lookupBean(Exchange exchange,
String name,
Class<T> type)
Performs a lookup in the registry of the bean name and type |
|
static Object |
ExchangeHelper.lookupMandatoryBean(Exchange exchange,
String name)
Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found |
|
static
|
ExchangeHelper.lookupMandatoryBean(Exchange exchange,
String name,
Class<T> type)
Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found |
|
static
|
ExchangeHelper.newInstance(Exchange exchange,
Class<T> type)
Creates a new instance of the given type from the injector |
|
static void |
ExchangeHelper.populateVariableMap(Exchange exchange,
Map map)
Populates the Map with the variables which are made available to a script or template |
|
static void |
AsyncProcessorHelper.process(AsyncProcessor processor,
Exchange exchange)
Calls the async version of the processor's process method and waits for it to complete before returning. |
|
static Endpoint |
ExchangeHelper.resolveEndpoint(Exchange exchange,
Object value)
Attempts to resolve the endpoint for the given value |
|
static void |
ExchangeHelper.setFailureHandled(Exchange exchange)
|
Method parameters in org.apache.camel.util with type arguments of type Exchange | |
---|---|
static Exchange |
ExchangeHelper.getExchangeById(Iterable<Exchange> exchanges,
String exchangeId)
Returns the first exchange in the given collection of exchanges which has the same exchange ID as the one given or null if none could be found |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |