此内容没有您所选择的语言版本。

Chapter 15. Camel CDI

15.1. Basic Features
复制链接

Overview
复制链接

The Camel CDI component provides auto-configuration for Apache Camel using CDI as the dependency injection framework, based on convention-over-configuration. 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 (for example RouteAddedEvent, CamelContextStartedEvent, ExchangeCompletedEvent, ...) as CDI events and provides a CDI events endpoint that can be used to consume / produce CDI events from / to Camel routes.

How to enable Camel CDI in Apache Karaf
复制链接

To enable Camel CDI in Apache Karaf, perform the following steps:

Add the required pax-cdi, pax-cdi-weld, and camel-cdi features to the Karaf container, as follows:
```
JBossFuse:karaf@root> features:install pax-cdi pax-cdi-weld camel-cdi
```
```
JBossFuse:karaf@root> features:install pax-cdi pax-cdi-weld camel-cdi
```
Copy to Clipboard Toggle word wrap

To enable Camel CDI in a bundle, open the pom.xml file in your bundle's Maven project and add the following Require-Capability element to the configuration of the Maven bundle plug-in:

<project ...>
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <extensions>true</extensions>
        <configuration>
          <instructions>
            <Bundle-SymbolicName>${project.groupId}.${project.artifactId}</Bundle-SymbolicName>
            <Import-Package>*</Import-Package>
            <Require-Capability>
              osgi.extender; filter:="(osgi.extender=pax.cdi)",
              org.ops4j.pax.cdi.extension; filter:="(extension=camel-cdi-extension)"
            </Require-Capability>
          </instructions>
        </configuration>
      </plugin>
      ...
    </plugins>
  </build>
  ...
</project>

<project ...>
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <extensions>true</extensions>
        <configuration>
          <instructions>
            <Bundle-SymbolicName>${project.groupId}.${project.artifactId}</Bundle-SymbolicName>
            <Import-Package>*</Import-Package>
            <Require-Capability>
              osgi.extender; filter:="(osgi.extender=pax.cdi)",
              org.ops4j.pax.cdi.extension; filter:="(extension=camel-cdi-extension)"
            </Require-Capability>
          </instructions>
        </configuration>
      </plugin>
      ...
    </plugins>
  </build>
  ...
</project>

Copy to Clipboard

Toggle word wrap

To access the CDI annotations in Java, you must add a dependency on the CDI API package and on the Camel CDI package. Edit your bundle's POM file, pom.xml, to add the CDI API package as a Maven dependency:

<project ...>
  ...
  <dependencies>
    ...
    <!-- CDI API -->
    <dependency>
      <groupId>javax.enterprise</groupId>
      <artifactId>cdi-api</artifactId>
      <version>${cdi-api-1.2-version}</version>
      <scope>provided</scope>
    </dependency>

    <!-- Camel CDI API -->
    <dependency>
      <groupId>org.apache.camel</groupId>
      <artifactId>camel-cdi</artifactId>
      <version>2.17.0.redhat-630xxx</version>
    </dependency>
    ...
  </dependencies>
  ...
</project>

<project ...>
  ...
  <dependencies>
    ...
    <!-- CDI API -->
    <dependency>
      <groupId>javax.enterprise</groupId>
      <artifactId>cdi-api</artifactId>
      <version>${cdi-api-1.2-version}</version>
      <scope>provided</scope>
    </dependency>

    <!-- Camel CDI API -->
    <dependency>
      <groupId>org.apache.camel</groupId>
      <artifactId>camel-cdi</artifactId>
      <version>2.17.0.redhat-630xxx</version>
    </dependency>
    ...
  </dependencies>
  ...
</project>

Copy to Clipboard

Toggle word wrap

Rebuild your bundle in the usual way for your Maven project. For example, using the command:
```
mvn clean install
```
```
mvn clean install
```
Copy to Clipboard Toggle word wrap
Deploy the bundle to the Karaf container in the usual way (for example, using the osgi:install console command).

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, for example:

@Inject
CamelContext context;

@Inject
CamelContext context;

Copy to Clipboard

Toggle word wrap

