|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Service | |
---|---|
org.apache.camel | The JAXB POJOs for the XML Configuration of the routing rules. |
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.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.ref | The Ref Component for lookup of existing
endpoints bound in the Registry . |
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 | Camel JMX export services. |
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.processor.interceptor | Helper classes for interceptors. |
org.apache.camel.processor.loadbalancer | Various load balancer processors |
org.apache.camel.spi | Service Provider Interfaces used internally by the Camel runtime which are plugin strategies. |
Uses of Service in org.apache.camel |
---|
Subinterfaces of Service in org.apache.camel | |
---|---|
interface |
BatchConsumer
A consumer of a batch of message exchanges from an Endpoint |
interface |
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
interface |
Consumer
A consumer of message exchanges from an Endpoint |
interface |
ConsumerTemplate
Template (named like Spring's TransactionTemplate & JmsTemplate et al) for working with Camel and consuming Message instances in an
Exchange from an Endpoint . |
interface |
PollingConsumer
Represents a Polling Consumer where the caller polls for messages when it is ready. |
interface |
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
interface |
ProducerTemplate
Template (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()
This property map is used to associate information about the route. |
Methods in org.apache.camel with parameters of type Service | |
---|---|
void |
Route.addService(Service service)
Adds a service to this route |
Method parameters in org.apache.camel with type arguments of type Service | |
---|---|
void |
Route.setServices(List<Service> services)
Sets the sources for this route |
Uses of Service in org.apache.camel.component.bean |
---|
Classes in org.apache.camel.component.bean that implement Service | |
---|---|
class |
BeanComponent
The Bean Component will look up the URI in the Spring ApplicationContext and use that to handle message dispatching. |
class |
BeanProcessor
A Processor which converts the inbound exchange to a method
invocation on a POJO |
Uses of Service in org.apache.camel.component.browse |
---|
Classes in org.apache.camel.component.browse that implement Service | |
---|---|
class |
BrowseComponent
The browse component. |
class |
BrowseEndpoint
An endpoint which maintains a List of Exchange instances
which can be useful for tooling, debugging and visualising routes. |
Uses of Service in org.apache.camel.component.dataset |
---|
Classes in org.apache.camel.component.dataset that implement Service | |
---|---|
class |
DataSetComponent
Component for DataSet. |
class |
DataSetConsumer
DataSet consumer. |
class |
DataSetEndpoint
Endpoint for DataSet. |
Uses of Service in org.apache.camel.component.direct |
---|
Classes in org.apache.camel.component.direct that implement Service | |
---|---|
class |
DirectComponent
Represents the component that manages DirectEndpoint . |
class |
DirectConsumer
The direct consumer. |
class |
DirectProducer
The direct producer. |
Uses of Service in org.apache.camel.component.file |
---|
Classes in org.apache.camel.component.file that implement Service | |
---|---|
class |
FileComponent
File component. |
class |
FileConsumer
File consumer. |
class |
GenericFileComponent<T>
Base class file component. |
class |
GenericFileConsumer<T>
Base class for remote file consumers. |
class |
GenericFileProducer<T>
Generic file producer |
Uses of Service in org.apache.camel.component.log |
---|
Classes in org.apache.camel.component.log that implement Service | |
---|---|
class |
LogComponent
The Log Component to log message exchanges to the underlying logging mechanism. |
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.ref |
---|
Classes in org.apache.camel.component.ref that implement Service | |
---|---|
class |
RefComponent
Component for lookup of existing endpoints bound in the Registry . |
Uses of Service in org.apache.camel.component.seda |
---|
Classes in org.apache.camel.component.seda that implement Service | |
---|---|
class |
CollectionProducer
A simple Producer which just appends to a Collection the Exchange object. |
class |
SedaComponent
An implementation of the SEDA components for asynchronous SEDA exchanges on a BlockingQueue within a CamelContext |
class |
SedaConsumer
A Consumer for the SEDA component. |
class |
SedaProducer
|
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
The timer consumer. |
Uses of Service in org.apache.camel.component.vm |
---|
Classes in org.apache.camel.component.vm that implement Service | |
---|---|
class |
VmComponent
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 |
ConsumerCache
Cache containing created Consumer . |
class |
DefaultCamelContext
Represents the context used to configure routes and the policies to use. |
class |
DefaultComponent
Default component to use for base for components implementations. |
class |
DefaultConsumer
A default consumer useful for implementation inheritance. |
class |
DefaultConsumerTemplate
|
class |
DefaultProducer
A default implementation of @{link Producer} for implementation inheritence |
class |
DefaultProducerServicePool
A service pool for Producer . |
class |
DefaultProducerTemplate
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 . |
class |
DefaultScheduledPollConsumer
A default implementation of an event driven Consumer which uses the
PollingConsumer |
class |
DefaultServicePool<Key,Service>
Default implementation to inherit for a basic service pool. |
class |
DefaultUnitOfWork
The default implementation of UnitOfWork |
class |
EventDrivenPollingConsumer
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 |
HeaderFilterStrategyComponent
|
class |
MainSupport
|
class |
PollingConsumerSupport
A useful base class for implementations of PollingConsumer |
class |
ProcessorPollingConsumer
A simple implementation of PollingConsumer which just uses
a Processor . |
class |
ProducerCache
Cache containing created Producer . |
class |
RouteService
Represents the runtime objects for a given RouteDefinition so that it can be stopped independently
of other routes |
class |
ScheduledPollConsumer
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 that return types with arguments of type Service | |
---|---|
List<Service> |
DefaultRoute.getServices()
|
List<Service> |
DefaultRoute.getServicesForRoute()
|
Methods in org.apache.camel.impl with parameters of type Service | |
---|---|
void |
DefaultRoute.addService(Service service)
|
void |
DefaultLifecycleStrategy.onServiceAdd(CamelContext context,
Service service)
|
protected void |
RouteService.startChildService(Service service)
|
void |
CamelPostProcessorHelper.startService(Service service)
|
protected void |
RouteService.stopChildService(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 |
protected void |
DefaultRoute.addServices(List<Service> services)
Strategy method to allow derived classes to lazily load services for the route |
void |
DefaultRoute.setServices(List<Service> services)
|
Constructors in org.apache.camel.impl with parameters of type Service | |
---|---|
DefaultRoute(Endpoint endpoint,
Service... services)
|
Uses of Service in org.apache.camel.management |
---|
Classes in org.apache.camel.management that implement Service | |
---|---|
class |
DefaultInstrumentationAgent
Default implementation of the Camel JMX service agent |
class |
InstrumentationProcessor
JMX enabled processor that uses the Counter for instrumenting
processing of exchanges. |
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 AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges. |
class |
AOPProcessor
|
class |
BatchProcessor
A base class for any kind of Processor which implements some kind of batch processing. |
class |
CatchProcessor
A processor which catches exceptions. |
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 |
DefaultChannel
DefaultChannel is the default Channel . |
class |
DefaultErrorHandler
Default error handler |
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 |
Enricher
A content enricher that enriches input data by first obtaining additional data from a resource represented by an endpoint producer
and second by aggregating input data and additional data. |
class |
ErrorHandlerSupport
Support class for ErrorHandler implementations. |
class |
FilterProcessor
The processor which implements the Message Filter EIP pattern. |
class |
InterceptEndpointProcessor
Endpoint intercept processor so we know the processor is supposed to intercept an andpoint. |
class |
LoggingErrorHandler
An ErrorHandler which uses commons-logging to dump the error |
class |
LoopProcessor
The processor which sends messages in a loop. |
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 |
OnCompletionProcessor
|
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 |
PollEnricher
A content enricher that enriches input data by first obtaining additional data from a resource represented by an endpoint producer
and second by aggregating input data and additional data. |
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 |
RedeliveryErrorHandler
Base redeliverable error handler that also supports a final dead letter queue in case all redelivery attempts fail. |
class |
Resequencer
An implementation of the Resequencer which can reorder messages within a batch. |
class |
RoutingSlip
Implements a Routing Slip pattern where the list of actual endpoints to send a message exchange to are dependent on the value of a message header. |
class |
SendProcessor
Processor for forwarding exchanges to an endpoint destination. |
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 |
StreamResequencer
A resequencer that re-orders a (continuous) stream of Exchange s. |
class |
ThreadsProcessor
Threads processor that leverage a thread pool for processing exchanges. |
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 |
TransformProcessor
A processor which sets the body on the OUT message with an expression |
class |
TryProcessor
Implements try/catch/finally type processing |
class |
UnitOfWorkProcessor
Handles calling the UnitOfWork.done() method when processing of an exchange is complete. |
class |
WireTapProcessor
Processor for wire tapping exchanges to an endpoint destination. |
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.processor.interceptor |
---|
Classes in org.apache.camel.processor.interceptor that implement Service | |
---|---|
class |
DelayInterceptor
An interceptor for delaying routes. |
class |
HandleFaultInterceptor
|
class |
StreamCachingInterceptor
DelegateProcessor that converts a message into a re-readable format |
class |
TraceInterceptor
An interceptor for debugging and tracing routes |
Uses of Service in org.apache.camel.processor.loadbalancer |
---|
Classes in org.apache.camel.processor.loadbalancer that implement Service | |
---|---|
class |
FailOverLoadBalancer
This FailOverLoadBalancer will failover to use next processor when an exception occured |
class |
LoadBalancerConsumer
Represents a consumer which on starting registers itself with a LoadBalancer and on closing unregisters
itself with a load balancer |
class |
LoadBalancerSupport
A default base class for a LoadBalancer implementation |
class |
QueueLoadBalancer
A base class for LoadBalancer implementations which choose a single
destination for each exchange (rather like JMS Queues) |
class |
RandomLoadBalancer
Implements the random load balancing policy |
class |
RoundRobinLoadBalancer
Implements the round robin load balancing policy |
class |
StickyLoadBalancer
Implements a sticky load balancer using an Expression to calculate
a correlation key to perform the sticky load balancing; rather like jsessionid in the web
or JMSXGroupID in JMS. |
class |
TopicLoadBalancer
A LoadBalancer implementations which sends to all destinations
(rather like JMS Topics). |
Uses of Service in org.apache.camel.spi |
---|
Subinterfaces of Service in org.apache.camel.spi | |
---|---|
interface |
InstrumentationAgent
Camel JMX service agent |
interface |
ServicePool<Key,Service>
A service pool is like a connection pool but can pool any kind of objects. |
Methods in org.apache.camel.spi with parameters of type Service | |
---|---|
void |
LifecycleStrategy.onServiceAdd(CamelContext context,
Service service)
Notification on adding a Service . |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |