Bootstrap and configuration
Camel Quarkus automatically configures and deploys a Camel Context bean which by default is started/stopped according to
the Quarkus Application lifecycle. The configuration step happens at build time during Quarkus' augmentation phase and
it is driven by the Camel Quarkus extensions which can be tuned using Camel Quarkus specific camel.quarkus.*
properties. After the configuration is done, a minimal Camel Runtime is assembled and started at
RUNTIME_INIT time.
CDI
The CDI APIs can be used to configure various aspects of Camel behavior. For example, to configure the LogComponent
you can write a code like:
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Named;
import org.apache.camel.component.log.LogComponent;
import org.apache.camel.support.processor.DefaultExchangeFormatter;
@ApplicationScoped
public class Configurations {
/**
* Produces a {@link LogComponent} instance with a custom exchange formatter set-up.
*/
@Named (1)
LogComponent log() {
DefaultExchangeFormatter formatter = new DefaultExchangeFormatter();
formatter.setShowExchangePattern(false);
formatter.setShowBodyType(false);
LogComponent component = new LogComponent();
component.setExchangeFormatter(formatter);
return component;
}
}
1 | Camel uses the component URI scheme to look-up components from its registry, this requires you to add the @Named annotation to the method, otherwise the CDI container would create an anonymous bean and Camel would not be able to look it up. |
In Camel Quarkus the Camel components are discovered during the augmentation phase, producing a new component as shown in the example above would invalidate any optimization that may have been made.
As a better alternative you can use @Inject
to obtain an instance of a component automatically created by Camel or you can observe one of the events fired by Camel Quarkus as shown in the following example, in which we use @Observes
to be notified about components added to the Camel Context:
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Observes;
import org.apache.camel.quarkus.core.events.ComponentAddEvent;
import org.apache.camel.component.log.LogComponent;
@ApplicationScoped
public static class EventHandler {
public void onComponentAdd(@Observes ComponentAddEvent event) {
if (event.getComponent() instanceof LogComponent) {
// do something with the log component
}
}
}
Camel Main
To configure components and other aspects of Apache Camel through properties, you can add the camel-quarkus-main
extension which brings functionalities from Apache Camel
Main to Camel Quarkus.
In the example below, we apply the same configuration as the one from the Java example above by using properties:
camel.component.log.exchange-formtatter = #class:org.apache.camel.support.processor.DefaultExchangeFormatter
camel.component.log.exchange-formtatter.show-exchange-pattern = false
camel.component.log.exchange-formtatter.show-body-type = false
In addition to support configuring Camel through properties, camel-quarkus-main
allows you to use conventions to configure the Camel behavior. For example, if there is a single ExchangeFormatter
instance in the CDI container, then it will automatically wire that bean to the LogComponent
.
Camel Main also brings the option to write Quarkus Command Mode Applications with control about when the Camel runtime should start:
import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.annotations.QuarkusMain;
import org.apache.camel.quarkus.main.CamelMainApplication;
@QuarkusMain
public class Main {
public static void main(String... args) {
//
// your logic here
//
Quarkus.run(CamelMainApplication.class, args); (1)
}
}
1 | Start Quarkus and the Camel Quarkus runtime |
It is recommended to perform very little logic in the Java Main. |
XML Configuration
In order to configure Camel routes, rests or templates in XML, you must add a Camel XML parser dependency to the classpath. E.g either camel-quarkus-xml-io
or
camel-quarkus-xml-jaxb
. camel-quarkus-xml-io
is preferred due to its lightweight implementation.
Routes
With Camel Main, you can set a property that points to the location of route XML files:
camel.main.xml-routes = routes/routes.xml, file:src/main/routes/other-routes.xml
Path globbing like |
Spring XML with <beans>
or Blueprint XML with <blueprint>
elements are not supported. The route XML should be in the simplified version like:
<routes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://camel.apache.org/schema/spring"
xsi:schemaLocation="
http://camel.apache.org/schema/spring
http://camel.apache.org/schema/spring/camel-spring.xsd">
<route id="xml-route">
<from uri="timer:from-xml?period=1000"/>
<log message="Hello XML!"/>
</route>
</routes>
REST DSL
The Camel REST DSL can be defined in XML and configured with Camel Main via a property:
camel.main.xml-rests = rests/rests.xml, file:src/main/rests/other-rests.xml
The XML for the REST configuration looks like:
<rests xmlns="http://camel.apache.org/schema/spring">
<rest id="greeting" path="/greeting">
<get uri="/hello">
<setBody>
<constant>Hello World!</constant>
</setBody>
</get>
</rest>
</rests>
Route Templates
Route templates can be defined in XML and configured with Camel Main via a property:
camel.main.xml-route-templates = templates/route-template.xml, file:src/main/rests/other-route-template.xml
The XML for the route template configuration looks like:
<routeTemplates xmlns="http://camel.apache.org/schema/spring">
<routeTemplate id="myTemplate">
<templateParameter name="name"/>
<templateParameter name="greeting"/>
<templateParameter name="myPeriod" defaultValue="3s"/>
<route>
<from uri="timer:{{name}}?period={{myPeriod}}"/>
<setBody><simple>{{greeting}} ${body}</simple></setBody>
<log message="${body}"/>
</route>
</routeTemplate>
</routeTemplates>