Para um desenvolvedor ou desenvolvedora back-end, a integração de alguns sistemas com outros é natural. Afinal, existem muitas formas de se fazer isso. No entanto, utilizando o Apache Camel, conseguimos abstrair toda a lógica do sistema que não conhecemos e nos preocupamos com apenas a integração para o nosso programa.

A partir do Apache Camel temos as duas principais opções para a definição das rotas – Java DSL e Spring DSL. Usando essas tecnologias juntamente com os conceitos da ferramenta, temos como resultado uma integração muito poderosa.

Neste artigo cobrimos tudo sobre o mundo do Apache Camel, da onde ele veio, como funciona e como usá-lo, siga com a gente!

O que é Apache Camel?

Apache Camel é uma framework open-source muito versátil baseada no que o site da Apache chama de Enterprise Integration Patterns, que nada mais é do que uma lista de padrões corporativos e middleware orientado a mensagem. Isso pode ser conferido com maior quantidade de detalhes no site oficial do Apache.

No Camel, temos a possibilidade de definir as regras de roteamento e mediação em uma variedade de linguagens específicas de domínio (DSL, XML e YAML). Dessa maneira, você consegue um auto preenchimento das regras de roteamento na sua IDE, seja em um editor Java ou XML.

O Apache Camel utiliza URIs para trabalhar diretamente com qualquer tipo de transporte ou modelo de mensagem, como HTTPS, ActiveMQ, JMS, JBI, SCA, MINA ou CXF. Também é possível utilizar as classes Components e Data Format.

Além de ser uma pequena biblioteca com poucas dependências, a integração com qualquer aplicativo Java é bem simples. O Apache Camel dá total liberdade para que você trabalhe com a mesma interface do projeto, independentemente do tipo de transporte usado. Logo, você só vai precisar aprender uma vez para conseguir interagir com todos os componentes.

Por fim, Apache Camel também tem suporte para diversas frameworks, como por exemplo o Spring Boot.

Qual a história do Apache camel?

Criado em 2007 por James Strachan, o Apache Camel já tem o seu espaço consolidado na indústria. Com os objetivos muito bem definidos e as soluções aplicadas, essa framework conseguiu em relativamente pouco tempo se tornar um case de sucesso para a Apache.

Parecida com as ferramentas Apache ServiceMix, Fuse ESB e Jboss Application Server, essa framework é adaptável a qualquer tipo de aplicação já que a sua arquitetura possibilita a utilização de apenas os componentes necessários para o seu programa. Além do mais, temos um excelente suporte a testes unitários e mocks no Apache Camel.

Como funciona o Apache Camel e entenda sua estrutura!

Vamos entender agora um pouco mais sobre a organização do Apache Camel.

Terminologia e Arquitetura

Para começar, vamos dar uma olhada nos conceitos fundamentais do Camel:

  • Message: Contém os dados que estão sendo transferidos para uma rota. Cada mensagem tem um identificador único e é construído a partir de um corpo, cabeçalho e anexo.
  • Exchange: O contêiner de uma mensagem. É criado a partir do recebimento de uma mensagem durante o processo de roteamento. Com o Exchange, conseguimos diferentes tipos de interações entre os sistemas, podemos definir uma mensagem unilateral ou uma mensagem que solicita algo e espera uma resposta
  • Endpoint: Nomenclatura muito famosa na parte do back-end. É um canal por meio do qual o sistema pode receber ou enviar uma mensagem. Pode referir-se a um URI da web, URI de fila, arquivo, endereço de e-mail, entre outros.
  • Component: Atua como uma fábrica do endpoint. Resumindo, os componentes oferecem uma interface para diferentes tecnologias utilizando a mesma abordagem e sintaxe. O Camel já tem suporte a muitos componentes para quase todas as tecnologias possíveis, no entanto também oferece a oportunidade de escrever componentes personalizados para o seu sistema.
  • Processor: É uma interface simples do Java que é usada para adicionar a lógica de integração customizada com uma rota. Ele contém o método de processo que é usado para realizar a lógica de negócios personalizada em uma mensagem recebida por uma pessoa consumidora. 

Vendo por cima, a arquitetura do Apache Camel é bem simples. Temos o CamelContext, que representa o sistema no tempo de execução, e a partir disso obtemos os diferentes conceitos de rotas, componentes e endpoints.

Além do mais, os processadores lidam com o roteamento e as transformações entre os endpoints.

Rotas

No Camel, temos o conceito de rotas. Essas interligam os endpoints determinados pelos métodos from() e to(), referindo-se a origem e destino, respectivamente. 

