|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Service | |
---|---|
org.apache.camel | The core Camel API |
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.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.timer | The Timer Component extends the POJO component to provide a simple timer |
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.management | |
org.apache.camel.processor | A collection of Processor implementations which are used to implement the Enterprise Integration Patterns |
org.apache.camel.processor.idempotent | An implementation of the Idempotent Consumer pattern. |
org.apache.camel.util | Utility classes used by the core of Camel and useful for Camel component developers |
Uses of Service in org.apache.camel |
---|
Subinterfaces of Service in org.apache.camel | |
---|---|
interface |
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
interface |
Consumer<E extends Exchange>
A consumer of message exchanges from an Endpoint |
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>
|
Classes in org.apache.camel that implement Service | |
---|---|
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 . |
Methods in org.apache.camel that return types with arguments of type Service | |
---|---|
List<Service> |
Route.getServices()
Returns the additional services required for this particular route |
List<Service> |
Route.getServicesForRoute()
|
Methods in org.apache.camel with parameters of type Service | |
---|---|
void |
Route.addService(Service service)
|
void |
LifecycleStrategy.onServiceAdd(CamelContext context,
Service service)
Notification on adding a Route . |
Method parameters in org.apache.camel with type arguments of type Service | |
---|---|
protected void |
Route.addServices(List<Service> services)
Strategy method to allow derived classes to lazily load services for the route |
void |
Route.setServices(List<Service> services)
|
Constructors in org.apache.camel with parameters of type Service | |
---|---|
Route(Endpoint<E> endpoint,
Service... services)
|
Uses of Service in org.apache.camel.component.bean |
---|
Classes in org.apache.camel.component.bean that implement Service | |
---|---|
class |
BeanComponent
An alternative to the POJO Component which implements the Bean Component which will look up the URI in the Spring ApplicationContext and use that to handle message dispatching. |
Uses of Service in org.apache.camel.component.file |
---|
Classes in org.apache.camel.component.file that implement Service | |
---|---|
class |
FileComponent
The File Component for working with file systems |
class |
FileConsumer
|
class |
FileProducer
A Producer implementation for File |
Uses of Service in org.apache.camel.component.jmx |
---|
Classes in org.apache.camel.component.jmx that implement Service | |
---|---|
class |
JMXComponent
The JMX Component for monitoring jmx attributes |
class |
JMXConsumer
Generate an Exchange after getting a JMX Notification |
Uses of Service in org.apache.camel.component.log |
---|
Classes in org.apache.camel.component.log that implement Service | |
---|---|
class |
LogComponent
|
Uses of Service in org.apache.camel.component.mock |
---|
Classes in org.apache.camel.component.mock that implement Service | |
---|---|
class |
MockComponent
A factory of MockEndpoint instances |
Uses of Service in org.apache.camel.component.seda |
---|
Classes in org.apache.camel.component.seda that implement Service | |
---|---|
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>
|
Uses of Service in org.apache.camel.component.timer |
---|
Classes in org.apache.camel.component.timer that implement Service | |
---|---|
class |
TimerComponent
Represents the component that manages TimerEndpoint . |
class |
TimerConsumer
|
Uses of Service in org.apache.camel.component.vm |
---|
Classes in org.apache.camel.component.vm that implement Service | |
---|---|
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. |
Uses of Service in org.apache.camel.impl |
---|
Classes in org.apache.camel.impl that implement Service | |
---|---|
class |
DefaultCamelContext
Represents the context used to configure routes and the policies to use. |
class |
DefaultComponent<E extends Exchange>
|
class |
DefaultConsumer<E extends Exchange>
|
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 |
PollingConsumerSupport<E extends Exchange>
A useful base class for implementations of PollingConsumer |
class |
ScheduledPollConsumer<E extends Exchange>
A useful base class for any consumer which is polling based |
class |
ServiceSupport
A useful base class which ensures that a service is only initialized once and provides some helper methods for enquiring of its status |
Methods in org.apache.camel.impl with parameters of type Service | |
---|---|
void |
DefaultLifecycleStrategy.onServiceAdd(CamelContext context,
Service service)
|
Method parameters in org.apache.camel.impl with type arguments of type Service | |
---|---|
protected void |
EventDrivenConsumerRoute.addServices(List<Service> services)
Factory method to lazily create the complete list of services required for this route such as adding the processor or consumer |
Uses of Service in org.apache.camel.management |
---|
Methods in org.apache.camel.management that return Service | |
---|---|
Service |
ManagedService.getService()
|
Methods in org.apache.camel.management with parameters of type Service | |
---|---|
void |
InstrumentationLifecycleStrategy.onServiceAdd(CamelContext context,
Service service)
|
Uses of Service in org.apache.camel.processor |
---|
Classes in org.apache.camel.processor that implement Service | |
---|---|
class |
Aggregator
An implementation of the Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of {@link AggregationStrategy ) (by default the latest message is used) to compress many message exchanges * into a smaller number of exchanges. |
class |
BatchProcessor
A base class for any kind of Processor which implements some kind of
batch processing. |
class |
CatchProcessor
|
class |
ChoiceProcessor
Implements a Choice structure where one or more predicates are used which if they are true their processors are used, with a default otherwise clause used if none match. |
class |
CompositeProcessor
Represents a composite pattern, aggregating a collection of processors together as a single processor |
class |
DeadLetterChannel
Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy |
class |
Delayer
A Delayer which delays processing the exchange until the correct amount of time has elapsed using an expression to determine the delivery time. |
class |
DelayProcessorSupport
A useful base class for any processor which provides some kind of throttling or delayed processing |
class |
DelegateProcessor
A Delegate pattern which delegates processing to a nested processor which can be useful for implementation inheritance when writing an Policy |
class |
ErrorHandlerSupport
|
class |
FilterProcessor
|
class |
Interceptor
An interceptor which provides the processing logic as a pluggable processor which allows the DelegateProcessor.proceed(Exchange) method to be called at some point |
class |
LoggingErrorHandler
An ErrorHandler which uses commons-logging to dump the error |
class |
MulticastProcessor
Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy of the message exchange. |
class |
Pipeline
Creates a Pipeline pattern where the output of the previous step is sent as input to the next step, reusing the same message exchanges |
class |
RecipientList
Implements a dynamic Recipient List pattern where the list of actual endpoints to send a message exchange to are dependent on some dynamic expression. |
class |
Resequencer
An implementation of the Resequencer which can reorder messages within a batch. |
class |
SendProcessor
|
class |
Splitter
Implements a dynamic Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint. |
class |
Throttler
A Throttler will set a limit on the maximum number of message exchanges which can be sent to a processor within a specific time period. |
class |
TryProcessor
Implements try/catch/finally type processing |
Uses of Service in org.apache.camel.processor.idempotent |
---|
Classes in org.apache.camel.processor.idempotent that implement Service | |
---|---|
class |
IdempotentConsumer
An implementation of the Idempotent Consumer pattern. |
Uses of Service in org.apache.camel.util |
---|
Classes in org.apache.camel.util that implement Service | |
---|---|
class |
ProducerCache<E extends Exchange>
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |