This article introduces OpenHub framework – new open-source integration solution based on Apache Camel. The article responds to questions why you should care about another integration framework, what are strong/weak properties and how to start a new project with OpenHub.
OpenHub framework is Apache Camel, but improved …
You can of course use only Apache Camel but you need to add a lot of other libraries, check their compatibility, prepare database and application server, then configure and tune everything together for production quality. Furthermore, for solving real problems you often need more than basic functionality …
OpenHub framework puts together the best application libraries and frameworks and creates a proven, tested and supported application stack that you can take and start integrating immediately. Moreover you get enterprise functionality that is available in commercial versions only.
Besides, OpenHub framework offers an effective way to structure project, to create routes and test them. It is based on several years’ experience with implementation integration projects. Nevertheless, it’s up to you which approach to use, whether OpenHub’s functionality or directly Apache Camel. There are no limitations in using Camel’s functionalities. You can choose functionality from Camel, OpenHub framework or another third-party component. Of course you can use the same tools which can be used by Apache Camel, for example Red Hat® JBoss® Fuse or Hawtio.
Our recommendation is to use best from both – use OpenHub framework as base (defines project structure, application stack, offers a lot of useful functionality for future use, …) together with any Camel’s functionality you need, also with third-party tools which work with Apache Camel.
Architecture
OpenHub framework extends Apache Camel and therefore base architecture came up from Apache Camel. We have created full application stack with the following libraries and frameworks:
- Spring Boot
- Spring Framework
- Spring Security solves security issues
- Spring Web Services is main component for web services communication
- Hibernate for persistence implementation
- PostgreSQL database (or H2 DB for unit tests)
- Apache Tomcat application server
- Hazelcast cache / memory grid
OpenHub is neutral to the database and application server. OpenHub supports both on-premise and cloud installations.
OpenHub framework has been created with the flexibility in mind – you can use/extend implementation from Camel, OpenHub or write your own.
Why use OpenHub framework?
OpenHub comes with enterprise functions like an asynchronous messaging model, cluster support and its own admin console.
The following patterns are implemented in asynchronous messaging model:
- parent-child concept – if one message is too complex to process then it can be splitted into smaller child messages (partial messages),
- obsolete messages – this functionality checks for duplicate and outdated calls,
- funnel is for filtering concurrent messages at specific integration point. This filtering ensures that only one message at one moment will be processed, even in guaranteed order (optional choice),
- guaranteed message processing order ensures processing order of incoming messages,
- confirmation to callee system – when asynchronous message is processed (is in the final status) then OpenHub can transmit information about result of processing to callee, system,
- monitoring / alerts – defines metrics for watching database data and if any metric exceeds its limit then alert is activated and further operation can be executed.
There are no limitations for synchronous messages from a performance point of view – it’s as fast as Apache Camel. For asynchronous messages we use a database by default for saving states – although this could be a bottleneck in some cases from a performance point of view, it still has many advantages. So far we haven’t hit performance limits in our real projects but we wouldn’t recommend it for really performance demanding projects. On the other side we believe that every company has a database and therefore we would also like to reuse it for OpenHub. Nevertheless there is possibility to use JMS/MQ systems in your company to support asynchronous messaging.
Create new project
Create new Maven project with reference to parent artifact of OpenHub framework:
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.openhubframework.ri</groupId> <artifactId>ri-openhub</artifactId> <version>1.0.0-SNAPSHOT</version> <name>OpenHub - Reference implementation</name> <packaging>pom</packaging> <parent> <groupId>org.openhubframework</groupId> <artifactId>openhub</artifactId> <version>2.0.0.RC1</version> </parent> <modules> <module>openhub-ext</module> <module>openhub-war</module> </modules> ...
We recommend to create the following project structure with at least two modules:
- project – module for project specific routes and business logic
- war – module that builds this project and OpenHub framework together
We have created reference project implementation with basic integration scenarious.
Sources
- Web: www.openhubframework.org
- Wiki: https://openhubframework.atlassian.net
- GitHub OpenHub: https://github.com/OpenWiseSolutions/openhub-framework
- GitHub OpenHub-RI: https://github.com/OpenWiseSolutions/openhub-ri