Como parâmetros desses métodos, temos a chance de utilizar as URIs de acordo com o componente utilizado. Entre os dois endpoints, podemos escolher algumas regras para o tratamento de dados, tais como transformações, filtros, divisões, validações, etc.

URI

Podemos ver a estrutura de uma URI no Apache Camel a seguir:

Estrutura da URI Apache Camel

Todas as URIs têm o mesmo padrão: componente:parâmetros?opções. O primeiro elemento refere-se ao componente a ser utilizado para ler os dados na entrada da rota e, a partir da base nas especificações dele, são definidos os parâmetros e as opções.

Componentes

Com um suporte de pelo menos 20 componentes no core e mais outros 300 disponíveis para o uso, o Apache Camel tem uma biblioteca considerável. Na documentação oficial, podemos ver a listagem de todos os componentes. Com eles, conseguimos implementar APIs utilizando o seu sistema de integração. Dessa forma, podemos até mesmo abstrair os protocolos e os tipos de dados.

O que é a Domain Specific Language?

Domain Specific Language, ou em português, linguagem de domínio específico é uma linguagem de programação dedicada a um determinado domínio de um aplicativo

Temos um grande volume de variedades de DSLs, desde linguagens que utilizamos para domínios comuns, como HTML para páginas da web, até linguagens usadas por apenas um ou alguns pedaços do programa, como Mush.

DSLs podem ser subdivididos pelo tipo de linguagem e incluem linguagens de marcação específicas de domínio, como o XML, linguagens de modelagem específicas de domínio e linguagens de programação específicas de domínio.

Esses tipos de linguagens sempre existiram na computação, no entanto, o termo “linguagem de domínio específico” tornou-se muito popular nos últimos anos. Isso se deve ao surgimento da modelagem de domínio específico. 

Voltando ao Camel, as rotas e a engenharia do roteamento são parte fundamental dessa ferramenta. Temos nas rotas o fluxo e a lógica de integração entre os diferentes sistemas.

Para definir as rotas de uma maneira mais simples e limpa, o Camel oferece diferentes tipos de DSLs para as linguagens de programação como Java ou Groovy. Por outro lado, também oferece a possibilidade de definir rotas no XML com o Spring DSL.

Quais as principais características do Apache Camel?

Para começar, temos um ótimo suporte ao poderoso Data Format e conversores de tipos para as possíveis transformações das nossas mensagens. Assim, novos formatos e conversores podem ser adicionados no futuro sem nenhum problema. Atualmente, o Apache Camel oferece suporte aos formatos CSV, EDI, JAXB, JSON, XmlBeans, XStream, Flatpack e Zip.

A ferramenta dá suporte para as linguagens conectáveis para escrever em DSL. Algumas dessas linguagens são: JavaScript, Groovy, Python, PHP, Ruby, SQL, XPath e XQuery.

O Camel também suporta o modelo POJO para que o desenvolvedor ou desenvolvedora consiga conectar o Javabeans em vários pontos. Outro ponto forte é a facilidade na hora de testar os sistemas distribuídos e as mensagens assíncronas.

Quando devo usar Apache Camel? 

Veremos a seguir algumas situações onde podemos utilizar o Apache Camel:

Integrando aplicativos juntos

O principal objetivo do Camel é a movimentação de dados entre diferentes protocolos e aplicativos (como arquivos, e-mails, APIs ou aplicativos da web).

Conseguimos usar o Apache Camel quando queremos mover dados entre qualquer um dos aplicativos e protocolos suportados por seus mais de 300 componentes. Os componentes do Camel geralmente funcionam de maneira semelhante. Dessa forma, depois de aprender a como usar um componente, será mais fácil utilizar outros. O Camel inclui componentes para muitos aplicativos diferentes, do Facebook e Twitter ao Salesforce e Workday. Você também pode escrever um componente customizado.

Desenvolvimento baseado em padrões

Alguns requisitos frequentes para integração — como suporte para transações ou transformações de dados — normalmente seriam complicados de planejar e escrever em código. Mas o Camel oferece algumas soluções por padrão e, muitas vezes, pode ser ativado com apenas o toque de um botão, ou alterando uma variável. A partir do Camel, temos alguns padrões e funcionalidades para coisas como:

  • Dados de roteamento com base no seu conteúdo
  • Manipulação de erros, transações e reversões
  • Transformação de dados
  • Cache de dados acessados com frequência
  • Criptografia e autenticação

Esses são apenas alguns exemplos do que o Camel é capaz de fazer.