The 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 automatically collects all the RoutesBuilder beans in the application, instantiates and add them to the CamelContext bean instance when the CDI container initialises. For example, adding a Camel route is as simple as declaring a class, for example:

class MyRouteBean extends RouteBuilder {
 
	@Override
    public void configure() {
        from("jms:invoices").to("file:/invoices");
    }
}

class MyRouteBean extends RouteBuilder {
 
	@Override
    public void configure() {
        from("jms:invoices").to("file:/invoices");
    }
}

Copy to Clipboard

Toggle word wrap

Note that you can declare as many RoutesBuilder beans as you want. Besides, RouteContainer beans are also automatically collected, instantiated and added to the CamelContext bean instance managed by Camel CDI when the container initialises.

Auto-configured Camel primitives
复制链接

Camel CDI provides beans for common Camel primitives that can be injected in any CDI beans, for example:

@Inject
@Uri("direct:inbound")
ProducerTemplate producerTemplate;

@Inject
MockEndpoint outbound; // URI defaults to the member name, i.e. mock:outbound

@Inject
@Uri("direct:inbound")
Endpoint endpoint;

@Inject
TypeConverter converter;

@Inject
@Uri("direct:inbound")
ProducerTemplate producerTemplate;

@Inject
MockEndpoint outbound; // URI defaults to the member name, i.e. mock:outbound

@Inject
@Uri("direct:inbound")
Endpoint endpoint;

@Inject
TypeConverter converter;

Copy to Clipboard

Toggle word wrap

Camel context configuration
复制链接

If you just want to change the name of the default CamelContext bean, you can used the @ContextName qualifier provided by Camel CDI, for example:

@ContextName("camel-context")
class MyRouteBean extends RouteBuilder {
 
	@Override
    public void configure() {
        from("jms:invoices").to("file:/invoices");
    }
}

@ContextName("camel-context")
class MyRouteBean extends RouteBuilder {
 
	@Override
    public void configure() {
        from("jms:invoices").to("file:/invoices");
    }
}

Copy to Clipboard

Toggle word wrap

Else, if more customisation is needed, any CamelContext class can be used to declare a custom Camel context bean. Then, the @PostConstruct and @PreDestroy lifecycle callbacks can be done to do the customisation, for example:

@ApplicationScoped
class CustomCamelContext extends DefaultCamelContext {

    @PostConstruct
    void customize() {
        // Set the Camel context name
        setName("custom");
        // Disable JMX
        disableJMX();
    }

    @PreDestroy
    void cleanUp() {
        // ...
    }
}

@ApplicationScoped
class CustomCamelContext extends DefaultCamelContext {

    @PostConstruct
    void customize() {
        // Set the Camel context name
        setName("custom");
        // Disable JMX
        disableJMX();
    }

    @PreDestroy
    void cleanUp() {
        // ...
    }
}

Copy to Clipboard

Toggle word wrap

Producer and disposer methods can also be used as well to customize the Camel context bean, for example:

class CamelContextFactory {

    @Produces
    @ApplicationScoped
    CamelContext customize() {
        DefaultCamelContext context = new DefaultCamelContext();
        context.setName("custom");
        return context;
    }

    void cleanUp(@Disposes CamelContext context) {
        // ...
    }
}

class CamelContextFactory {

    @Produces
    @ApplicationScoped
    CamelContext customize() {
        DefaultCamelContext context = new DefaultCamelContext();
        context.setName("custom");
        return context;
    }

    void cleanUp(@Disposes CamelContext context) {
        // ...
    }
}

Copy to Clipboard

Toggle word wrap

Similarly, producer fields can be used, for example:

@Produces
@ApplicationScoped
CamelContext context = new CustomCamelContext();

class CustomCamelContext extends DefaultCamelContext {

    CustomCamelContext() {
        setName("custom");
    }
}

@Produces
@ApplicationScoped
CamelContext context = new CustomCamelContext();

class CustomCamelContext extends DefaultCamelContext {

    CustomCamelContext() {
        setName("custom");
    }
}

Copy to Clipboard

Toggle word wrap

This pattern can be used for example to avoid having the Camel context routes started automatically when the container initialises by calling the setAutoStartup method, for example:

@ApplicationScoped
class ManualStartupCamelContext extends DefaultCamelContext {

    @PostConstruct
    void manual() {
        setAutoStartup(false);
    }
}

@ApplicationScoped
class ManualStartupCamelContext extends DefaultCamelContext {

    @PostConstruct
    void manual() {
        setAutoStartup(false);
    }
}

Copy to Clipboard

Toggle word wrap

Multiple Camel contexts
复制链接

Any number of CamelContext beans can actually be declared in the application as documented above. In that case, the CDI qualifiers declared on these CamelContext beans are used to bind the Camel routes and other Camel primitives to the corresponding Camel contexts. From example, if the following beans get declared:

@ApplicationScoped
@ContextName("foo")
class FooCamelContext extends DefaultCamelContext {
}

@ApplicationScoped
@BarContextQualifier
class BarCamelContext extends DefaultCamelContext {
}
 
@ContextName("foo")
class RouteAdddedToFooCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}
 
@BarContextQualifier
class RouteAdddedToBarCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}
 
@ContextName("baz")
class RouteAdddedToBazCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}
 
@MyOtherQualifier
class RouteNotAddedToAnyCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}

@ApplicationScoped
@ContextName("foo")
class FooCamelContext extends DefaultCamelContext {
}

@ApplicationScoped
@BarContextQualifier
class BarCamelContext extends DefaultCamelContext {
}
 
@ContextName("foo")
class RouteAdddedToFooCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}
 
@BarContextQualifier
class RouteAdddedToBarCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}
 
@ContextName("baz")
class RouteAdddedToBazCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}
 
@MyOtherQualifier
class RouteNotAddedToAnyCamelContext extends RouteBuilder {
 
	@Override
    public void configure() {
        // ...
    }
}

Copy to Clipboard

Toggle word wrap

The RoutesBuilder beans qualified with @ContextName are automatically added to the corresponding CamelContext beans by Camel CDI. If no such CamelContext bean exists, it gets automatically created, as for the RouteAddedToBazCamelContext bean. Note this only happens for the @ContextName qualifier provided by Camel CDI. Hence the RouteNotAddedToAnyCamelContext bean qualified with the user-defined @MyOtherQualifier qualifier does not get added to any Camel contexts. That may be useful, for example, for Camel routes that may be required to be added later during the application execution.

Since Camel version 2.17.0, Camel CDI is capable of managing any kind of CamelContext beans. In previous versions, it is only capable of managing beans of type CdiCamelContext so it is required to extend it.

The CDI qualifiers declared on the CamelContext beans are also used to bind the corresponding Camel primitives, for example:

@Inject
@ContextName("foo")
@Uri("direct:inbound")
ProducerTemplate producerTemplate;

@Inject
@BarContextQualifier
MockEndpoint outbound; // URI defaults to the member name, i.e. mock:outbound

@Inject
@ContextName("baz")
@Uri("direct:inbound")
Endpoint endpoint;

@Inject
@ContextName("foo")
@Uri("direct:inbound")
ProducerTemplate producerTemplate;

@Inject
@BarContextQualifier
MockEndpoint outbound; // URI defaults to the member name, i.e. mock:outbound

@Inject
@ContextName("baz")
@Uri("direct:inbound")
Endpoint endpoint;

Copy to Clipboard

Toggle word wrap

Configuration properties
复制链接

To configure the sourcing of the configuration properties used by Camel to resolve properties placeholders, you can declare a PropertiesComponent bean qualified with @Named("properties"), for example:

@Produces
@ApplicationScoped
@Named("properties")
PropertiesComponent propertiesComponent() {
    Properties properties = new Properties();
    properties.put("property", "value");
    PropertiesComponent component = new PropertiesComponent();
    component.setInitialProperties(properties);
    component.setLocation("classpath:placeholder.properties");
    return component;
}

@Produces
@ApplicationScoped
@Named("properties")
PropertiesComponent propertiesComponent() {
    Properties properties = new Properties();
    properties.put("property", "value");
    PropertiesComponent component = new PropertiesComponent();
    component.setInitialProperties(properties);
    component.setLocation("classpath:placeholder.properties");
    return component;
}

