Part 2
TODO: links to Camel documentation for Log and File component
Adding Camel
In this part we will introduce Camel so we start by adding Camel to our pom.xml:
...
Here at first we want Camel to log the givenName and familyName parameters we receive, so we add the LogComponent
with the key log. And we must start Camel before its ready to act.
Tip | ||
---|---|---|
| ||
The Log and File components is documented as well, just click on the links. Just return to this documentation later when you must use these components for real. |
Then we change the code in the method that is invoked by Apache CXF when a webservice request arrives. We get the name and let Camel have a go at it in the new method we create sendToCamel:
...
Code Block | ||||
---|---|---|---|---|
| ||||
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); } } |
...
Code Block | ||||
---|---|---|---|---|
| ||||
String filename = "easy-incident-" + incidentId + ".txt"; template.sendBodyAndHeader("file://target/subfolder", name, FileComponent.HEADER_FILE_NAME, filename); |
Reducing even more code lines
Well we got the Camel code down to 1-2 lines for sending the message to the component that does all the heavy work of wring the message to a file etc. But we still got 5 lines to initialize Camel.
Code Block | ||||
---|---|---|---|---|
| ||||
camel = new DefaultCamelContext();
camel.addComponent("log", new LogComponent());
camel.addComponent("file", new FileComponent());
template = camel.createProducerTemplate();
camel.start();
|
This can also be reduced. All the standard components in Camel is auto discovered on-the-fly so we can remove these code lines and we are down to 3 lines.
Info | ||
---|---|---|
| ||
When an endpoint is requested with a scheme that Camel hasn't seen before it will try to look for it in the classpath. It will do so by looking for special Camel component marker files that reside in the folder
The class property defines the component implementation. Tip: End-users can create their 3rd party components using the same technique and have them been auto discovered on-the-fly. |
Okay back to the 3 code lines:
Code Block | ||||
---|---|---|---|---|
| ||||
camel = new DefaultCamelContext();
template = camel.createProducerTemplate();
camel.start();
|
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
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. 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 | ||||
---|---|---|---|---|
| ||||
private String createMailBody(InputReportIncident parameters) {
StringBuilder sb = new StringBuilder();
sb.append("Incident ").append(parameters.getIncidentId());
sb.append(" has been reported on the ").append(parameters.getIncidentDate());
sb.append(" by ").append(parameters.getGivenName());
sb.append(" ").append(parameters.getFamilyName());
// and the rest of the mail body with more appends to the string builder
return sb.toString();
}
|
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 | ||||
---|---|---|---|---|
| ||||
<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 | ||||
---|---|---|---|---|
| ||||
<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 | ||||
---|---|---|---|---|
| ||||
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 has been reported on the 2008-07-16 by Claus Ibsen.
The person can be contact by:
- email: davsclaus@apache.org
- phone: +45 2962 7576
Summary: bla bla
Details:
more bla bla
This is an auto generated email. You can not reply.
|
First part of the solution
What we have seen here is actually what it takes to build the first part of the integration flow. Receiving a request from a webservice, transform it to a mail body and store it to a file, and return an OK response to the webservice. All possible within 10 lines of code. So lets wrap it up here is what it takes:
Code Block | ||||
---|---|---|---|---|
| ||||
/**
* The webservice we have implemented.
*/
public class ReportIncidentEndpointImpl implements ReportIncidentEndpoint {
private CamelContext camel;
private ProducerTemplate template;
public ReportIncidentEndpointImpl() throws Exception {
// create the camel context that is the "heart" of Camel
camel = new DefaultCamelContext();
// get the ProducerTemplate thst is a Spring'ish xxxTemplate based producer for very
// easy sending exchanges to Camel.
template = camel.createProducerTemplate();
// start Camel
camel.start();
}
public OutputReportIncident reportIncident(InputReportIncident parameters) {
// transform the request into a mail body
Object mailBody = template.sendBody("velocity:MailBody.vm", parameters);
// store the mail body in a file
String filename = "mail-incident-" + parameters.getIncidentId() + ".txt";
template.sendBodyAndHeader("file://target/subfolder", mailBody, FileComponent.HEADER_FILE_NAME, filename);
// return an OK reply
OutputReportIncident out = new OutputReportIncident();
out.setCode("OK");
return out;
}
}
|
Okay I missed by one, its in fact only 9 lines of java code and 2 fields.
End of part 2
I know this is a bit different introduction to Camel to how you can start using it in your projects just as a plain java .jar framework that isn't invasive at all. I took you through the coding parts that requires 6 - 10 lines to send a message to an endpoint, buts it's important to show the Message Endpoint EIP pattern in action and how its implemented in Camel. Yes of course Camel also has to one liners that you can use, and will use in your projects for sending messages to endpoints. This part has been about good old plain java, nothing fancy with Spring, XML files, auto discovery, OGSi or other new technologies. I wanted to demonstrate the basic building blocks in Camel and how its setup in pure god old fashioned Java. There are plenty of eye catcher examples with one liners that does more than you can imagine - we will come there in the later parts.
Okay part 3 is about building the last pieces of the solution and now it gets interesting since we have to wrestle with the event driven consumer.
Brew a cup of coffee, tug the kids and kiss the wife, for now we will have us some fun with the Camel. See you in part 3.