Eu não entendo o que exatamente Camel faz.

Se você pudesse citar 101 palavras, uma introdução ao Camel:

• O que exatamente é isso?
• Como ele interage com um aplicativo escrito em Java?
• É algo que acompanha o servidor?
• É um programa independente?

Por favor, explique o que é Camel.

Se você tiver de 5 a 10 minutos, geralmente recomendo que as pessoas leiam esta integração com o Apache Camel de Jonathan Anstey. É uma peça bem escrita que fornece uma breve introdução e uma visão geral de alguns dos conceitos do Camel e implementa um caso de uso com exemplos de código. Nele, Jonathan escreve:

O Apache Camel é uma estrutura Java de código aberto que se concentra em tornar a integração mais fácil e mais acessível aos desenvolvedores. Faz isso fornecendo:

• implementações concretas de todos os padrões de integração corporativa (EIPs) amplamente usados
• conectividade a uma grande variedade de transportes e APIs
• DSLs (Domain Specific Languages) fáceis de usar para conectar EIPs e transportes

Há também um capítulo gratuito do Camel in Action que apresenta o Camel no primeiro capítulo. Jonathan é co-autor desse livro comigo.

Minha opinião é descrever isso de uma maneira mais acessível ...

Para entender o que é o Apache Camel, você precisa entender o que são os padrões de integração corporativa.

Vamos começar com o que presumivelmente já sabemos: o padrão Singleton, o padrão Factory, etc; São apenas maneiras de organizar sua solução para o problema, mas não são soluções em si. Esses padrões foram analisados ​​e extraídos para o resto de nós pela Gangue dos Quatro, quando publicaram seu livro: Design Patterns . Eles pouparam alguns de nós um tremendo esforço ao pensar em como estruturar melhor nosso código.

Assim como o Gang of Four, Gregor Hohpe e Bobby Woolf foram os autores do livro Enterprise Integration Patterns (EIP), no qual eles propõem e documentam um conjunto de novos padrões e esquemas de como podemos projetar melhor sistemas grandes baseados em componentes, onde componentes podem ser executando no mesmo processo ou em uma máquina diferente.

Eles basicamente propõem que estruturemos nosso sistema para ser orientado a mensagens - onde os componentes se comunicam usando mensagens como entradas e saídas e absolutamente nada mais. Eles nos mostram um conjunto completo de padrões que podemos escolher e implementar em nossos diferentes componentes que juntos formarão todo o sistema.

Então, o que é o Apache Camel?

O Apache Camel oferece as interfaces para os EIPs, os objetos base, implementações geralmente necessárias, ferramentas de depuração, um sistema de configuração e muitos outros auxiliares que economizarão muito tempo quando você deseja implementar sua solução para seguir os EIPs.

Tome MVC. O MVC é bastante simples em teoria e poderíamos implementá-lo sem nenhuma ajuda da estrutura. Porém, boas estruturas de MVC nos fornecem a estrutura pronta para uso e foram além e pensaram em todas as outras coisas "secundárias" necessárias quando você cria um grande projeto de MVC e é por isso que as usamos na maioria das vezes.

É exatamente isso que o Apache Camel é para os EIPs. É uma estrutura completa pronta para produção para pessoas que desejam implementar sua solução para seguir os EIPs.

Criar uma descrição do projeto não deve ser complicado.

Eu digo:

O Apache Camel é uma cola de tecnologia de mensagens com roteamento. Ele une os pontos inicial e final das mensagens, permitindo a transferência de mensagens de diferentes fontes para diferentes destinos. Por exemplo: JMS -> JSON, HTTP -> JMS ou FTP de funil -> JMS, HTTP -> JMS, JSON -> JMS

A Wikipedia diz:

O Apache Camel é um mecanismo de roteamento e mediação baseado em regras que fornece uma implementação baseada em objetos Java do Enterprise Integration Patterns usando uma API (ou Java Domain Specific Language declarativa) para configurar regras de roteamento e mediação. A linguagem específica do domínio significa que o Apache Camel pode suportar a conclusão inteligente e segura de regras de roteamento no seu IDE usando código Java regular, sem grandes quantidades de arquivos de configuração XML; embora a configuração XML dentro do Spring também seja suportada.

Vejo? Isso não foi difícil, foi?

Em resumo:

Quando houver um requisito para conectar / integrar sistemas, você provavelmente precisará se conectar a alguma fonte de dados e processá-los para atender aos seus requisitos de negócios.

A fim de fazer isso:

1) Você poderia desenvolver um programa personalizado que o faria (pode ser demorado e difícil de entender, manter para outro desenvolvedor)

2) Como alternativa, você pode usar o Apache Camel para fazê-lo de maneira padronizada (ele tem a maioria dos conectores já desenvolvidos para você, basta configurá-lo e conectar sua lógica - chamada Processo):

Camel irá ajudá-lo a:

1. Consumir dados de qualquer fonte / formato
2. Processar esses dados
3. Dados de saída para qualquer fonte / formato

Ao usar o Apache Camel, você facilitará a compreensão / manutenção / extensão do sistema para outro desenvolvedor.

O Apache Camel é desenvolvido com padrões de integração corporativa. Os padrões ajudam você a integrar sistemas de uma maneira boa :-)

Camel envia mensagens de A para B:

Por que toda uma estrutura para isso? Bem, e se você tiver:

• muitos remetentes e muitos receptores
• uma dúzia de protocolos ( ftp, http, jms, etc.)
• muitas regras complexas
  • Envie uma mensagem A apenas para os receptores A e B
  • Envie uma mensagem B para o Receptor C como XML , mas traduza -o parcialmente , aprimore -o (adicione metadados) e a condição SE X e envie-o também para o Receptor D, mas como CSV .

Então agora você precisa:

• traduzir entre protocolos
• cola componentes juntos
• definir rotas - o que vai aonde
• filtrar algumas coisas em alguns casos

Camel oferece o que você disse acima (e muito mais) imediatamente:

