Page History

...

    private void sendToCamelLog(String name) {
        try {
            // get the log component
            Component component = camel.getComponent("log");

            // create an endpoint and configure it.
            // Notice the URI parameters this is a common pratice in Camel to configure
            // endpoints based on URI.
            // com.mycompany.part2 = the log category used. Will log at INFO level as default
            Endpoint endpoint = component.createEndpoint("log:com.mycompany.part2");

            // create an Exchange that we want to send to the endpoint
            Exchange exchange = endpoint.createExchange();
            // set the in message payload (=body) with the name parameter
            exchange.getIn().setBody(name);

            // now we want to send the exchange to this endpoint and we then need a producer
            // for this, so we create and start the producer.
            Producer producer = endpoint.createProducer();
            producer.start();
            // process the exchange will send the exchange to the log component, that will process
            // the exchange and yes log the payload
            producer.process(exchange);

            // stop the producer, we want to be nice and cleanup
            producer.stop();
        } catch (Exception e) {
            // we ignore any exceptions and just rethrow as runtime
            throw new RuntimeException(e);





        }
    }

Okay there are code comments in the code block above that should explain what is happening. We run the code by invoking our unit test with maven mvn test, and we should get this log line:

...

Later will we see how we can reduce this to ... in fact 0 java code lines. But the 3 lines will do for now.

Message Translation

TODO: Write about simple java stringbuilder with processor to create the email body

Message Translation

...

Okay lets head back to the over goal of the integration. Looking at the EIP diagrams at the introduction page we need to be able to translate the incoming webservice to an email. Doing so we need to create the email body, and for that we will use a template language such as Apache Velocity. As Camel have a component for Velocity integration we will use this component. Looking at the Component List overview we can see that camel-velocity component uses the artifactId camel-velocity so therefore we need to add this to the pom.xml. When doing the message translation we could put up our sleeves and do it manually in pure java with a StringBuilder such as:

Code Block
java java
private String createMailBody(InputReportIncident parameters) {
Code Block
xml	xml	<dependency> StringBuilder sb = new StringBuilder(); <groupId>org.apache.camel</groupId>sb.append("Incident ").append(parameters.getIncidentId()); sb.append(" has been reported on <artifactId>camel-velocity</artifactId>the ").append(parameters.getIncidentDate()); sb.append(" by ").append(parameters.getGivenName()); <version>${camel-version}</version> sb.append(" ").append(parameters.getFamilyName()); </dependency>

And now we have a Spring conflict as Apache CXF is dependent on Spring 2.0.8 and camel-velocity is dependent on Spring 2.5.5. To remedy this we could wrestle with the pom.xml with excludes settings in the dependencies or just bring in another dependency camel-spring:

Code Block
xml	xml	<dependency>// and the rest of the mail body with more appends to the string builder <groupId>org.apache.camel</groupId> <artifactId>camel-spring</artifactId> return sb.toString(); <version>${camel-version}</version> </dependency>

In fact camel-spring is such a vitual part of Camel that you will end up using it in nearly all situations - we will look into how well Camel is seamless integration with Spring in part 3. For now its just another dependency.

We create the mail body with the Velocity template and create the file src/main/resources/MailBody.vm. The content in the MailBody.vm file is:

But as always it is a hardcoded template for the mail body and the code gets kinda ugly if the mail message has to be a bit more advanced. But of course it just works out-of-the-box with just classes already in the JDK.

Lets use a template language instead such as Apache Velocity. As Camel have a component for Velocity integration we will use this component. Looking at the Component List overview we can see that camel-velocity component uses the artifactId camel-velocity so therefore we need to add this to the pom.xml

Code Block
xml xml
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-velocity</artifactId> <version>${camel-version}</version> </dependency>

And now we have a Spring conflict as Apache CXF is dependent on Spring 2.0.8 and camel-velocity is dependent on Spring 2.5.5. To remedy this we could wrestle with the pom.xml with excludes settings in the dependencies or just bring in another dependency camel-spring:

Code Block
xml xml
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-spring</artifactId> <version>${camel-version}</version> </dependency>

In fact camel-spring is such a vital part of Camel that you will end up using it in nearly all situations - we will look into how well Camel is seamless integration with Spring in part 3. For now its just another dependency.

We create the mail body with the Velocity template and create the file src/main/resources/MailBody.vm. The content in the MailBody.vm file is:

Code Block
Incident $body.incidentId has been reported on the $body.incidentDate by $body.givenName $body.familyName. The person can be contact by: - email: $body.email - phone: $body.phone Summary: $body.summary Details: $body.details This is an auto generated email. You can not reply.

Letting Camel creating the mail body and storing it as a file is as easy as the following 3 code lines:

Code Block
java java
private void generateEmailBodyAndStoreAsFile(InputReportIncident parameters) { // generate the mail body using velocity template // notice that we just pass in our POJO (= InputReportIncident) that we // got from Apache CXF to Velocity. Object response = template.sendBody("velocity:MailBody.vm", parameters); // Note: the response is a String and can be cast to String if needed // store the mail in a file String filename = "mail-incident-" + parameters.getIncidentId() + ".txt"; template.sendBodyAndHeader("file://target/subfolder", response, FileComponent.HEADER_FILE_NAME, filename); }

What is impressive is that we can just pass in our POJO object we got from Apache CXF to Velocity and it will be able to generate the mail body with this object in its context. Thus we don't need to prepare anything before we let Velocity loose and generate our mail body. Notice that the template method returns a object with out response. This object contains the mail body as a String object. We can cast to String if needed.

If we run our unit test with mvn test we can in fact see that Camel has produced the file and we can type its content:

Code Block
D:\demo\part-two>type target\subfolder\mail-incident-123.txt Incident 123
Code Block
Incident $body.incidentId has been reported on the $body.incidentDate2008-07-16 by $body.givenName $body.familyNameClaus Ibsen. The person can be contact by: - email: $bodydavsclaus@apache.emailorg - phone: $body.phone +45 2962 7576 Summary: $body.summarybla bla Details: $body.detailsmore bla bla This is an auto generated email. You can not reply.