Camel CDI
As of 2.10 we now have support Contexts and Dependency Injection - JSR299 and Dependency Injection for Java - JSR330 as a dependency injection framework. This offers new opportunities to develop and deploy Apache Camel projects in Java EE 6 containers but also in standalone Java SE or CDI container
The current project is under active development and does not provide all the features that we have with injection frameworks like Spring or Blueprint
Dependency Injecting Camel with CDI
Basically, two things should be done to use Apache Camel in a CDI environment. First, we just need to create a BootStrap class which will be use by the Java EE 6 container or Java SE to start the Camel Context. The CdiCamelContext when instantiated will add a CDI Bean Registry. That will allow Camel to perform lookup of beans injected and registered in CDI container. Next, we must add CDI annotated beans (@inject, @named, ...) to use them from the Apache Camel routes.
Bootstrapping Camel with CDI container
The following example shows how we can bootstrap an Apache Camel Context in a Boot Strap class. This class contains important annotations like the javax.ejb.Singleton. This annotation will tell the container to create a Singleton instance of the BootStrapClass class. This mechanism is similar to Bean instance creation that we have with Spring framework. By combining this annotation with javax.ejb.Startup, the container will start the camel context at the startup of the CDI container.
Code Block |
---|
@Singleton
@Startup
public class BootStrap {
...
|
When the @PreConstruct annotation is called, then we inject a CdiCamelContext objet, register a SimpleCamelRoute using @Inject annotation and starts the Camel Route.
Code Block |
---|
@PostConstruct
public void init() throws Exception {
logger.info(">> Create CamelContext and register Camel Route.");
// Define Timer URI
simpleRoute.setTimerUri("timer://simple?fixedRate=true&period=10s");
// Add Camel Route
camelCtx.addRoutes(simpleRoute);
// Start Camel Context
camelCtx.start();
|
When you look to the following Camel Route code, you can see that we do a lookup to find a bean "helloWorld" which has been injected. This is possible because the CdiCamelContext registers a Camel Registry containing a reference to a CDI BeanManager.
Code Block |
---|
@Override
public void configure() throws Exception {
from(timerUri)
.setBody()
.simple("Bean Injected")
// Lookup for bean injected by CDI container
// The HellowWorld class is annotated using @Named
.beanRef("helloWorld", "sayHello")
.log(">> Response : ${body}");
}
|
Here is the code of the HelloWorld Bean
Code Block |
---|
@Named
public class HelloWorld {
public String sayHello(@Body String message) {
return ">> Hello " + message + " user.";
}
}
|
The Camel CDI component provides auto-configuration for Apache Camel using CDI as dependency injection framework based on the convention-over-configuration principle. It auto-detects Camel routes available in the application and provides beans for common Camel primitives like Endpoint
, ProducerTemplate
or TypeConverter
. It implements standard Camel bean integration so that Camel annotations like @Consume
, @Produce
and @PropertyInject
can be used seamlessly in CDI beans. Besides, it bridges Camel events (e.g. RouteAddedEvent
, CamelContextStartedEvent
or ExchangeCompletedEvent
) as CDI events and provides a CDI events endpoint that can be used to consume / produce CDI events from / to Camel routes.
Info |
---|
While the Camel CDI component is available as of Camel 2.10, it's been rewritten in Camel 2.17 to better fit into the CDI programming model. Hence some of the features like the Camel events to CDI events bridge and the CDI events endpoint only apply starting Camel 2.17. |
Auto-configured Camel context
Camel CDI automatically deploys and configures a CamelContext
bean. That CamelContext
bean is automatically instantiated, configured and started (resp. stopped) when the CDI container initialises (resp. shuts down). It can be injected in the application, e.g.:
Code Block | ||
---|---|---|
| ||
@Inject
CamelContext context; |
That default CamelContext
bean is qualified with the built-in @Default
qualifier, is scoped @ApplicationScoped
and is of type DefaultCamelContext
.
Note that this bean can be customised programmatically and other Camel context beans can be deployed in the application as well.
Auto-detecting Camel routes
Camel CDI collects all the RoutesBuilder
beans in the application when the CDI container initialises and automatically instantiates and add them to the CamelContext
bean instance. For example, adding a Camel route is as simple as declaring a class, e.g.:
As of 2.10 we now have support Contexts and Dependency Injection - JSR299 and Dependency Injection for Java - JSR330 as a dependency injection framework. This offers new opportunities to develop and deploy Apache Camel projects in Java EE 6 containers but also in standalone Java SE or CDI container
This project is started using the GlassFish maven plugin but alternatively, you can deploy the war file produced in any Java EE 6 servers : Glassfish, JBoss AS 7, OpenEJB, Apache TomEE or Apache KarafEE or using a Java SE.
See Also
- Simple Camel CDI BootStrap project
- JSR299 and JSR330 reference documentations
- Apache DeltaSpike project - CDI extensions and JavaSE BootStrap
- CDI revealed by Antonio Goncalves - part 1, part 2, part 3 and OpenEJB team - see examples
- Apache implementation of the specs JSR299, 330 - OpenWebbeans and Apache OpenEJB which provide the container to deploy CDI projects
- Apache Karaf featured with OpenEJB and CDI - Apache KarafEE