Este conteúdo não está disponível no idioma selecionado.

Chapter 1. Getting Started with Camel Spring Boot

This guide introduces Camel Spring Boot and demonstrates how to get started building an application using Camel Spring Boot:

1.1. Camel Spring Boot starters
Copiar o link

Camel support for Spring Boot provides auto-configuration of the Camel and starters for many Camel components. The opinionated auto-configuration of the Camel context auto-detects Camel routes available in the Spring context and registers the key Camel utilities (such as producer template, consumer template and the type converter) as beans.

Note

For information about using a Maven archtype to generate a Camel for Spring Boot application see Generating a Camel for Spring Boot application using Maven.

To get started, you must add the Camel Spring Boot BOM to your Maven pom.xml file.

<dependencyManagement>

    <dependencies>
        <!-- Camel BOM -->
        <dependency>
            <groupId>org.apache.camel.springboot</groupId>
            <artifactId>camel-spring-boot-bom</artifactId>
            <version>3.14.5.redhat-00032</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- ... other BOMs or dependencies ... -->
    </dependencies>

</dependencyManagement>

<dependencyManagement>

    <dependencies>
        <!-- Camel BOM -->
        <dependency>
            <groupId>org.apache.camel.springboot</groupId>
            <artifactId>camel-spring-boot-bom</artifactId>
            <version>3.14.5.redhat-00032</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- ... other BOMs or dependencies ... -->
    </dependencies>

</dependencyManagement>

Copy to Clipboard

Toggle word wrap

The camel-spring-boot-bom is a basic BOM that contains the list of Camel Spring Boot starter JARs.

Next, add the Camel Spring Boot starter to startup the Camel Context.

    <dependencies>
        <!-- Camel Starter -->
        <dependency>
            <groupId>org.apache.camel.springboot</groupId>
            <artifactId>camel-spring-boot-starter</artifactId>
        </dependency>
        <!-- ... other dependencies ... -->
    </dependencies>

    <dependencies>
        <!-- Camel Starter -->
        <dependency>
            <groupId>org.apache.camel.springboot</groupId>
            <artifactId>camel-spring-boot-starter</artifactId>
        </dependency>
        <!-- ... other dependencies ... -->
    </dependencies>

Copy to Clipboard

Toggle word wrap

You must also add any component starters that your Spring Boot application requires. The following example shows how to add the auto-configuration starter to the ActiveMQ component

    <dependencies>
        <!-- ... other dependencies ... -->
        <dependency>
            <groupId>org.apache.camel.springboot</groupId>
            <artifactId>camel-activemq-starter</artifactId>
        </dependency>
    </dependencies>

    <dependencies>
        <!-- ... other dependencies ... -->
        <dependency>
            <groupId>org.apache.camel.springboot</groupId>
            <artifactId>camel-activemq-starter</artifactId>
        </dependency>
    </dependencies>

Copy to Clipboard

Toggle word wrap

1.1.1. Camel Spring Boot BOM vs Camel Spring Boot Dependencies BOM
Copiar o link

The curated camel-spring-boot-dependencies BOM, which is generated, contains the adjusted JARs that both Spring Boot and Apache Camel use to avoid any conflicts. This BOM is used to test camel-spring-boot itself.

Spring Boot users may choose to use pure Camel dependencies by using the camel-spring-boot-bom that only has the Camel starter JARs as managed dependencies. However, this may lead to a classpath conflict if a third-party JAR from Spring Boot is not compatible with a particular Camel component.

1.1.2. Spring Boot configuration support
Copiar o link

Each starter lists configuration parameters you can configure in the standard application.properties or application.yml files. These parameters have the form of camel.component.[component-name].[parameter]. For example to configure the URL of the ActiveMQ broker you can set:

camel.component.activemq.broker-url=tcp://localhost:61616

camel.component.activemq.broker-url=tcp://localhost:61616

Copy to Clipboard

Toggle word wrap

1.1.3. Adding Camel routes
Copiar o link

Camel routes are detected in the Spring application context, for example a route annotated with org.springframework.stereotype.Component will be loaded, added to the Camel context and run.

import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;

@Component
public class MyRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("...")
            .to("...");
    }

}

import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;

@Component
public class MyRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("...")
            .to("...");
    }

}

Copy to Clipboard

Toggle word wrap

1.2. Spring Boot
Copiar o link

Spring Boot automatically configures Camel for you. The opinionated auto-configuration of the Camel context auto-detects Camel routes available in the Spring context and registers the key Camel utilities (like producer template, consumer template and the type converter) as beans.