Todas essas lógicas são facilitadas pelo Apache Camel, pois ele fornece esses recursos como um conjunto de padrões, chamados de padrões de integração empresarial. Se for útil para o seu projeto, você pode utilizar qualquer um desses padrões de integração no seu código, sem nem precisar escrever sua própria solução.

Com base nesses padrões, o Camel se torna uma ferramenta poderosíssima e muito produtiva para integrar sistemas distribuídos.

Um estilo de alto nível para muitas integrações

Depois que você entende os padrões e os componentes do Camel, tudo se torna muito mais fácil.

Essa é uma das principais vantagens do Camel: a habilidade de criar muitas integrações com muita velocidade. O Apache Camel é ideal para quando você estiver desenvolvendo muitas integrações e gostaria que todas fossem desenvolvidas de maneira igualitária. Essa provavelmente é uma opção muito atrativa para empresas de grande porte, podendo ajudar a escolher uma abordagem que seja compartilhada e compreendida pela equipe de desenvolvimento.

Quando não usar Apache Camel?

E quais são as situações onde não devemos utilizar o Apache Camel? Confira:

Para transformação de muitos dados

Apesar de o Camel ser ótimo para se conectar a muitos aplicativos diferentes, ele não foi arquitetado para análises e transformações pesadas de dados. Se você tem um fluxo de trabalho com muitos dados, onde necessita fazer muita mesclagem e processamento intensivo destes, como por exemplo, processamento em lote ou ETL, então provavelmente existem outras ferramentas que são melhores para esse tipo de trabalho.

No entanto, o Apache Camel ainda é ótimo para orquestrar várias etapas juntas em fluxo. Portanto, você ainda pode considerar o uso do Camel como condutor para seus processos de transformação de dados.

Se você só precisa escrever um único fluxo de integração 

O Apache Camel é muito leve e ficou ainda mais nos lançamentos recentes. Porém, provavelmente não vale a pena aprender todos os padrões e toda a abordagem do Camel para o desenvolvimento de integração, caso você só precise disso para escrever uma única. 

Se você só precisa escrever um único fluxo de integração, talvez seja melhor escrever seu código de integração sozinho.

Se você não tem ninguém que saiba Java na sua equipe

Como o Camel é um framework baseado em Java, é necessário algum conhecimento prévio da linguagem para usá-lo. Não é muito difícil usar o DSL baseado em XML para configurá-lo, mas ainda assim ajuda ter algum conhecimento de Java para entender os conceitos, principalmente porque tudo é executado na JVM (Java Virtual Machine). Esse conhecimento pode ser muito útil para quando você for solucionar alguns problemas mais graves, pois saber ler um stack trace lhe ajudará.

Apache Camel vs Enterprise Service Bus: quais as diferenças?

Como já comentamos, o Apache Camel é um framework de integração open source leve que implementa a grande maioria dos Enterprise Integration Patterns. Dessa maneira, é possível integrar diferentes aplicações usando os modelos requeridos. Além do mais, toda a estrutura de padrões e componentes do Camel torna a experiência do desenvolvimento muito mais fluida.

No outro lado, temos o Enterprise Service Bus que também usa um framework de integração em seu core operacional. No entanto, temos algumas outras características, como a gestão de processos de integração, registro e rastreamento de atividades das execuções. Também contamos com uma interface gráfica para a configuração de rotas e alguns outros detalhes.

Normalmente, o ESB é uma ferramenta muito mais complexa que o Camel, a sua curva de aprendizado é bem maior. Por isso, esse tipo de produto está perdendo a força no mercado, tanto por ter soluções mais simples ou arquiteturas mais novas.

Quais as principais aplicações do Apache Camel na vida real?

Por ser uma tecnologia mais usada em projetos fechados, o Apache Camel não tem um grande projeto de código, dessa forma vamos analisar os principais tipos de aplicações que conseguimos desenvolvedor utilizando o Camel:

Ilustração da estrutura de funcionamento do Apache Camel
Principal fluxo do Apache Camel.
Na ordem:
Endpoint: Recebe a mensagem
Rota: Um fluxo em Camel
EIP: Processa a mensagem
Camel Context: Contêiner por onde sua rota segue
Endpoint: Envia a mensagem
  • Processar e rotear dados: Conseguimos processar pedidos de clientes e encaminhá-los para um banco de dados (Utilizando Spring Boot com o Camel e o ActiveMQ)
  • Processar dados enviados pela web: Podemos receber e transformar formulários de uma pesquisa agrícola e, logo depois, adicionar em um banco de dados (Camel com Apache Karaf)
  • Processamento de transações financeiras usando filas de mensagens: Alinhamos as transações financeiras e encaminhamos para o departamento correto (Novamente Camel com Apache Karaf)
  • Gateway nas suas APIs: Temos a possibilidade de adicionar um gateway que autentica uma API e roteia as mensagem para a API correta (Apache Camel com Spring Boot)

