---
title: Camel and Wicket Playing Together
description: A brief case for using Apache Camel and Wicket to streamline system integrations.
image: https://blog.avenuecode.com/hubfs/Images/Blog/FullSizeRender-5.jpg
---
[AvenueCode.com](https://avenuecode.com) [News](https://avenuecode.com/news) [Contact](https://avenuecode.com/contact)
[](https://blog.avenuecode.com/?hsLang=en-us) *menu*
- Technology
[Cloud](https://blog.avenuecode.com/blog/topic/cloud?hsLang=en-us) [Delivery Infrastructure](https://blog.avenuecode.com/blog/topic/delivery-infrastructure?hsLang=en-us) [Web Experience](https://blog.avenuecode.com/blog/topic/web-experience?hsLang=en-us) [Agile Mindset](https://blog.avenuecode.com/blog/topic/agile-mindset?hsLang=en-us) [Quality First](https://blog.avenuecode.com/blog/topic/quality-first?hsLang=en-us)
[Design](https://blog.avenuecode.com/blog/topic/design?hsLang=en-us) [Solution Architecture](https://blog.avenuecode.com/blog/topic/solution-architecture?hsLang=en-us) [Data & ML](https://blog.avenuecode.com/blog/topic/data-and-machine-learning?hsLang=en-us) [Mobile Experience](https://blog.avenuecode.com/blog/topic/mobile-experience?hsLang=en-us)
- [Whitepapers](https://blog.avenuecode.com/blog/topic/whitepapers?hsLang=en-us)
- [Spotlight](https://blog.avenuecode.com/blog/topic/spotlight?hsLang=en-us)
- [Extraordinary Women in Tech](https://blog.avenuecode.com/blog/topic/extraordinary-women-in-tech?hsLang=en-us)
- [Avenue Code Culture](https://blog.avenuecode.com/blog/topic/avenue-code-culture?hsLang=en-us)
- [Cloud](https://blog.avenuecode.com/blog/topic/cloud?hsLang=en-us)
- [Design](https://blog.avenuecode.com/blog/topic/design?hsLang=en-us)
- [Delivery Infrastructure](https://blog.avenuecode.com/blog/topic/delivery-infrastructure?hsLang=en-us)
- [Solution Architecture](https://blog.avenuecode.com/blog/topic/solution-architecture?hsLang=en-us)
- [Web Experience](https://blog.avenuecode.com/blog/topic/web-experience?hsLang=en-us)
- [Data & ML](https://blog.avenuecode.com/blog/topic/data-and-machine-learning?hsLang=en-us)
- [Agile Mindset](https://blog.avenuecode.com/blog/topic/agile-mindset?hsLang=en-us)
- [Mobile Experience](https://blog.avenuecode.com/blog/topic/mobile-experience?hsLang=en-us)
- [Quality First](https://blog.avenuecode.com/blog/topic/quality-first?hsLang=en-us)
- [Whitepapers](https://blog.avenuecode.com/blog/topic/whitepapers?hsLang=en-us)
- [Spotlight](https://blog.avenuecode.com/blog/topic/spotlight?hsLang=en-us)
- [Extraordinary Women in Tech](https://blog.avenuecode.com/blog/topic/extraordinary-women-in-tech?hsLang=en-us)
- [Avenue Code Culture](https://blog.avenuecode.com/blog/topic/avenue-code-culture?hsLang=en-us)
# [Camel and Wicket Playing Together](https://blog.avenuecode.com/camel-and-wicket-playing-together)
- [Tweet](https://twitter.com/share)
*perm\_identity* [Luis Felipe Volpato Alves](https://blog.avenuecode.com/camel-and-wicket-playing-together/author/luis-felipe-volpato-alves?hsLang=en-us)
*schedule* 12/14/16 4:13 PM
> Imagine this scenario: you're responsible for integrating your company’s system with an old system from one of your clients. Every day, just when you think you've achieved it, the client’s system crashes and you have no idea why. You are so disappointed that you don’t even want to get a drink with your friends anymore, you just want to stay home thinking of ways to solve the problem. Well, that was my story - until I found Apache Camel and Apache Wicket.
[Apache Camel](http://camel.apache.org/) is a lightweight integration framework. Sometimes, the facing problem is not just about integration, but about showing the user results as well.
[Apache Wicket](http://wicket.apache.org/) is a web component-based framework on which you can write web pages very easily using only java and html.
In this article I will show you how I used these two amazing tools to solve my problem, get my life back on track and start drinking beer again. Really. They're that good.
**Getting started**
To start, I'll use [Maven](http://maven.apache.org/) to manage the dependencies.
Creating an application in Wicket using Maven is pretty easy. I just needed to find the correct archetype ([this page](https://wicket.apache.org/start/quickstart.html) helps a lot), and I’m ready. Running this command will create a new project for me, and I can import it into my favorite IDE as a Maven project:
```
mvn archetype:generate -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=8.0.0-M2 -DgroupId=com.avenuecode -DartifactId=wicket-camel -DarchetypeRepository=https://repository.apache.org/ -DinteractiveMode=false
```
I selected the options following this picture:
This step could take a while, since it will download some dependencies.
To test the recently created application, I ran the `com.avenuecode.Start` class as a Java application and access `http://localhost:8080` in my browser. The result was:
Ok, I have a web application working! Now it’s time to integrate it with Camel.
## **Integrating Wicket and Camel**
To use the best of the two frameworks, I’ll need a third and well-known framework: Spring. Wicket came with its own Spring version, but I faced some compatibility issues here, so I just excluded this dependencies and used a compatible version. In this example, using Wicket version `8.0.0-M2` and Camel version `2.16.0`, I’ll use Spring version `4.3.3.RELEASE`.
Adding Spring dependency and removing the Spring itself in `pom.xml` (I need this dependency because Wicket contains specific code for Spring, we just need another version):
```
...
org.apache.wicketwicket-spring${wicket.version}org.springframeworkspring
...
```
To add the dependencies for Spring:
```
...
org.springframeworkspring-core${spring.version}org.springframeworkspring-context${spring.version}org.springframeworkspring-web${spring.version}
...
```
Camel dependencies:
```
...
org.apache.camelcamel-core${camel.version}org.apache.camelcamel-spring${camel.version}org.apache.camelcamel-http${camel.version}org.apache.camelcamel-tagsoup${camel.version}
...
```
To better organize our `pom.xml`, we’ll add these properties:
```
...
2.16.04.3.3.RELEASE
...
```
Saving `pom.xml` will organize the dependencies in the IDE.
> In case this doesn’t happen automatically, you should update the project inside the IDE).
A good way to see if it's working is to run the `com.avenuecode.Start` class again and access `http://localhost:8080`. I saw the same page, so I’m good.
## **Configuring Spring**
The dependencies are fine, but I needed to do a few more steps to really use Spring in Wicket.
First, I needed to create the file `applicationContext.xml` in `WEB-INF` folder. This is what it looks like:
The content for `applicationContext.xml` is something like this:
```
```
I needed to add this content to `web.xml` as well:
```
...
contextConfigLocation/WEB-INF/applicationContext.xmlorg.springframework.web.context.ContextLoaderListener
...
```
Last step is to “turn on” Spring in our Wicket application, adding this line in `init()` method in `com.avenuecode.WicketApplication`:
```
public void init() {
super.init();
...
getComponentInstantiationListeners().add(new SpringComponentInjector(this));
...
}
```
Now, how can I tell if it’s working? As I added *com.avenuecode.bean* in the component-scan, Spring will search in this package for Spring beans. So I can create one bean to test it:
```
package com.avenuecode.bean;
import org.springframework.stereotype.Component;
@Component
public class HelloBean {
public String getHello() {
return "Hello, Spring!";
}
}
```
And then change the `com.avenuecode.HomePage` to use this bean:
```
package com.avenuecode;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.apache.wicket.spring.injection.annot.SpringBean;
import com.avenuecode.bean.HelloBean;
public class HomePage extends WebPage {
private static final long serialVersionUID = 1L;
@SpringBean
private HelloBean helloBean;
public HomePage(final PageParameters parameters) {
super(parameters);
add(new Label("version", helloBean.getHello()));
// TODO Add your page's components here
}
}
```
Note that `HelloBean` is annotated with `@SpringBean`. This is the annotation that Wicket uses to use the beans in Spring.
Now let’s check back and see if it’s working. I ran the `com.avenuecode.Start`, and looked at the bottom of the page. It’s showing *"Hello, Spring!"* instead of the Wicket version, and Spring and Wicket are working well together!
**Ok, Wicket and Spring are running. Now what about Camel?**
To setup Camel, I needed to add a `camel-context.xml` file in the same folder as `applicationContext.xml`, `WEB-INF`. In this file, I’ll tell Camel where the folder is to scan that contains the routes to execute. Here is an example:
```
com.avenuecode.route
```
To configure Camel in Spring, I just added `` into `applicationContext.xml`.
```
```
To see everything working (at least to see it working on the console), I also changed the root level from `WARN` to `INFO`inside `log4j2.xml`, like this:
```
...
...
```
The last step was to create a Camel route to move from a specific directory to another one.
```
package com.avenuecode.route;
import org.apache.camel.builder.RouteBuilder;
public class FileRouteBuilder extends RouteBuilder {
@Override
public void configure() throws Exception {
from("file:src/data")
.log("Message received!")
.to("file:target/messages");
}
}
```
Running `com.avenuecode.Start` again, I could see Camel in action. Then, I moved a file to the directory `src/data`. The file was moved to `target/messages`, and the console displayed the message: **Message received!**.
File in `src/data` folder:
File should be moved to `target/messages`:
And the console:
## **Time to solve the problem!**
The problem is pretty similar to what I did before now. The system receives a file in an ftp server and needs to move it to a local folder to be processed. But to make it easier to show, I’ll continue working with local folders, using `src/in` and `target/out`. I’ll create another route to process this file, and store the status in memory so I can show it.
To store the status, I can simply create a Spring bean:
```
package com.avenuecode.bean;
import org.springframework.stereotype.Component;
@Component
public class FileStatus {
private String status = "UNDEFINED";
public void ok() {
this.status = "Ok";
}
public void error() {
this.status = "Error";
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
```
And the route:
```
package com.avenuecode.route;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import com.avenuecode.bean.FileStatus;
public class ProcessFileRouteBuilder extends RouteBuilder {
@Autowired
private FileStatus fileStatus;
@Override
public void configure() throws Exception {
from("file:src/in").process(new Processor() {
@Override
public void process(Exchange exchange) throws Exception {
String message = exchange.getIn().getBody(String.class);
if (message.toLowerCase().contains("error")) {
fileStatus.error();
} else {
fileStatus.ok();
}
}
}).log("Message processed!").to("file:target/out");
}
}
```
Running `com.avenuecode.Start` showed in the console what’s happened. If I put a file inside `data/in`, it will show **“Message processed!”** and the status will be changed in memory. But I can’t show the console to the user, right?
## **Creating a page to show the status of the route**
I used our initial page, just changing some code in `com.avenuecode.HomePage`:
```
package com.avenuecode;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.apache.wicket.spring.injection.annot.SpringBean;
import com.avenuecode.bean.FileStatus;
public class HomePage extends WebPage {
private static final long serialVersionUID = 1L;
@SpringBean
private FileStatus fileStatus;
public HomePage(final PageParameters parameters) {
super(parameters);
add(new Label("status", fileStatus.getStatus()));
}
}
```
And the `HomePage.html` file:
```
Integration status