TrustRadius Insights for Apache Camel are summaries of user sentiment data from TrustRadius reviews and, when necessary, third party data sources.
Pros
Easy Learning Curve: Several users have found Apache Camel to have an easy learning curve, allowing them to quickly grasp the concepts and start using it efficiently.
Extensive Integration Support: Many reviewers have praised Apache Camel for its extensive support for integration with diverse software platforms. With over 150 components available, users can seamlessly integrate Camel with various frameworks and middleware products such as Spring, Apache Karaf, and Servicemix.
Robustness and Reliability: Numerous users have highlighted the robustness of Apache Camel in handling various information transfer protocols out-of-the-box. They appreciate that it is a reliable solution for their integration needs, making it suitable for creating microservices and handling complex business logic.
We had some workloads where we need to integrate multiple sources & sinks of data, with different formats & protocols, while doing some pretty complex logic on top of that. Apache Camel was a natural choice for it since there are tons of built-in components that allow making easy connections to all the sources & sinks that we need. On the other hand, the Java-native nature of Apache Camel means writing & testing whatever logic we need is just business-as-usual for the engineers.
Pros
Easy & reliable integration with lots of types of source or sink of data.
Complex business logic could be written in Java.
Excellent unit testing support with Java.
Cons
Documentation could be improved
Support for complex & advance integration options could be better
Navigating the Java code base requires learning curve
Likelihood to Recommend
There are tons of integration technologies available, the point is to pick the one most suited for your use case. Apache Camel offers easy connections to lots of types of sources or sinks of data while supporting custom complex business logic, all testable. However, it means configuring using Java source code, which is a hurdle when all your logic need is very simple. There are many other GUI-based integration technologies that get those types of logic-lite work done faster.
VU
Verified User
Engineer in Engineering (Computer Software company, 201-500 employees)
When we switched from a monolithic architecture to a service oriented one we were researching on all the enterprise integration technologies. We chose Apache Camel because it was lightweight, was easy to get started with, had a groovy DSL and because it was an implementation of existing integration patterns. Over the last few years, Apache Camel became the glue that binds all our micro services. We use publish-subscribe pattern the most i.e consuming from and producing to AWS SQS queues. A lot of our quartz jobs are heavily depended on Apache Camel as well. I would highly recommend Apache Camel as a lightweight yet formidable enterprise integration solution.
Pros
Producing to and consuming from any messaging system
Message type conversion
Large support library
Cons
Documentation could use some more detail
Hot deployment
Likelihood to Recommend
For basic publish subscribe use cases, Apache Camel is the clear winner.
Apache Camel is used by many departments at Cox Communications, but not the entire organization. It enables quick and scaleable integration of diverse business systems at Cox and reduces development effort and resources. Various Camel components are used and there is even a customized version of Camel Http4 component. Also Camel fits well in the existing infrastructure at Cox.
Pros
Camel has an easy learning curve. It is fairly well documented and there are about 5-6 books on Camel.
There is a large user group and blogs devoted to all things Camel and the developers of Camel provide quick answers and have also been very quick to patch Camel, when bugs are reported.
Camel integrates well with well known frameworks like Spring, and other middleware products like Apache Karaf and Servicemix.
There are over 150 components for the Camel framework that help integrate with diverse software platforms.
Camel is also good for creating microservices.
Cons
Camel features and documentation can get confusing to new users. Documentation can and should be improved. Also it would help if there are more tutorials available. Certification in Camel and related technologies like Servicemix and Karaf would also help.
The Camel infrastructure probably needs to be rebuilt (hopefully this may happen with version 3.0). At this time the latest production release of Camel (2.17.x) is not built with the latest version of Java (JDK 1.8).
Camel should also move towards becoming a "heavyweight" ESB product, though this may detract from some of its desirable features.
Likelihood to Recommend
Apache Camel is well suited for integration of existing software programs/components with newer and external systems. It supports SOAP and REST protocols pretty well. It was not designed to directly support front end systems. It has limited to non-existent support for Javascript. It is not suitable for creating simple standalone applications and meaningful deployment does require use of other frameworks like Spring/Karaf/JBoss.
I worked on a product development team creating an enterprise cybersecurity product. The core event processing mechanism of the product used Apache Camel in many places, mainly to handle interactions over JMS between the various modules of the product. Apache Camel especially makes the process of sending a POJO from one method to another across two separate application components, handling the marshaling and unmarshaling via JAXB, and the sending and receiving via JMS. It achieves all this routing via a simple XML configuration that is part of the application's spring context (although it can also be configured procedurally).
Pros
Configuration of information routing via XML in a Sprint Context.
Robustness. Apache Camel is capable of handling many different information transfer protocols out-of-the-box.
Extensibility. Apache Camel also allows for custom routing handlers where needed.
Cons
Some of the documentation is a little sparse. In particular, its TCP-based routes use an underlying Netty server, and the interactions between Netty's decoder capabilities and Apache Camel's routing/handler capabilities can be a little muddy at times. In general it is clear which routes and endpoints are the more frequently used and which haven't been given as much attention.
Likelihood to Recommend
In my experience, Apache Camel was very useful for the main use case that we leveraged it for, i.e. wiring up JMS messaging. I found the less-frequently-used handlers and endpoints to be either less reliable, maintainable, or easy to work with than just rolling my own data transfer logic. I would stick to straightforward use cases where the XML configuration conveys the intent in a very clear manner, and avoid using Apache Camel to do large portions of moving data around that involve business logic or custom intermediaries.
I used it when I worked at Verizon Wireless. We used apache Camel on a couple projects as an integration layer between the UI and backend services and databases. We used Apache Camel's REST component. We used it as xml and java dsl [solution].
Pros
It uses URIs to directly integrate with various back-end components.
It has a very easy to use REST component.
Easy to track the execution flow while coding by using routers.
Helps keep different components separate.
Cons
To be able to hot deploy
Likelihood to Recommend
If you want to integrate several applications with different protocols and technologies you should use Apache Camel. The good thing about it is that you have to follow same steps for every integration. If you want to have a container you need to use something else.
VU
Verified User
Employee in Engineering (Computer Software company, 51-200 employees)