Copy to Clipboard

Toggle word wrap

If you want to use DeltaSpike configuration mechanism you can declare the following PropertiesComponent bean:

@Produces
@ApplicationScoped
@Named("properties")
PropertiesComponent properties(PropertiesParser parser) {
    PropertiesComponent component = new PropertiesComponent();
    component.setPropertiesParser(parser);
    return component;
}

// PropertiesParser bean that uses DeltaSpike to resolve properties
static class DeltaSpikeParser extends DefaultPropertiesParser {
    @Override
    public String parseProperty(String key, String value, Properties properties) {
        return ConfigResolver.getPropertyValue(key);
    }
}

@Produces
@ApplicationScoped
@Named("properties")
PropertiesComponent properties(PropertiesParser parser) {
    PropertiesComponent component = new PropertiesComponent();
    component.setPropertiesParser(parser);
    return component;
}

// PropertiesParser bean that uses DeltaSpike to resolve properties
static class DeltaSpikeParser extends DefaultPropertiesParser {
    @Override
    public String parseProperty(String key, String value, Properties properties) {
        return ConfigResolver.getPropertyValue(key);
    }
}

Copy to Clipboard

Toggle word wrap

You can see the camel-example-cdi-properties example for a working example of a Camel CDI application using DeltaSpike configuration mechanism.

Auto-configured type converters
复制链接

CDI beans annotated with the @Converter annotation are automatically registered into the deployed Camel contexts, for example:

@Converter
public class MyTypeConverter {

    @Converter
    public Output convert(Input input) {
        //...
    }
}

@Converter
public class MyTypeConverter {

    @Converter
    public Output convert(Input input) {
        //...
    }
}

Copy to Clipboard

Toggle word wrap

Note that CDI injection is supported within the type converters.

Lazy Injection / Programmatic Lookup
复制链接

Available as of Camel 2.17

While the CDI programmatic model favors a type-safe resolution mechanism that occurs at application initialization time, it is possible to perform dynamic / lazy injection later during the application execution using the programmatic lookup mechanism.

Camel CDI provides for convenience the annotation literals corresponding to the CDI qualifiers that you can use for standard injection of Camel primitives. These annotation literals can be used in conjunction with thejavax.enterprise.inject.Instance interface which is the CDI entry point to perform lazy injection / programmatic lookup.

For example, you can use the provided annotation literal for the @Uriqualifier to lazily lookup for Camel primitives, for example for ProducerTemplatebeans:

@Any
@Inject
Instance<ProducerTemplate> producers;
 
ProducerTemplate inbound = producers
    .select(Uri.Literal.of("direct:inbound"))
    .get();

@Any
@Inject
Instance<ProducerTemplate> producers;
 
ProducerTemplate inbound = producers
    .select(Uri.Literal.of("direct:inbound"))
    .get();

Copy to Clipboard

Toggle word wrap

Or for Endpoint beans, for example:

@Any
@Inject
Instance<Endpoint> endpoints;
 
MockEndpoint outbound = endpoints
    .select(MockEndpoint.class, Uri.Literal.of("mock:outbound"))
    .get();

@Any
@Inject
Instance<Endpoint> endpoints;
 
MockEndpoint outbound = endpoints
    .select(MockEndpoint.class, Uri.Literal.of("mock:outbound"))
    .get();

Copy to Clipboard

Toggle word wrap

Similarly, you can use the provided annotation literal for the@ContextName qualifier to lazily lookup for CamelContext beans, for example:

@Any
@Inject
Instance<CamelContext> contexts;
 
CamelContext context = contexts
    .select(ContextName.Literal.of("foo"))
    .get();

@Any
@Inject
Instance<CamelContext> contexts;
 
CamelContext context = contexts
    .select(ContextName.Literal.of("foo"))
    .get();

Copy to Clipboard

Toggle word wrap

You can also refined the selection based on the Camel context type, for example:

@Any
@Inject
Instance<CamelContext> contexts;
 
// Refine the selection by type 
Instance<DefaultCamelContext> context = contexts.select(DefaultCamelContext.class);
 