Maven users will need to add the following dependency to their pom.xml in order to use this component:

<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-spring-boot</artifactId>
    <version>3.14.5.redhat-00032</version> <!-- use the same version as your Camel core version -->
</dependency>

<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-spring-boot</artifactId>
    <version>3.14.5.redhat-00032</version> <!-- use the same version as your Camel core version -->
</dependency>

Copy to Clipboard

Toggle word wrap

camel-spring-boot jar comes with the spring.factories file, so as soon as you add that dependency into your classpath, Spring Boot will automatically auto-configure Camel for you.

1.2.1. Camel Spring Boot Starter
Copiar o link

Apache Camel ships a Spring Boot Starter module that allows you to develop Spring Boot applications using starters. There is a sample application in the source code also.

To use the starter, add the following to your spring boot pom.xml file:

<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-spring-boot-bom</artifactId>
    <version>3.14.5.redhat-00032</version> <!-- use the same version as your Camel core version -->
</dependency>

<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-spring-boot-bom</artifactId>
    <version>3.14.5.redhat-00032</version> <!-- use the same version as your Camel core version -->
</dependency>

Copy to Clipboard

Toggle word wrap

Then you can just add classes with your Camel routes such as:

package com.example;

import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;

@Component
public class MyRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("timer:foo").to("log:bar");
    }
}

package com.example;

import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;

@Component
public class MyRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("timer:foo").to("log:bar");
    }
}

Copy to Clipboard

Toggle word wrap

Then these routes will be started automatically.

You can customize the Camel application in the application.properties or application.yml file.

1.2.2. Spring Boot Auto-configuration
Copiar o link

When using spring-boot with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-spring-boot-starter</artifactId>
  <version>3.14.5.redhat-00032</version> <!-- use the same version as your Camel core version -->
</dependency>

<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-spring-boot-starter</artifactId>
  <version>3.14.5.redhat-00032</version> <!-- use the same version as your Camel core version -->
</dependency>

Copy to Clipboard

Toggle word wrap

1.2.3. Auto-configured Camel context
Copiar o link

The most important piece of functionality provided by the Camel auto-configuration is the CamelContext instance. Camel auto-configuration creates a SpringCamelContext for you and takes care of the proper initialization and shutdown of that context. The created Camel context is also registered in the Spring application context (under the camelContext bean name), so you can access it like any other Spring bean.

@Configuration
public class MyAppConfig {

  @Autowired
  CamelContext camelContext;

  @Bean
  MyService myService() {
    return new DefaultMyService(camelContext);
  }

}

@Configuration
public class MyAppConfig {

  @Autowired
  CamelContext camelContext;

  @Bean
  MyService myService() {
    return new DefaultMyService(camelContext);
  }

}

Copy to Clipboard

Toggle word wrap

1.2.4. Auto-detecting Camel routes
Copiar o link

Camel auto-configuration collects all the RouteBuilder instances from the Spring context and automatically injects them into the provided CamelContext. This means that creating new Camel routes with the Spring Boot starter is as simple as adding the @Component annotated class to your classpath:

@Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("jms:invoices").to("file:/invoices");
  }

}

@Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("jms:invoices").to("file:/invoices");
  }

}

Copy to Clipboard

Toggle word wrap

Or creating a new route RouteBuilder bean in your @Configuration class:

@Configuration
public class MyRouterConfiguration {

  @Bean
  RoutesBuilder myRouter() {
    return new RouteBuilder() {

      @Override
      public void configure() throws Exception {
        from("jms:invoices").to("file:/invoices");
      }

    };
  }

}

@Configuration
public class MyRouterConfiguration {

  @Bean
  RoutesBuilder myRouter() {
    return new RouteBuilder() {

      @Override
      public void configure() throws Exception {
        from("jms:invoices").to("file:/invoices");
      }

    };
  }

}

Copy to Clipboard

Toggle word wrap

1.2.5. Camel properties
Copiar o link

Spring Boot auto-configuration automatically connects to Spring Boot external configuration (which may contain properties placeholders, OS environment variables or system properties) with the Camel properties support. It basically means that any property defined in application.properties file:

route.from = jms:invoices

route.from = jms:invoices

Copy to Clipboard

Toggle word wrap

Or set via system property:

java -Droute.to=jms:processed.invoices -jar mySpringApp.jar

java -Droute.to=jms:processed.invoices -jar mySpringApp.jar

