O documento compara três frameworks de integração - Spring Integration, Mule ESB e Apache Camel. O Mule ESB fornece mais recursos além de integração, enquanto o Camel oferece muitos componentes e DSLs para Java, Groovy e Scala. O Camel é o favorito do autor devido às suas DSLs de programação, embora todos os três frameworks sejam adequados para projetos de integração complexos.

1. Qual Integration Framework você deve usar - Integração
Spring, Mule ESB ou Apache Camel? – Parte 2
Mule ESB
Mule ESB é - como o nome sugere - uma ESB completo, incluindo
vários recursos adicionais, em vez de apenas uma estrutura de
integração (você pode compará-lo com Apache ServiceMix que é
um ESB baseado no Apache Camel). No entanto, Mule pode ser
usar estrutura de integração como leve, também - por simplesmente
não adicionar e utilizando todos os recursos adicionais além do
material integração EIP. Como Spring Integration, mula só oferece
uma DSL XML. Pelo menos, é muito mais fácil de ler do que Spring
Integration, na minha opinião. Mule Studio oferece um muito bom e
intuitiva designer visual. Compare o seguinte trecho de código ao
código de integração Primavera de cima. É mais como uma DSL de
Integração da Primavera. Isto é importante se a lógica de integração
é mais complexa.
<flow name=”muleFlow”>
<file:inbound-endpoint path=”incomingOrders”/>
<choice>
<when expression=”payload instanceof com.kw.DvdOrder”
evaluator=”groovy”>
<file:outbound-endpoint
path=”incoming/dvdOrders”/>
</when>
<when expression=”payload instanceof com.kw.DvdOrder”
evaluator=”groovy”>
<jms:outbound-endpoint
queue=”videogameOrdersQueue”/>
</when>
<otherwise>
<logger level=”INFO”/>

2. </otherwise>
</choice>
</flow>
A principal vantagem da mula é alguns conectores muito
interessante para interfaces proprietárias importantes, tais como
SAP, Tibco Rendevous, o Oracle Siebel CRM, Paypal ou CICS
Transaction Gateway da IBM. Se o seu projeto de integração requer
algum desses conectores, então eu provavelmente escolheria mula!
Uma desvantagem para alguns projetos pode ser que Mule diz não
a OSGi: http://blogs.mulesoft.org/osgi-no-thanks/
Apache Camel
Apache Camel é quase idêntico ao Mule. Ele oferece muitos, muitos
componentes (ainda mais do que Mule) por quase toda a tecnologia
que você poderia pensar. Se não houver nenhum componente
disponível, você pode criar seu próprio componente muito
facilmente começar com um arquétipo Maven! Se você é um cara
Spring: Camel tem integração impressionante Spring, também.
Como os outros dois, que oferece uma DSL XML:
<route>
<from uri=”file:incomingOrders”/>
<choice>
<when>
<simple>${in.header.type} is ‘com.kw.DvdOrder’</simple>
<to uri=”file:incoming/dvdOrders”/>
</when>
<when>
<simple>${in.header.type} is ‘com.kw.VideogameOrder’
</simple>
<to uri=”jms:videogameOrdersQueue”/>

3. </when>
<otherwise>
<to uri=”log:OtherOrders”/>
</otherwise>
</choice>
</route>
Legibilidade é melhor do que Spring Integration e quase idêntica à
mula. Além disso, um muito bom (mas comercial) designer visual
chamado Fuse IDE está disponível por FuseSource - gerando o
código DSL XML. No entanto, é um monte de XML, não importa se
você usar um designer visual ou apenas o seu editor de XML.
Pessoalmente, eu não gosto disso.
Portanto, vamos mostrar-lhe outra característica impressionante:
Apache Camel também oferece DSLs para Java, Groovy e Scala.
Você não tem que escrever tanto XML feio. Pessoalmente, eu
prefiro utilizar um destes DSLs fluentes em vez de XML para a
lógica de integração. Eu só faço coisas de configuração, tais como
fábricas de conexão JMS ou propriedades JDBC usando XML. Aqui
você pode ver o mesmo exemplo usando um trecho de código DSL
Java:
from(“file:incomingOrders “)
.choice()
.when(body().isInstanceOf(com.kw.DvdOrder.class))
.to(“file:incoming/dvdOrders”)
.when(body().isInstanceOf(com.kw.VideogameOrder.class
))
.to(“jms:videogameOrdersQueue “)
.otherwise()
.to(“mock:OtherOrders “);

4. As DSLs programação fluentes são muito fácil de ler (mesmo em
exemplos mais complexos). Além disso, esses DSLs de
programação têm um melhor suporte IDE do que XML (conclusão
de código, refatoração, etc.). Devido a esses DSLs fluentes
impressionante, eu sempre usar o Apache Camel, se eu não
preciso de alguns dos excelentes conectores de mula para produtos
proprietários. Devido à sua muito boa integração com Spring, eu até
prefiro Apache Camel para Integração da Primavera, na maioria dos
casos de uso.
Pela maneira: Talend oferece um designer visual gerar o código
Java DSL, mas ele gera um monte de código clichê e não permitir a
edição vice-versa (ou seja, você não pode editar o código gerado).
Este é um critério de no-go e tem de ser corrigido em breve
(espero)!
E o vencedor é…
... Todos os três quadros de integração, porque todos eles são
leves e fáceis de usar - mesmo para projetos de integração
complexos. É impressionante a integrar várias tecnologias
diferentes, usando sempre a mesma sintaxe e conceitos - incluindo
suporte muito bom teste.
O meu favorito é Apache Camel devido às suas impressionantes
DSLs Java, Groovy e Scala, combinados com muitas tecnologias
suportadas. Eu só iria usar Mule se eu precisar de alguns de seus
conectores originais para produtos proprietários. Eu só iria usar
Spring Integration em um projeto de Primavera existente e se eu só
precisa integrar "tecnologias básicas", como FTP ou JMS. No
entanto: Não importa qual desses quadros de integração leves que
você escolher, você vai se divertir muito na realização de projectos
de integração complexos facilmente com esforços baixos. Lembre-
se: Muitas vezes, um ESB gordura tem muita funcionalidade e,
portanto, muito, complexidade desnecessária e esforços. Use a
ferramenta certa para o trabalho certo!