com uma linguagem DSL legal para você definir o quê e como:

  new DefaultCamelContext().addRoutes(new RouteBuilder() {
        public void configure() {
            from("jms:incomingMessages")
                    .choice() // start router rules
                    .when(header("CamelFileName")
                            .endsWith(".xml"))
                    .to("jms:xmlMessages")
                    .when(header("CamelFileName")
                            .endsWith(".csv"))
                    .to("ftp:csvMessages");
}

Veja também isto e isto e Camel in Action (como outros já disseram, um excelente livro!)

Um diagrama é melhor que milhares de descrições. Este diagrama ilustra a arquitetura do Camel.

BASEADO NA ANALOGIA

O roteamento baseado em camelo pode ser entendido com muita facilidade, colocando-se no lugar de um proprietário de uma companhia aérea (por exemplo: American Airlines, Jet Airways).

O objetivo de 'sua companhia aérea' é 'transportar' passageiros 'de uma' cidade 'para outra no mundo. Você usa aeronaves de diferentes 'empresas de aeronaves', como Boeing, Airbus, HAL para transportar passageiros.

A sua companhia aérea embarca passageiros usando os 'aeroportos' da cidade de e os deboard usando o aeroporto da cidade para. Um passageiro pode 'viajar' para várias cidades, mas em todos os lugares que eles precisam atravessar o aeroporto para viajar entre a aeronave da sua companhia aérea e a cidade.

Observe que um passageiro que "parte" da cidade está essencialmente "chegando" ao avião da sua companhia aérea. E um passageiro que 'chega' à cidade está partindo essencialmente da aeronave. Como estamos no lugar do proprietário da companhia aérea, o termo "passageiro de chegada" e "passageiro de partida" são revertidos de nossas noções convencionais, baseadas na perspectiva das cidades.

A mesma infraestrutura de 'aeroporto' de cada cidade é usada pelos passageiros 'de partida' e 'de chegada'. Um aeroporto fornece 'infraestrutura de partida' para passageiros que partem, que é diferente da 'infraestrutura de chegada' fornecida para os passageiros que chegam.

Os passageiros podem continuar fazendo o dia com suas atividades devido a várias 'comodidades' fornecidas pelas aeronaves dentro da aeronave durante a viagem.

Além disso, sua companhia aérea também oferece instalações de lounge para tratamentos especiais, como 'entender o idioma local' e ou prepará-lo para a 'viagem'.

Vamos substituir algumas palavras / frases usadas acima pelo seguinte:

sua companhia aérea: Apache Camel

Empresas de aeronaves: Mecanismos de transporte

aeronave da sua companhia aérea: o mecanismo de transporte subjacente do Apache Camel

transportar: rota

passageiros: mensagem;

cidade: sistema;

aeroporto: componente de camelo;

compreensão de idiomas locais: conversões de tipo;

partida: produção, produzido

chegando: consumindo, consumido

travel: roteado

amenidades: fornecidas

Depois de substituir as palavras, eis o que você obtém:

O objetivo do 'Apache Camel' é rotear 'mensagens' de um 'sistema' para outro no mundo. O Apache camel usa diferentes mecanismos de transporte para o roteamento de mensagens.

O Apache Camel pega as mensagens usando o 'Componente baseado em camelo' do sistema 'de' e as elimina usando o 'Componente baseado em camelo' do sistema 'para'. Uma mensagem pode rotear para vários sistemas, mas em todos os lugares eles precisam passar por 'Componentes baseados em Camel' para viajar entre o 'Mecanismo de transporte subjacente do Apache Camel' e o sistema.

Observe que uma mensagem 'produzida' do sistema é essencialmente 'consumida' no mecanismo de transporte subjacente do Apache Camel '. E uma mensagem consumida por um sistema é essencialmente produzida pelo 'mecanismo de transporte subjacente do Apache Camel'.

Já que estamos tentando entender Camel, devemos pensar da perspectiva de Camel aqui em diante. O significado dos termos 'mensagem do consumidor' e 'mensagem do produtor' é, portanto, revertido de nossas noções convencionais, baseadas na perspectiva de um sistema.

A mesma infraestrutura de codificação do 'Componente baseado em camelo' é usada por 'mensagem do produtor' e 'mensagem do consumidor'. Um 'Componente baseado em camelo' fornece um 'ponto final do produtor' para 'mensagem do produtor' e um 'ponto final do consumidor' para 'mensagem do consumidor'.

As mensagens podem ser processadas pelo Camel quando estão sendo roteadas.

Além disso, o Camel oferece recursos especiais como 'Conversão de tipo' e muito mais ...

Uma das coisas que você precisa entender, antes de tentar entender o Apache Camel, são os Padrões de integração corporativa. Nem todo mundo no campo está realmente ciente deles. Embora você possa certamente ler o livro Enterprise Integration Patterns, uma maneira mais rápida de se familiarizar com eles seria ler algo como o artigo da Wikipedia sobre Enterprise Application Integration .

Se você leu e entendeu a área de assunto, seria muito mais provável que entendesse o propósito do Apache Camel

HTH

Se você conhece os Padrões de integração corporativa, o Apache Camel é uma estrutura de integração que implementa todos os EIPs.

E você pode implantar o Camel como um aplicativo independente em um contêiner da web.

Basicamente, se você precisar integrar vários aplicativos com diferentes protocolos e tecnologias, poderá usar o Camel.

Uma definição de outra perspectiva:

O Apache Camel é uma estrutura de integração. Consiste em algumas bibliotecas Java, o que ajuda a implementar problemas de integração na plataforma Java. O que isso significa e como difere das APIs, por um lado, e de um ESB (Enterprise Service Bus), por outro lado, está descrito no meu artigo " Quando usar o Apache Camel ".

O que exatamente é isso?

O Apache Camel é uma estrutura de integração leve que implementa todos os padrões de Integração Corporativa. Você pode integrar facilmente diferentes aplicativos usando os padrões necessários.

Você pode usar Java, Spring XML, Scala ou Groovy. Quase todas as tecnologias que você pode imaginar estão disponíveis, por exemplo, HTTP, FTP, JMS, EJB, JPA, RMI, JMS, JMX, LDAP, Netty etc.

Dê uma olhada neste artigo e no artigo do padrão EIP

Como ele interage com um aplicativo escrito em Java?

O Camel usa uma linguagem específica de domínio Java ou DSL para criar rotas ou padrões de integração corporativa em uma variedade de linguagens específicas de domínio (DSL), conforme listado abaixo.

Java DSL - um DSL baseado em Java usando o estilo fluente do construtor.

A história do Enterprise Integration Pattern resolve esses conceitos:

Mensagem, ponto final, produtor, consumidor, roteamento, barramento, transformação e processo .

Veja este artigo de Anirban Konar para um dos casos de uso em tempo real.

É algo que acompanha o servidor?

Ele atua como uma ponte entre vários subsistemas corporativos.

É um programa independente?

O Apache Camel, uma estrutura de integração, integra diferentes aplicativos independentes.

A principal vantagem do Camel : você pode integrar diferentes aplicativos com diferentes tecnologias (e diferentes protocolos) usando os mesmos conceitos para cada integração.

A maioria das coisas "novas" da computação não são realmente novas, são apenas um invólucro misterioso em torno de algo que já é bem compreendido. Quando eles são difíceis de entender, geralmente é porque alguém decidiu inventar novos termos de idioma ou colonizar termos existentes para um propósito diferente (um bom exemplo disso é a reversão dos desenvolvedores do X do que "cliente" e "servidor" significam).

Camel é um wrapper / API baseado em Java para middleware entre aplicativos.

Middleware é um termo geral para software que fornece serviços de interpretação entre entidades que não compartilham um idioma ou tipos de dados comuns.

É o que Camel é, no fundo. Podemos detalhar a descrição, observando que ela fornece middleware do tipo EIP.

Ele não fornece o middleware em si, pois não pode saber os detalhes do que os aplicativos precisam se comunicar. Mas ele fornece a API para criar as partes invariantes desse middleware (criar um ponto inicial, criar um ponto final, criar condições para iniciar e terminar etc.)

Espero que ajude.

Aqui está outra tentativa.

Você sabe como existem / existem coisas como Webmethods, ICAN Seebeyond, Tibco BW, IBM Broker. Todos eles ajudaram com soluções de integração na empresa. Essas ferramentas são comumente conhecidas pelo nome de ferramentas Enterprise Application Integration (EAI).

Havia principalmente ferramentas de arrastar e soltar construídas com base nessas tecnologias e em partes você teria que escrever adaptadores em Java. Esse código do adaptador não foi testado ou possuía ferramentas / automação ruins em relação aos testes.

Assim como os padrões de design na programação, você possui padrões de Integração Corporativa para soluções de integração comuns. Eles ficaram famosos por um livro de mesmo nome de Gregor Hohpe e Bobby Woolf.

Embora seja possível implementar soluções de integração que usam um ou mais EIP, o Camel é uma tentativa de fazer isso em sua base de código usando XML, Java, Groovy ou Scala.

O Camel suporta todos os padrões de integração corporativa listados no livro por meio de seu rico DSL e mecanismo de roteamento.

Portanto, o Camel é um tecnoloy concorrente de outras ferramentas EAI com melhor suporte para testar seu código de integração. O código é conciso devido às linguagens específicas do domínio (DSLs). É legível até mesmo para usuários corporativos, é gratuito e o torna produtivo.

Existem muitas estruturas que nos facilitam a enviar mensagens e resolver problemas nas mensagens. Um desses produtos é o Apache Camel.

A maioria dos problemas comuns tem soluções comprovadas chamadas de padrões de design. O padrão de design para o sistema de mensagens é EIPs (Enterprise Integration Patterns), que é bem explicado aqui . O Apache camel nos ajuda a implementar nossa solução usando os EIPs.

A força de uma estrutura de integração é sua capacidade de nos facilitar através de EIPs ou outros padrões, número de transportes e componentes e facilidade de desenvolvimento em que o Apache camel está no topo da lista

Cada um dos Frameworks tem suas próprias vantagens Alguns dos recursos especiais do Apache camel são os seguintes.

1. Ele fornece a codificação para muitas DSLs, como Java DSL e Spring xml, que são populares.
2. Fácil de usar e simples de usar.
3. O Fuse IDE é um produto que ajuda você a codificar através da interface do usuário

Em inglês simples, o camelo realiza (muitas) coisas sem muito código da placa da caldeira.

Apenas para lhe dar uma perspectiva, o Java DSL fornecido abaixo criará um ponto de extremidade REST que poderá aceitar um XML que consiste em Lista de produtos e o divide em vários produtos e invocará o método Process do BrandProcessor. E apenas adicionando .parallelProcessing (observe a parte comentada), ele processará paralelamente todos os Objetos de Produto. (A classe do produto é o stub Java gerado pelo JAXB / XJC a partir do XSD ao qual o xml de entrada está confinado.) Esse código (junto com poucas dependências do Camel) realizará o trabalho que costumava levar centenas de linhas de código Java.

from("servlet:item-delta?matchOnUriPrefix=true&httpMethodRestrict=POST")
.split(stax(Product.class))
/*.parallelProcessing()*/
.process(itemDeltaProcessor);

Depois de adicionar o ID da rota e a instrução de log

from("servlet:item-delta?matchOnUriPrefix=true&httpMethodRestrict=POST")
.routeId("Item-DeltaRESTRoute")
.log(LoggingLevel.INFO, "Item Delta received on Item-DeltaRESTRoute")
.split(stax(Product.class))
.parallelProcessing()
.process(itemDeltaProcessor);

Esta é apenas uma amostra, o Camel é muito mais do que apenas o ponto final REST. Basta dar uma olhada na lista de componentes conectáveis http://camel.apache.org/components.html

Camel ajuda no roteamento, transformação, monitoramento.

Ele usa rotas; que pode ser descrito como:

Quando o barramento de serviço recebe uma mensagem específica, ele o encaminha por meio de destinos de serviços / intermediários, como fila / tópicos. Esse caminho é conhecido como rota.

Exemplo: seu aplicativo de estoque recebeu alguma entrada do analista, será processado através do componente de aplicativo / web e o resultado será publicado para todos os membros interessados ​​/ registrados para atualização específica de estoque.

Suponha que você crie uma empresa de comércio eletrônico como a Amazon e deseje se concentrar apenas na estratégia / escolha de produtos para vender. diferentemente da frota de entrega da amazon, em vez de lidar com a movimentação de mercadorias dos vendedores para o armazém, faça alterações no armazém, como embalagens e enviá-las para outras cidades e clientes. Você contrata uma empresa que faz tudo isso e fornece informações sobre todos os locais de seu armazém, tipos de veículos, locais de entrega e uma lista de quando fazer o que. Então eles lidam com isso sozinhos, isso seria Apache Camel. Eles cuidam de mover as coisas de um lado para o outro, uma vez que você entrega coisas a eles, para que você fique livre para se concentrar em outras coisas.

101 Word Intro

Camel é uma estrutura com uma API consistente e um modelo de programação para integrar aplicativos juntos. A API é baseada em teorias em Padrões de integração corporativa - ou seja, vários padrões de design que tendem a usar mensagens. Ele fornece implementações prontas para uso na maioria desses padrões e é fornecido com mais de 200 componentes diferentes , que você pode usar para conversar facilmente com todos os tipos de outros sistemas. Para usar o Camel, primeiro escreva sua lógica de negócios em POJOs e implemente interfaces simples centradas em mensagens. Em seguida, use o DSL do Camel para criar "Rotas", que são conjuntos de regras para colar seu aplicativo.

Introdução estendida

Na superfície, a funcionalidade do Camel rivaliza com os produtos tradicionais do Enterprise Service Bus. Normalmente, pensamos em um Camel Route como um componente de "mediação" (também conhecido como orquestração) que mora no lado do servidor, mas como é uma biblioteca Java, é fácil de incorporar e também pode viver em um aplicativo do lado do cliente, além de ajudá-lo a integrar com serviços ponto a ponto (também conhecido como coreografia). Você pode até levar seus POJOs que processam as mensagens dentro da rota Camel e transformá-las facilmente em seus próprios processos remotos de consumo, por exemplo, se você precisar escalar apenas uma peça independentemente. Você pode usar o Camel para conectar rotas ou processadores através de qualquer número de protocolos / transportes remotos diferentes, dependendo de suas necessidades. Você precisa de um protocolo binário extremamente eficiente e rápido, ou um que seja mais legível por humanos e fácil de depurar? E se você quisesse mudar? Com o Camel, geralmente é tão fácil quanto alterar uma linha ou duas no seu percurso e não alterar nenhuma lógica comercial. Ou você pode oferecer suporte a ambos - você é livre para executar várias rotas ao mesmo tempo em um contexto de camelo.

Você realmente não precisa usar o Camel para aplicativos simples que viverão em um único processo ou JVM - seria um exagero. Mas não é conceitualmente mais difícil do que o código que você pode escrever. E se seus requisitos forem alterados, a separação da lógica comercial e do código de cola facilita a manutenção ao longo do tempo. Depois de aprender a API do Camel, é fácil usá-lo como um canivete suíço e aplicá-lo rapidamente em muitos contextos diferentes para reduzir a quantidade de código personalizado que você teria que escrever. Você pode aprender um sabor - o Java DSL, por exemplo, uma API fluente que é fácil de encadear - e pegar os outros sabores facilmente.

No geral, o Camel é uma ótima opção se você estiver tentando fazer microsserviços. Eu achei isso inestimável para a arquitetura evolutiva, porque você pode adiar muitas decisões difíceis e "fáceis de errar" sobre protocolos, transportes e outros problemas de integração de sistemas até que você saiba mais sobre o domínio do problema. Concentre-se apenas nos seus EIPs e na lógica de negócios principal e mude para novas rotas com os componentes "certos" à medida que aprender mais.

Sim, provavelmente é um pouco tarde. Mas uma coisa a acrescentar aos comentários de todos os outros é que, o Camel é na verdade uma caixa de ferramentas, e não um conjunto completo de recursos. Você deve ter isso em mente ao desenvolver e precisa fazer várias transformações e conversões de protocolo.

O próprio Camel depende de outras estruturas e, portanto, às vezes você precisa entendê-las para entender qual é o mais adequado para suas necessidades. Por exemplo, existem várias maneiras de lidar com o REST. Isso pode ficar um pouco confuso no começo, mas assim que você começar a usar e testar, ficará à vontade e seu conhecimento dos diferentes conceitos aumentará.

O Apache Camel é uma estrutura Java para integração corporativa. Por exemplo: - se você estiver construindo um aplicativo da web que interaja com muitas APIs de fornecedores, podemos usar o camel como ferramenta de integração externa. Podemos fazer mais com isso com base no caso de uso. Camel in Action das publicações Manning é um ótimo livro para aprender Camel. As integrações podem ser definidas como abaixo.

Java DSL

from("jetty://0.0.0.0:8080/searchProduct").routeId("searchProduct.products").threads()
    .log(LoggingLevel.INFO, "searchProducts request Received with body: ${body}")
    .bean(Processor.class, "createSearchProductsRequest").removeHeaders("CamelHttp*")
    .setHeader(Exchange.HTTP_METHOD, constant(org.apache.camel.component.http4.HttpMethods.POST))
    .to("http4://" + preLiveBaseAPI + searchProductsUrl + "?apiKey=" + ApiKey
                    + "&bridgeEndpoint=true")
    .bean(Processor.class, "buildResponse").log(LoggingLevel.INFO, "Search products finished");

Isso é apenas para criar um terminal de API REST que, por sua vez, chama uma API externa e envia a solicitação de volta

Spring DSL

<route id="GROUPS-SHOW">
    <from uri="jetty://0.0.0.0:8080/showGroups" />
    <log loggingLevel="INFO" message="Reqeust receviced service to fetch groups -> ${body}" />
    <to uri="direct:auditLog" />
    <process ref="TestProcessor" />
</route>

Chegando às suas perguntas

1. O que exatamente é isso? Resp: - É uma estrutura que implementa padrões de integração da empresa
2. Como ele interage com um aplicativo escrito em Java? Resp: - ele pode interagir com quaisquer protocolos disponíveis, como http, ftp, amqp etc.
3. É algo que acompanha o servidor? Resp: - Ele pode ser implantado em um contêiner como o tomcat ou pode ser implantado independentemente como um processo java
4. É um programa independente? Resp: - Pode ser.

Espero que ajude

O Apache Camel é uma estrutura de integração leve que implementa todos os padrões de integração corporativa. Você pode integrar facilmente diferentes aplicativos usando os padrões necessários. Você pode usar Java, Spring XML, Scala ou Groovy.

O Apache Camel é executado na Java Virtual Machine (JVM). ... A principal funcionalidade do Apache Camel é seu mecanismo de roteamento. Aloca mensagens com base nas rotas relacionadas. Uma rota contém lógica de fluxo e integração. É implementado usando EIPs e uma DSL específica.

É como um oleoduto conectando

From---->To

Entre você pode adicionar quantos canais e pipes. A torneira pode ser de qualquer tipo automático ou manual para fluxo de dados e uma rota para canalizar o fluxo.

Ele suporta e tem implementação para todos os tipos e tipos de processamento. E para o mesmo processamento, muitas abordagens, pois possui muitos componentes e cada componente também pode fornecer a saída desejada usando métodos diferentes.

Por exemplo, a transferência de arquivos pode ser feita em camelo com tipos de arquivos movidos ou copiados e também da pasta, servidor ou fila.

-from-->To
   - from-->process-->to
   - from-->bean-->to
   - from-->process-->bean-->to
   -from-->marshal-->process-->unmarshal-->to

Da / para ---- pasta, direta, seda, vm pode ser qualquer coisa

Outro ponto de vista (baseado em tópicos matemáticos mais fundamentais)

A plataforma de computação mais geral é uma [ https://en.wikipedia.org/wiki/Turing_machine]

Há um problema com a máquina de Turing. Todos os dados de entrada / saída permanecem dentro da máquina de turing. No mundo real, existem fontes de entrada e sumidouros de saída externos à nossa máquina de Turing e, em geral, governados por sistemas fora de nosso controle. Ou seja, esses sistemas externos enviarão / receberão dados à vontade, em qualquer formato, com qualquer agendador de dados desejado.

Pergunta: Como conseguimos fazer com que as máquinas de turing independentes se comuniquem da maneira mais geral, para que cada máquina de turing veja seus pares como uma fonte de dados de entrada ou um coletor de dados de saída?

Resposta: Usando algo como camel, mule, BizTalk ou qualquer outro ESB que abstraia o tratamento de dados entre a conclusão de máquinas de turing distintas "físicas" (ou software virtual).