Copy to Clipboard

Toggle word wrap

can be used as placeholders in Camel route:

@Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("{{route.from}}").to("{{route.to}}");
  }

}

@Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("{{route.from}}").to("{{route.to}}");
  }

}

Copy to Clipboard

Toggle word wrap

1.2.6. Custom Camel context configuration
Copiar o link

If you want to perform some operations on CamelContext bean created by Camel auto-configuration, register CamelContextConfiguration instance in your Spring context:

@Configuration
public class MyAppConfig {

  @Bean
  CamelContextConfiguration contextConfiguration() {
    return new CamelContextConfiguration() {
      @Override
      void beforeApplicationStart(CamelContext context) {
        // your custom configuration goes here
      }
    };
  }

}

@Configuration
public class MyAppConfig {

  @Bean
  CamelContextConfiguration contextConfiguration() {
    return new CamelContextConfiguration() {
      @Override
      void beforeApplicationStart(CamelContext context) {
        // your custom configuration goes here
      }
    };
  }

}

Copy to Clipboard

Toggle word wrap

The method beforeApplicationStart will be called just before the Spring context is started, so the CamelContext instance passed to this callback is fully auto-configured. If you add multiple instances of CamelContextConfiguration into your Spring context, each instance is executed.

1.2.7. Auto-configured consumer and producer templates
Copiar o link

Camel auto-configuration provides pre-configured ConsumerTemplate and ProducerTemplate instances. You can simply inject them into your Spring-managed beans:

@Component
public class InvoiceProcessor {

  @Autowired
  private ProducerTemplate producerTemplate;

  @Autowired
  private ConsumerTemplate consumerTemplate;

  public void processNextInvoice() {
    Invoice invoice = consumerTemplate.receiveBody("jms:invoices", Invoice.class);
    ...
    producerTemplate.sendBody("netty-http:http://invoicing.com/received/" + invoice.id());
  }

}

@Component
public class InvoiceProcessor {

  @Autowired
  private ProducerTemplate producerTemplate;

  @Autowired
  private ConsumerTemplate consumerTemplate;

  public void processNextInvoice() {
    Invoice invoice = consumerTemplate.receiveBody("jms:invoices", Invoice.class);
    ...
    producerTemplate.sendBody("netty-http:http://invoicing.com/received/" + invoice.id());
  }

}

Copy to Clipboard

Toggle word wrap

By default, consumer templates and producer templates come with the endpoint cache sizes set to 1000. You can change these values by modifying the following Spring properties:

camel.springboot.consumer-template-cache-size = 100
camel.springboot.producer-template-cache-size = 200

camel.springboot.consumer-template-cache-size = 100
camel.springboot.producer-template-cache-size = 200

Copy to Clipboard

Toggle word wrap

1.2.8. Auto-configured TypeConverter
Copiar o link

Camel auto-configuration registers a TypeConverter instance named typeConverter in the Spring context.

@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public long parseInvoiceValue(Invoice invoice) {
    String invoiceValue = invoice.grossValue();
    return typeConverter.convertTo(Long.class, invoiceValue);
  }

}

@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public long parseInvoiceValue(Invoice invoice) {
    String invoiceValue = invoice.grossValue();
    return typeConverter.convertTo(Long.class, invoiceValue);
  }

}

Copy to Clipboard

Toggle word wrap

1.2.8.1. Spring type conversion API bridge
Copiar o link

Spring comes with the powerful type conversion API. The Spring API is similar to the Camel type converter API. As both APIs are so similar, Camel Spring Boot automatically registers a bridge converter (SpringTypeConverter) that delegates to the Spring conversion API. This means that out-of-the-box Camel will treat Spring Converters like Camel ones. With this approach you can use both Camel and Spring converters accessed via Camel TypeConverter API:

@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public UUID parseInvoiceId(Invoice invoice) {
    // Using Spring's StringToUUIDConverter
    UUID id = invoice.typeConverter.convertTo(UUID.class, invoice.getId());
  }

}

@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public UUID parseInvoiceId(Invoice invoice) {
    // Using Spring's StringToUUIDConverter
    UUID id = invoice.typeConverter.convertTo(UUID.class, invoice.getId());
  }

}

Copy to Clipboard

Toggle word wrap

Under the hood Camel Spring Boot delegates conversion to the Spring’s ConversionService instances available in the application context. If no ConversionService instance is available, Camel Spring Boot auto-configuration will create one for you.

1.2.9. Keeping the application alive
Copiar o link