// Check if such a bean exists then retrieve a reference 
if (!context.isUnsatisfied())
    context.get();

@Any
@Inject
Instance<CamelContext> contexts;
 
// Refine the selection by type 
Instance<DefaultCamelContext> context = contexts.select(DefaultCamelContext.class);
 
// Check if such a bean exists then retrieve a reference 
if (!context.isUnsatisfied())
    context.get();

Copy to Clipboard

Toggle word wrap

Or even iterate over a selection of Camel contexts, for example:

@Any
@Inject
Instance<CamelContext> contexts;
 
for (CamelContext context : contexts)
    context.setUseBreadcrumb(true);

@Any
@Inject
Instance<CamelContext> contexts;
 
for (CamelContext context : contexts)
    context.setUseBreadcrumb(true);

Copy to Clipboard

Toggle word wrap

Injecting a Camel context from Spring XML
复制链接

While CDI favors a type safe dependency injection mechanism, it may be useful to reuse existing Camel XML configurations by injecting them into a Camel CDI application. In other use cases, it might be handy to rely on the Camel XML DSL to configure its Camel context(s).

To inject by CDI a camelContext defined in Spring XML, you need to use the Java @Resource annotation, instead of the @Inject @ContextName annotations in the Camel CDI extension. For example,

...
public class RouteCaller {
    ...
    @Resource(name = "java:jboss/camel/context/simple-context")
    private CamelContext context;
    ...

...
public class RouteCaller {
    ...
    @Resource(name = "java:jboss/camel/context/simple-context")
    private CamelContext context;
    ...

Copy to Clipboard

Toggle word wrap

The string java:jboss/camel/context/simple-context is the name of the deployed context registered in the JNDI registry. simple-context is the xml:id of the camelContext element in the Spring XML file.

Important

Using the @Inject @ContextName annotations can result in the creation of a new camelContext instead of injecting the named context, which later causes endpoint lookups to fail.

此内容没有您所选择的语言版本。

Chapter 15. Camel CDI

15.1. Basic Features
复制链接

Overview
复制链接

How to enable Camel CDI in Apache Karaf
复制链接

Auto-configured Camel context
复制链接

Auto-detecting Camel routes
复制链接

Auto-configured Camel primitives
复制链接

Camel context configuration
复制链接

Multiple Camel contexts
复制链接

Configuration properties
复制链接

Auto-configured type converters
复制链接

Lazy Injection / Programmatic Lookup
复制链接

Injecting a Camel context from Spring XML
复制链接

学习

尝试、购买和销售

社区

关于红帽文档

让开源更具包容性

關於紅帽

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

此内容没有您所选择的语言版本。

Chapter 15. Camel CDI

15.1. Basic Features复制链接链接已复制到粘贴板!

Overview复制链接链接已复制到粘贴板!

How to enable Camel CDI in Apache Karaf复制链接链接已复制到粘贴板!

Auto-configured Camel context复制链接链接已复制到粘贴板!

Auto-detecting Camel routes复制链接链接已复制到粘贴板!

Auto-configured Camel primitives复制链接链接已复制到粘贴板!

Camel context configuration复制链接链接已复制到粘贴板!

Multiple Camel contexts复制链接链接已复制到粘贴板!

Configuration properties复制链接链接已复制到粘贴板!

Auto-configured type converters复制链接链接已复制到粘贴板!

Lazy Injection / Programmatic Lookup复制链接链接已复制到粘贴板!

Injecting a Camel context from Spring XML复制链接链接已复制到粘贴板!

学习

尝试、购买和销售

社区

关于红帽文档

让开源更具包容性

關於紅帽

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

15.1. Basic Features
复制链接

Overview
复制链接

How to enable Camel CDI in Apache Karaf
复制链接

Auto-configured Camel context
复制链接

Auto-detecting Camel routes
复制链接

Auto-configured Camel primitives
复制链接

Camel context configuration
复制链接

Multiple Camel contexts
复制链接

Configuration properties
复制链接

Auto-configured type converters
复制链接

Lazy Injection / Programmatic Lookup
复制链接

Injecting a Camel context from Spring XML
复制链接