Resumindo, os melhores casos de uso para o Camel são quando temos uma forte base de dados para consumir. Podemos utilizar tanto mensagens vindas de uma fila ou dados de um API. No final, temos que escolher um destino para enviar os dados.

Como instalar o Apache Camel? O passo a passo!

Para a instalação do Apache Camel, devemos primeiramente ter uma IDE do Java instalada em nossos computadores. Podemos escolher entre NetBeans, Eclipse e Intellij. A partir disso, devemos entrar na seção de download do Camel e procurar a versão mais estável do projeto. No momento que estamos escrevendo esse artigo, a versão 3.7.5 é a mais recomendada.

Logo depois, entrando página da versão, temos as importações das dependências para colocar seu pom.xml:

Dependências

Após isso, tudo estará pronto para utilizar o Apache Camel.

Como usar o Apache Camel! Entenda com um exemplo prático!

Para iniciar o código pom.xml, utilizaremos esse:

<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.apache.camel.exemplo</groupId>
        <artifactId>exemplos</artifactId>
        <version>3.12.0-SNAPSHOT</version>
    </parent>

    <artifactId>camel-exemplo-basico</artifactId>
    <packaging>jar</packaging>
    <name>Camel :: Exemplo :: Basico</name>
    <description>Exemplo básico</description>

    <dependencyManagement>
        <dependencies>
            <!-- Adicionando Camel BOM -->
            <dependency>
                <groupId>org.apache.camel</groupId>
                <artifactId>camel-bom</artifactId>
                <version>${camel.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>

        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-core</artifactId>
        </dependency>

        <!-- Adicionando dependências de log -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <scope>runtime</scope>
            <version>${log4j2-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <scope>runtime</scope>
            <version>${log4j2-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <scope>runtime</scope>
            <version>${log4j2-version}</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>

            <!-- Permite que as rotas possam ser rodadas a partir do comando 'mvn camel:run' -->
            <plugin>
                <groupId>org.apache.camel</groupId>
                <artifactId>camel-maven-plugin</artifactId>
                <version>${camel.version}</version>
                <configuration>
                    <mainClass>org.apache.camel.exemplo.basico.CamelBasico</mainClass>
                </configuration>
            </plugin>

        </plugins>

    </build>

</project>

Aqui adicionamos todas as dependências que o Apache Camel necessita para funcionar. Em seguida criaremos o arquivo principal de execução, o código é bem simples e necessita apenas de um arquivo:

package org.apache.camel.example.basic;

import org.apache.camel.CamelContext;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;

/**
 * Um simples exemplo rodando como public static void main
 */
public final class CamelBasico {

    public static void main(String[] args) throws Exception {
        // Cria o contexto do Camel
        try (CamelContext camel = new DefaultCamelContext()) {

            // Adiciona as rotas que podem ser escritas como uma classe anônima interna
            // (para todo o código ficar em um único arquivo Java)
            camel.addRoutes(new RouteBuilder() {
                @Override
                public void configure() {
                    from("timer:foo")
                            .log("Olá Camel");
                }
            });

            // Iniciando
            camel.start();

            // roda por 10 segundos
            Thread.sleep(10_000);

            // e para de rodar tranquilamente 
            camel.stop();
        }
    }
}

O exemplo é bem simples e tem alguns comentários relevantes. Para rodar o projeto, comece rodando o comando de build, mvn compile.

Depois de concluído o passo do build, basta apenas rodar mvn camel:run para executar a aplicação. Você também pode rodar o programa na sua IDE, se quiser.

Resultado da execução
Resultado da execução

Na área da programação, existem muitas vertentes e devemos sempre olhar elas com bons olhos. O Apache Camel é uma ferramenta incrível para integrar sistemas que não se comunicam. Pode não parecer ser algo realmente útil, mas quando olhamos o mundo empresarial, percebemos uma grande demanda para isso.

Quando criamos um sistema novo não imaginamos que um dia ele poderá ser usado em outros, desse jeito acabamos não nos preparando para nenhum tipo de integração no futuro. O Apache Camel consegue lidar com essa questão para que não precisemos realocar esforços em projetos antigos. A partir dessa ferramenta, criamos uma interface simples e rápida para que os outros sistemas consigam interagir e dessa forma resolvemos vários problemas.

Quer entender mais sobre o mundo da integração de sistemas? Então leia um pouco mais sobre a API: o que é, como funciona e exemplos práticos!

0 Shares:
Você também pode gostar