Camel applications which have this feature enabled launch a new thread on startup for the sole purpose of keeping the application alive by preventing JVM termination. This means that after you start a Camel application with Spring Boot, your application waits for a Ctrl+C signal and does not exit immediately.

The controller thread can be activated using the camel.springboot.main-run-controller to true.

camel.springboot.main-run-controller = true

camel.springboot.main-run-controller = true

Copy to Clipboard

Toggle word wrap

Applications using web modules (for example, applications that import the org.springframework.boot:spring-boot-web-starter module), usually don’t need to use this feature because the application is kept alive by the presence of other non-daemon threads.

1.2.10. Adding XML routes
Copiar o link

By default, you can put Camel XML routes in the classpath under the directory camel, which camel-spring-boot will auto-detect and include. You can configure the directory name or turn this off using the configuration option:

turn off

# turn off
camel.springboot.routes-include-pattern = false

Copy to Clipboard

Toggle word wrap

scan only in the com/foo/routes classpath

# scan only in the com/foo/routes classpath
camel.springboot.routes-include-pattern = classpath:com/foo/routes/*.xml

Copy to Clipboard

Toggle word wrap

The XML files should be Camel XML routes (not <CamelContext>) such as:

<routes xmlns="http://camel.apache.org/schema/spring">
    <route id="test">
        <from uri="timer://trigger"/>
        <transform>
            <simple>ref:myBean</simple>
        </transform>
        <to uri="log:out"/>
    </route>
</routes>

<routes xmlns="http://camel.apache.org/schema/spring">
    <route id="test">
        <from uri="timer://trigger"/>
        <transform>
            <simple>ref:myBean</simple>
        </transform>
        <to uri="log:out"/>
    </route>
</routes>

Copy to Clipboard

Toggle word wrap

1.2.11. Testing the JUnit 5 way
Copiar o link

For testing, Maven users will need to add the following dependencies to their pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.7.4</version> <!-- Use the same version as your Spring Boot version -->
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-test-spring-junit5</artifactId>
    <version>3.14.5.redhat-00018</version> <!-- use the same version as your Camel core version -->
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.7.4</version> <!-- Use the same version as your Spring Boot version -->
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-test-spring-junit5</artifactId>
    <version>3.14.5.redhat-00018</version> <!-- use the same version as your Camel core version -->
    <scope>test</scope>
</dependency>

Copy to Clipboard

Toggle word wrap

To test a Camel Spring Boot application, annotate your test class(es) with @CamelSpringBootTest. This brings Camel’s Spring Test support to your application, so that you can write tests using Spring Boot test conventions.

To get the CamelContext or ProducerTemplate, you can inject them into the class in the normal Spring manner, using @Autowired.

You can also use camel-test-spring-junit5 to configure tests declaratively. This example uses the @MockEndpoints annotation to auto-mock an endpoint:

@CamelSpringBootTest
@SpringBootApplication
@MockEndpoints("direct:end")
public class MyApplicationTest {

    @Autowired
    private ProducerTemplate template;

    @EndpointInject("mock:direct:end")
    private MockEndpoint mock;

    @Test
    public void testReceive() throws Exception {
        mock.expectedBodiesReceived("Hello");
        template.sendBody("direct:start", "Hello");
        mock.assertIsSatisfied();
    }

}

@CamelSpringBootTest
@SpringBootApplication
@MockEndpoints("direct:end")
public class MyApplicationTest {

    @Autowired
    private ProducerTemplate template;

    @EndpointInject("mock:direct:end")
    private MockEndpoint mock;

    @Test
    public void testReceive() throws Exception {
        mock.expectedBodiesReceived("Hello");
        template.sendBody("direct:start", "Hello");
        mock.assertIsSatisfied();
    }

}

Copy to Clipboard

Toggle word wrap

1.3. Component Starters
Copiar o link

Camel Spring Boot supports the following Camel artifacts as Spring Boot Starters:

Note

Reference documentation is not yet available for some of the artifacts listed below. This documentation will be released as soon as it is available.

Expand

Table 1.1. Camel Components
Component	Artifact	Description
AWS Cloudwatch	camel-aws2-cw-starter	Sending metrics to AWS CloudWatch using AWS SDK version 2.x.
AWS DynamoDB	camel-aws2-ddb-starter	Store and retrieve data from AWS DynamoDB service using AWS SDK version 2.x.
AWS Kinesis	camel-aws2-kinesis-starter	Consume and produce records from and to AWS Kinesis Streams using AWS SDK version 2.x.
AWS Lambda	camel-aws2-lambda-starter	Manage and invoke AWS Lambda functions using AWS SDK version 2.x.
AWS S3 Storage Service	camel-aws2-s3-starter	Store and retrieve objects from AWS S3 Storage Service using AWS SDK version 2.x.
AWS Simple Notification System (SNS)	camel-aws2-sns-starter	Send messages to an AWS Simple Notification Topic using AWS SDK version 2.x.
AWS Simple Queue Service (SQS)	camel-aws2-sqs-starter	Send and receive messages to/from AWS SQS service using AWS SDK version 2.x.
Azure Storage Blob Service	camel-azure-storage-blob-starter	Store and retrieve blobs from Azure Storage Blob Service using SDK v12.
Azure Storage Queue Service	camel-azure-storage-queue-starter	The azure-storage-queue component is used for storing and retrieving the messages to/from Azure Storage Queue using Azure SDK v12.
Bean	camel-bean-starter	Invoke methods of Java beans stored in Camel registry.
Bean Validator	camel-bean-validator-starter	Validate the message body using the Java Bean Validation API.
Browse	camel-browse-starter	Inspect the messages received on endpoints supporting BrowsableEndpoint.
Cassandra CQL	camel-cassandraql-starter	Integrate with Cassandra 2.0 using the CQL3 API (not the Thrift API). Based on Cassandra Java Driver provided by DataStax.
Control Bus	camel-controlbus-starter	Manage and monitor Camel routes.
Cron	camel-cron-starter	A generic interface for triggering events at times specified through the Unix cron syntax.
CXF	camel-cxf-soap-starter	Expose SOAP WebServices using Apache CXF or connect to external WebServices using CXF WS client.
Data Format	camel-dataformat-starter	Use a Camel Data Format as a regular Camel Component.
Dataset	camel-dataset-starter	Provide data for load and soak testing of your Camel application.
Direct	camel-direct-starter	Call another endpoint from the same Camel Context synchronously.
FHIR	camel-fhir-starter	Exchange information in the healthcare domain using the FHIR (Fast Healthcare Interoperability Resources) standard.
File	camel-file-starter	Read and write files.
FTP	camel-ftp-starter	Upload and download files to/from FTP servers.
HTTP	camel-http-starter	Send requests to external HTTP servers using Apache HTTP Client 4.x.
Infinispan	camel-infinispan-starter	Read and write from/to Infinispan distributed key/value store and data grid.
Jira	camel-jira-starter	Interact with JIRA issue tracker.
JMS	camel-jms-starter	Sent and receive messages to/from a JMS Queue or Topic.
Kafka	camel-kafka-starter	Sent and receive messages to/from an Apache Kafka broker.
Kamelet	camel-kamelet-starter	To call Kamelets
Language	camel-language-starter	Execute scripts in any of the languages supported by Camel.
Log	camel-log-starter	Log messages to the underlying logging mechanism.
Mail	camel-mail-starter	Send and receive emails using imap, pop3 and smtp protocols.
Master	camel-master-starter	Have only a single consumer in a cluster consuming from a given endpoint; with automatic failover if the JVM dies.
MLLP	camel-mllp-starter	Communicate with external systems using the MLLP protocol.
Mock	camel-mock-starter	Test routes and mediation rules using mocks.
MongoDB	camel-mongodb-starter	Perform operations on MongoDB documents and collections.
Netty	camel-netty-starter	Socket level networking using TCP or UDP with Netty 4.x.
Paho	camel-paho-starter	Communicate with MQTT message brokers using Eclipse Paho MQTT Client.
Paho MQTT 5	camel-paho-mqtt5-starter	Communicate with MQTT message brokers using Eclipse Paho MQTT v5 Client.
Quartz	camel-quartz-starter	Schedule sending of messages using the Quartz 2.x scheduler.
Ref	camel-ref-starter	Route messages to an endpoint looked up dynamically by name in the Camel Registry.
REST	camel-rest-starter	Expose REST services or call external REST services.
Salesforce	camel-salesforce-starter	Communicate with Salesforce using Java DTOs.
Scheduler	camel-scheduler-starter	Generate messages in specified intervals using java.util.concurrent.ScheduledExecutorService.
SEDA	camel-seda-starter	Asynchronously call another endpoint from any Camel Context in the same JVM.
Servlet	camel-servlet-starter	Serve HTTP requests by a Servlet.
Slack	camel-slack-starter	Send and receive messages to/from Slack.
SQL	camel-sql-starter	Perform SQL queries using Spring JDBC.
Stub	camel-stub-starter	Stub out any physical endpoints while in development or testing.
Telegram	camel-telegram-starter	Send and receive messages acting as a Telegram Bot Telegram Bot API.
Timer	camel-timer-starter	Generate messages in specified intervals using java.util.Timer.
Validator	camel-validator-starter	Validate the payload using XML Schema and JAXP Validation.
Webhook	camel-webhook-starter	Expose webhook endpoints to receive push notifications for other Camel components.
XSLT	camel-xslt-starter	Transforms XML payload using an XSLT template.

Expand

Table 1.2. Camel Data Formats
Component	Artifact	Description
Avro	camel-avro-starter	Serialize and deserialize messages using Apache Avro binary data format.
Avro Jackson	camel-jackson-avro-starter	Marshal POJOs to Avro and back using Jackson.
Bindy	camel-bindy-starter	Marshal and unmarshal between POJOs and key-value pair (KVP) format using Camel Bindy
HL7	camel-hl7-starter	Marshal and unmarshal HL7 (Health Care) model objects using the HL7 MLLP codec.
JacksonXML	camel-jacksonxml-starter	Unmarshal a XML payloads to POJOs and back using XMLMapper extension of Jackson.
JAXB	camel-jaxb-starter	Unmarshal XML payloads to POJOs and back using JAXB2 XML marshalling standard.
JSON Gson	camel-gson-starter	Marshal POJOs to JSON and back using Gson
JSON Jackson	camel-jackson-starter	Marshal POJOs to JSON and back using Jackson
Protobuf Jackson	camel-jackson-protobuf-starter	Marshal POJOs to Protobuf and back using Jackson.
SOAP	camel-soap-starter	Marshal Java objects to SOAP messages and back.
Zip File	camel-zipfile-starter	Compression and decompress streams using java.util.zip.ZipStream.

Expand

Table 1.3. Camel Languages
Language	Artifact	Description
Constant	camel-core-starter	A fixed value set only once during the route startup.
CSimple	camel-core-starter	Evaluate a compiled simple expression.
ExchangeProperty	camel-core-starter	Gets a property from the Exchange.
File	camel-core-starter	File related capabilities for the Simple language.
Header	camel-core-starter	Gets a header from the Exchange.
JSONPath	camel-jsonpath-starter	Evaluates a JSONPath expression against a JSON message body.
Ref	camel-core-starter	Uses an existing expression from the registry.
Simple	camel-core-starter	Evaluates a Camel simple expression.
Tokenize	camel-core-starter	Tokenize text payloads using delimiter patterns.
XML Tokenize	camel-xml-jaxp-starter	Tokenize XML payloads.
XPath	camel-xpath-starter	Evaluates an XPath expression against an XML payload.
XQuery	camel-saxon-starter	Query and/or transform XML payloads using XQuery and Saxon.

Expand

Table 1.4. Miscellaneous Extensions
Extensions	Artifact	Description
Openapi Java	camel-openapi-java-starter	Rest-dsl support for using openapi doc

1.4. Starter Configuration
Copiar o link

Clear and accessible configuration is a crucial part of any application. Camel starters fully support Spring Boot’s external configuration mechanism. You can also configure them through Spring Beans for more complex use cases.

1.4.1. Using External Configuration
Copiar o link

Internally, every starter is configured through Spring Boot’s ConfigurationProperties. Each configuration parameter can be set in various ways (application.[properties|json|yaml] files, command line arguments, environments variables etc.). Parameters have the form of camel.[component|language|dataformat].[name].[parameter]

For example to configure the URL of the ActiveMQ broker you can set:

camel.component.activemq.broker-url=tcp://localhost:61616

camel.component.activemq.broker-url=tcp://localhost:61616

Copy to Clipboard

Toggle word wrap

Or to configure the delimeter of the CSV dataformat to be a semicolon(;) you can set:

camel.dataformat.csv.delimiter=;

camel.dataformat.csv.delimiter=;

Copy to Clipboard

Toggle word wrap

Camel will use the Type Converter mechanism when setting properties to the desired type.

You can refer to beans in the Registry using the #bean:name:

camel.component.jms.transactionManager=#bean:myjtaTransactionManager

camel.component.jms.transactionManager=#bean:myjtaTransactionManager

Copy to Clipboard

Toggle word wrap

The Bean would be typically created in Java:

@Bean("myjtaTransactionManager")
public JmsTransactionManager myjtaTransactionManager(PooledConnectionFactory pool) {
    JmsTransactionManager manager = new JmsTransactionManager(pool);
    manager.setDefaultTimeout(45);
    return manager;
}

@Bean("myjtaTransactionManager")
public JmsTransactionManager myjtaTransactionManager(PooledConnectionFactory pool) {
    JmsTransactionManager manager = new JmsTransactionManager(pool);
    manager.setDefaultTimeout(45);
    return manager;
}

Copy to Clipboard

Toggle word wrap

Beans can also be created in configuration files but this is not recommended for complex use cases.

1.4.2. Using Beans
Copiar o link

Starters can also be created and configured via Spring Beans. Before creating a starter , Camel will first lookup it up in the Registry by it’s name if it already exists. For example to configure a Kafka component:

@Bean("kafka")
public KafkaComponent kafka(KafkaConfiguration kafkaconfiguration){
    return ComponentsBuilderFactory.kafka()
                        .brokers("{{kafka.host}}:{{kafka.port}}")
                        .build();
}

@Bean("kafka")
public KafkaComponent kafka(KafkaConfiguration kafkaconfiguration){
    return ComponentsBuilderFactory.kafka()
                        .brokers("{{kafka.host}}:{{kafka.port}}")
                        .build();
}

Copy to Clipboard

Toggle word wrap

The Bean name has to be equal to that of the Component, Dataformat or Language that you are configuring. If the Bean name isn’t specified in the annotation it will be set to the method name.

Typical Camel Spring Boot projects will use a combination of external configuration and Beans to configure an application. For more examples on how to configure your Camel Spring Boot project, please see the example repository.

1.5. Generating a Camel for Spring Boot application using Maven
Copiar o link

You can generate a Camel Spring Boot application using the Maven archetype org.apache.camel.archetypes:camel-archetype-spring-boot:3.14.5.redhat-00032.

Procedure

Run the following command:

mvn archetype:generate \
 -DarchetypeGroupId=org.apache.camel.archetypes \
 -DarchetypeArtifactId=camel-archetype-spring-boot \
 -DarchetypeVersion=3.14.5.redhat-00032 \
 -DgroupId=com.redhat \
 -DartifactId=csb-app \
 -Dversion=1.0-SNAPSHOT \
 -DinteractiveMode=false

mvn archetype:generate \
 -DarchetypeGroupId=org.apache.camel.archetypes \
 -DarchetypeArtifactId=camel-archetype-spring-boot \
 -DarchetypeVersion=3.14.5.redhat-00032 \
 -DgroupId=com.redhat \
 -DartifactId=csb-app \
 -Dversion=1.0-SNAPSHOT \
 -DinteractiveMode=false

Copy to Clipboard

Toggle word wrap

Build the application:
```
mvn package -f csb-app/pom.xml
```
```
mvn package -f csb-app/pom.xml
```
Copy to Clipboard Toggle word wrap

Run the application:

java -jar csb-app/target/csb-app-1.0-SNAPSHOT.jar

java -jar csb-app/target/csb-app-1.0-SNAPSHOT.jar

Copy to Clipboard

Toggle word wrap

Verify that the application is running by examining the console log for the Hello World output which is generated by the application.

com.redhat.MySpringBootApplication       : Started MySpringBootApplication in 3.514 seconds (JVM running for 4.006)
Hello World
Hello World

com.redhat.MySpringBootApplication       : Started MySpringBootApplication in 3.514 seconds (JVM running for 4.006)
Hello World
Hello World

Copy to Clipboard

Toggle word wrap

Este conteúdo não está disponível no idioma selecionado.

Chapter 1. Getting Started with Camel Spring Boot

1.1. Camel Spring Boot starters
Copiar o link

1.1.1. Camel Spring Boot BOM vs Camel Spring Boot Dependencies BOM
Copiar o link

1.1.2. Spring Boot configuration support
Copiar o link

1.1.3. Adding Camel routes
Copiar o link

1.2. Spring Boot
Copiar o link

1.2.1. Camel Spring Boot Starter
Copiar o link

1.2.2. Spring Boot Auto-configuration
Copiar o link

1.2.3. Auto-configured Camel context
Copiar o link

1.2.4. Auto-detecting Camel routes
Copiar o link

1.2.5. Camel properties
Copiar o link

1.2.6. Custom Camel context configuration
Copiar o link

1.2.7. Auto-configured consumer and producer templates
Copiar o link

1.2.8. Auto-configured TypeConverter
Copiar o link

1.2.8.1. Spring type conversion API bridge
Copiar o link

1.2.9. Keeping the application alive
Copiar o link

1.2.10. Adding XML routes
Copiar o link

1.2.11. Testing the JUnit 5 way
Copiar o link

1.3. Component Starters
Copiar o link

1.4. Starter Configuration
Copiar o link

1.4.1. Using External Configuration
Copiar o link

1.4.2. Using Beans
Copiar o link

1.5. Generating a Camel for Spring Boot application using Maven
Copiar o link

Aprender

Experimente, compre e venda

Comunidades

Sobre a documentação da Red Hat

Tornando o open source mais inclusivo

Sobre a Red Hat

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

Este conteúdo não está disponível no idioma selecionado.

Chapter 1. Getting Started with Camel Spring Boot

1.1. Camel Spring Boot startersCopiar o linkLink copiado para a área de transferência!

1.1.1. Camel Spring Boot BOM vs Camel Spring Boot Dependencies BOMCopiar o linkLink copiado para a área de transferência!

1.1.2. Spring Boot configuration supportCopiar o linkLink copiado para a área de transferência!

1.1.3. Adding Camel routesCopiar o linkLink copiado para a área de transferência!

1.2. Spring BootCopiar o linkLink copiado para a área de transferência!

1.2.1. Camel Spring Boot StarterCopiar o linkLink copiado para a área de transferência!

1.2.2. Spring Boot Auto-configurationCopiar o linkLink copiado para a área de transferência!

1.2.3. Auto-configured Camel contextCopiar o linkLink copiado para a área de transferência!

1.2.4. Auto-detecting Camel routesCopiar o linkLink copiado para a área de transferência!

1.2.5. Camel propertiesCopiar o linkLink copiado para a área de transferência!

1.2.6. Custom Camel context configurationCopiar o linkLink copiado para a área de transferência!

1.2.7. Auto-configured consumer and producer templatesCopiar o linkLink copiado para a área de transferência!

1.2.8. Auto-configured TypeConverterCopiar o linkLink copiado para a área de transferência!

1.2.8.1. Spring type conversion API bridgeCopiar o linkLink copiado para a área de transferência!

1.2.9. Keeping the application aliveCopiar o linkLink copiado para a área de transferência!

1.2.10. Adding XML routesCopiar o linkLink copiado para a área de transferência!

1.2.11. Testing the JUnit 5 wayCopiar o linkLink copiado para a área de transferência!

1.3. Component StartersCopiar o linkLink copiado para a área de transferência!

1.4. Starter ConfigurationCopiar o linkLink copiado para a área de transferência!

1.4.1. Using External ConfigurationCopiar o linkLink copiado para a área de transferência!

1.4.2. Using BeansCopiar o linkLink copiado para a área de transferência!

1.5. Generating a Camel for Spring Boot application using MavenCopiar o linkLink copiado para a área de transferência!

Aprender

Experimente, compre e venda

Comunidades

Sobre a documentação da Red Hat

Tornando o open source mais inclusivo

Sobre a Red Hat

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

1.1. Camel Spring Boot starters
Copiar o link

1.1.1. Camel Spring Boot BOM vs Camel Spring Boot Dependencies BOM
Copiar o link

1.1.2. Spring Boot configuration support
Copiar o link

1.1.3. Adding Camel routes
Copiar o link

1.2. Spring Boot
Copiar o link

1.2.1. Camel Spring Boot Starter
Copiar o link

1.2.2. Spring Boot Auto-configuration
Copiar o link

1.2.3. Auto-configured Camel context
Copiar o link

1.2.4. Auto-detecting Camel routes
Copiar o link

1.2.5. Camel properties
Copiar o link

1.2.6. Custom Camel context configuration
Copiar o link

1.2.7. Auto-configured consumer and producer templates
Copiar o link

1.2.8. Auto-configured TypeConverter
Copiar o link

1.2.8.1. Spring type conversion API bridge
Copiar o link

1.2.9. Keeping the application alive
Copiar o link

1.2.10. Adding XML routes
Copiar o link

1.2.11. Testing the JUnit 5 way
Copiar o link

1.3. Component Starters
Copiar o link

1.4. Starter Configuration
Copiar o link

1.4.1. Using External Configuration
Copiar o link

1.4.2. Using Beans
Copiar o link

1.5. Generating a Camel for Spring Boot application using Maven
Copiar o link