Non capisco cosa faccia esattamente Camel .

Se potessi dare in 101 parole un'introduzione a Camel:

• Che cosa è esattamente?
• Come interagisce con un'applicazione scritta in Java?
• È qualcosa che va di pari passo con il server?
• È un programma indipendente?

Per favore, spiega cos'è Camel.

Se hai dai 5 ai 10 minuti, di solito consiglio alle persone di leggere questa integrazione con Apache Camel di Jonathan Anstey. È un pezzo ben scritto che offre una breve introduzione e una panoramica di alcuni concetti di Camel e implementa un caso d'uso con esempi di codice. In esso, Jonathan scrive:

Apache Camel è un framework Java open source che si concentra sul rendere l'integrazione più facile e più accessibile agli sviluppatori. Lo fa fornendo:

• implementazioni concrete di tutti i modelli di integrazione aziendale (EIP) ampiamente utilizzati
• connettività a una grande varietà di trasporti e API
• DSL (Domain Specific Languages) facili da usare per collegare EIP e trasporti insieme

C'è anche un capitolo gratuito di Camel in Action che introduce Camel nel primo capitolo. Jonathan è coautore di quel libro con me.

La mia opinione per descriverlo in un modo più accessibile ...

Per capire cos'è Apache Camel, devi capire quali sono i modelli di integrazione aziendale.

Cominciamo con quello che presumibilmente già sappiamo: il modello Singleton, il modello Factory, ecc; Sono semplicemente modi di organizzare la tua soluzione al problema, ma non sono soluzioni stesse. Questi modelli sono stati analizzati ed estratti per il resto di noi dalla Banda dei Quattro, quando hanno pubblicato il loro libro: Design Patterns . Hanno risparmiato ad alcuni di noi enormi sforzi nel pensare a come strutturare al meglio il nostro codice.

Proprio come Gang of Four, Gregor Hohpe e Bobby Woolf hanno scritto il libro Enterprise Integration Patterns (EIP) in cui propongono e documentano una serie di nuovi modelli e schemi per come progettare al meglio sistemi basati su componenti di grandi dimensioni, in cui i componenti possono essere in esecuzione sullo stesso processo o su una macchina diversa.

Sostanzialmente propongono di strutturare il nostro sistema in modo che sia orientato ai messaggi , in cui i componenti comunicano tra loro usando i messaggi come input e output e nient'altro. Ci mostrano una serie completa di modelli che possiamo scegliere e implementare nei nostri diversi componenti che formeranno insieme l'intero sistema.

Allora, cos'è Apache Camel?

Apache Camel ti offre le interfacce per gli EIP, gli oggetti base, le implementazioni comunemente necessarie, gli strumenti di debug, un sistema di configurazione e molti altri aiutanti che ti faranno risparmiare un sacco di tempo quando vuoi implementare la tua soluzione per seguire gli EIP.

Prendi MVC. MVC è piuttosto semplice in teoria e potremmo implementarlo senza alcun aiuto di quadro. Ma i buoni framework MVC ci forniscono la struttura pronta per l'uso e hanno fatto il possibile e hanno pensato a tutte le altre cose "secondarie" di cui hai bisogno quando crei un grande progetto MVC ed è per questo che le usiamo la maggior parte del tempo.

Questo è esattamente ciò che Apache Camel è per gli EIP. È un framework completo pronto per la produzione per le persone che vogliono implementare la propria soluzione per seguire gli EIP.

La creazione di una descrizione del progetto non dovrebbe essere complicata.

Dico:

Apache Camel è la tecnologia di messaggistica colla con routing. Unisce i punti di inizio e fine della messaggistica consentendo il trasferimento di messaggi da fonti diverse a destinazioni diverse. Ad esempio: JMS -> JSON, HTTP -> JMS o incanalamento FTP -> JMS, HTTP -> JMS, JSON -> JMS

Wikipedia dice:

Apache Camel è un motore di routing e mediazione basato su regole che fornisce un'implementazione basata su oggetti Java degli Enterprise Integration Patterns utilizzando un'API (o un linguaggio specifico del dominio Java dichiarativo) per configurare le regole di routing e mediazione. Il linguaggio specifico del dominio significa che Apache Camel può supportare il completamento intelligente di tipo sicuro delle regole di routing nel tuo IDE utilizzando il normale codice Java senza enormi quantità di file di configurazione XML; sebbene sia supportata anche la configurazione XML all'interno di Spring.

Vedere? Non è stato difficile, vero?

In breve:

Quando è necessario connettere / integrare i sistemi, sarà probabilmente necessario connettersi ad alcune origini dati e quindi elaborare questi dati per soddisfare i requisiti aziendali.

Per fare ciò:

1) Potresti sviluppare un programma personalizzato che lo farebbe (potrebbe richiedere molto tempo e difficile da capire, mantenere per altri sviluppatori)

2) In alternativa, potresti usare Apache Camel per farlo in modo standard (ha la maggior parte dei connettori già sviluppati per te, devi solo configurarlo e collegare la tua logica - chiamata Process):

Camel ti aiuterà a:

1. Consuma dati da qualsiasi fonte / formato
2. Elabora questi dati
3. Invia dati a qualsiasi fonte / formato

Usando Apache Camel renderai più semplice comprendere / mantenere / estendere il tuo sistema a un altro sviluppatore.

Apache Camel è sviluppato con Enterprise Integration Patterns. I modelli ti aiutano a integrare i sistemi in modo positivo :-)

Il cammello invia messaggi da A a B:

Perché un intero quadro per questo? Bene, se avessi:

• molti mittenti e molti ricevitori
• una dozzina di protocolli ( ftp, http, jms, etc.)
• molte regole complesse
  • Invia un messaggio A solo ai ricevitori A e B.
  • Invia un messaggio B a Ricevitore C in formato XML , ma in parte tradurlo esso, arricchire esso (metadati add) e IF condizione X , poi inviarlo al ricevitore D anche, ma in formato CSV .

Quindi ora hai bisogno di:

• tradurre tra i protocolli
• incollare i componenti insieme
• definire le rotte - cosa va dove
• filtrare alcune cose in alcuni casi

Camel ti dà quanto sopra (e altro) fuori dalla scatola:

con un linguaggio DSL interessante per definire cosa e come:

  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");
}

Vedi anche questo e questo e Camel in Action (come altri hanno già detto, un libro eccellente!)

Un diagramma è migliore di migliaia di descrizioni. Questo diagramma illustra l'architettura del cammello.

BASATO SULL'ANALOGIA

Il percorso basato sul cammello può essere compreso molto facilmente mettendosi nei panni di un proprietario di una compagnia aerea (ad es .: American Airlines, Jet Airways).

Lo scopo della "tua compagnia aerea" è quello di "trasportare" "passeggeri" da una "città" a un'altra nel mondo. Utilizzi velivoli di diverse "compagnie aeree" come Boeing, Airbus, HAL per trasportare passeggeri.

La tua compagnia aerea si imbarca sui passeggeri che utilizzano gli "aeroporti" della città e li imbarca utilizzando l'aeroporto della città. Un passeggero può "viaggiare" in più città, ma ovunque deve attraversare l'aeroporto per viaggiare tra l'aeromobile della tua compagnia aerea e la città.

Nota che un passeggero che "parte" dalla città essenzialmente sta "arrivando" sull'aeromobile delle tue compagnie aeree. E un passeger che "arriva" in città, sta essenzialmente partendo dall'aereo. Dato che siamo nei panni del proprietario della compagnia aerea, i termini "passeggero in arrivo" e "passeggero in partenza" sono invertiti dalle nostre nozioni convenzionali basate sulla prospettiva della città.

La stessa infrastruttura "aeroportuale" di ogni città viene utilizzata dai passeggeri "in partenza" e dai passeggeri "in arrivo". Un aeroporto fornisce "infrastrutture di partenza" per i passeggeri in partenza, che è diverso dall'infrastruttura di arrivo prevista per i passeggeri in arrivo.

I passeggeri possono continuare a svolgere le loro attività quotidiane grazie ai vari "servizi" forniti all'interno dell'aeromobile dalle compagnie aeree durante il viaggio.

Inoltre, la tua compagnia aerea offre anche servizi lounge per trattamenti speciali come "comprendere la lingua locale" o prepararti per il "viaggio".

Sostituiamo alcune parole / frasi usate sopra con le seguenti:

la tua compagnia aerea: Apache Camel

compagnie aeree: meccanismi di trasporto

l'aereo della tua compagnia aerea: il meccanismo di trasporto sottostante di Apache Camel

carry: route

passeggeri: messaggio;

città: sistema;

aeroporto: Camel Component;

comprensione delle lingue locali: conversioni di tipo;

in partenza: produzione, produzione

in arrivo: consumando, consumato

viaggio: in rotta

servizi: fornito

Dopo aver sostituito le parole, ecco cosa ottieni:

Lo scopo di "Apache Camel" è di instradare i "messaggi" da un "sistema" a un altro nel mondo. Apache Camel utilizza diversi meccanismi di trasporto per l'instradamento dei messaggi.

Apache Camel raccoglie i messaggi utilizzando 'Componente basato su cammello' del sistema 'da' e li rilascia utilizzando il 'Componente basato su cammello' del sistema 'a'. Un messaggio può essere indirizzato a più sistemi, ma ovunque debbano passare attraverso i "Componenti basati su cammello" per viaggiare tra "il meccanismo di trasporto sottostante di Apache Camel" e il sistema.

Si noti che un messaggio "prodotto" dal sistema viene essenzialmente "consumato" nel meccanismo di trasporto sottostante di Apache Camel. E un messaggio consumato da un sistema, è essenzialmente prodotto dal "meccanismo di trasporto sottostante di Apache Camel".

Dal momento che stiamo cercando di capire Camel, dobbiamo pensare dalla prospettiva di Camel qui in avanti. Il significato dei termini "messaggio del consumatore" e "messaggio del produttore" è quindi invertito dalle nostre nozioni convenzionali che si basano sulla prospettiva di un sistema.

La stessa infrastruttura di codifica "Componente basato su cammello" viene utilizzata da "messaggio del produttore" e "messaggio del consumatore". Un 'Componente basato su cammello' fornisce un 'endpoint produttore' per 'messaggio produttore' e un 'endpoint consumatore' per 'messaggio consumatore'.

I messaggi possono essere elaborati da Camel quando vengono instradati.

Oltre a questo percorso, Camel offre funzioni speciali come "Conversione del tipo" e molte altre ...

Una delle cose che devi capire, prima di provare a capire Apache Camel, sono i modelli di integrazione aziendale. Non tutti nel campo ne sono effettivamente consapevoli. Mentre puoi certamente leggere il libro Modelli di integrazione aziendale, un modo più rapido per aggiornarli sarebbe leggere qualcosa come l'articolo di Wikipedia sull'integrazione delle applicazioni aziendali .

Uno che hai letto e compreso l'area tematica, sarebbe molto più probabile che tu capisca lo scopo di Apache Camel

HTH

Se sei a conoscenza dei modelli di integrazione aziendale, Apache Camel è un framework di integrazione che implementa tutti gli EIP.

E puoi distribuire Camel come applicazione autonoma in un contenitore web.

Fondamentalmente, se devi integrare diverse applicazioni con protocolli e tecnologie diverse, puoi usare Camel.

Una definizione da un'altra prospettiva:

Apache Camel è un framework di integrazione. È composto da alcune librerie Java, che ti aiutano a implementare problemi di integrazione sulla piattaforma Java. Cosa significa e come differisce dalle API da un lato e da un Enterprise Service Bus (ESB) dall'altro lato è descritto nel mio articolo " Quando usare Apache Camel ".

Che cosa è esattamente?

Apache Camel è un framework di integrazione leggero che implementa tutti i modelli di integrazione aziendale. È possibile integrare facilmente diverse applicazioni utilizzando i modelli richiesti.

Puoi usare Java, Spring XML, Scala o Groovy. Quasi tutte le tecnologie che puoi immaginare sono disponibili, ad esempio HTTP, FTP, JMS, EJB, JPA, RMI, JMS, JMX, LDAP, Netty ecc.

Dai un'occhiata a questo articolo e all'articolo modello EIP

Come interagisce con un'applicazione scritta in Java?

Camel utilizza un linguaggio specifico del dominio Java o DSL per creare modelli o percorsi di integrazione aziendale in una varietà di linguaggi specifici del dominio (DSL) elencati di seguito.

DSL Java : un DSL basato su Java che utilizza lo stile del builder fluente.

La storia di Enterprise Integration Pattern si risolve attorno a questi concetti:

Messaggio, punto finale, produttore, consumatore, routing, bus, trasformazione e processo .

Dai un'occhiata a questo articolo di Anirban Konar per uno dei casi d'uso in tempo reale.

È qualcosa che va di pari passo con il server?

Funziona come un ponte tra più sottosistemi aziendali.

È un programma indipendente?

Apache Camel, un framework di integrazione, integra diverse applicazioni indipendenti.

Il vantaggio principale di Camel : è possibile integrare diverse applicazioni con tecnologie diverse (e protocolli diversi) utilizzando gli stessi concetti per ogni integrazione.

La maggior parte delle cose "nuove" nell'informatica non sono affatto nuove, sono solo un involucro mistificante attorno a qualcosa che è già ben compreso. Quando sono difficili da capire, di solito è perché qualcuno ha deciso di inventare nuovi termini linguistici o di colonizzare i termini esistenti per uno scopo diverso (un buon esempio di ciò è l'inversione da parte degli sviluppatori X di cosa significano "client" e "server").

Camel è un wrapper / API basato su Java per middleware tra applicazioni.

Middleware è un termine generale per software che fornisce servizi di interpretazione tra entità che non condividono un linguaggio comune o tipi di dati.

Questo è Camel, in fondo. Possiamo approfondire la descrizione osservando che fornisce un middleware di tipo EIP.

Non fornisce il middleware stesso, poiché non è in grado di conoscere i dettagli di ciò che le applicazioni devono comunicare. Ma fornisce l'API per la creazione delle parti invarianti di quel middleware (creare un punto iniziale, creare un punto finale, creare condizioni per l'inizio e la fine, ecc.)

Spero che aiuti.

Ecco un altro tentativo.

Sai come ci sono / erano cose come Webmethods, ICAN Seebeyond, Tibco BW, IBM Broker. Tutti hanno aiutato con le soluzioni di integrazione nell'azienda. Questi strumenti sono comunemente noti con il nome di strumenti Enterprise Application Integration (EAI).

Esistono principalmente strumenti di trascinamento della selezione costruiti attorno a queste tecnologie e in alcune parti dovresti scrivere adattatori in Java. Questi codici dell'adattatore non erano stati testati o presentavano scarsi strumenti / automazione durante i test.

Proprio come con i modelli di progettazione nella programmazione, hai modelli di integrazione aziendale per soluzioni di integrazione comuni. Furono resi famosi da un libro omonimo di Gregor Hohpe e Bobby Woolf.

Sebbene sia del tutto possibile implementare soluzioni di integrazione che utilizzano uno o più EIP, Camel è un tentativo di farlo all'interno della tua base di codice usando uno di XML, Java, Groovy o Scala.

Camel supporta tutti i modelli di integrazione aziendale elencati nel libro attraverso il suo ricco meccanismo DSL e di routing.

Quindi Camel è una tecnologia competitiva rispetto ad altri strumenti EAI con un supporto migliore per testare il tuo codice di integrazione. Il codice è conciso a causa delle lingue specifiche del dominio (DSL). È leggibile anche dagli utenti aziendali, è gratuito e ti rende produttivo.

Esistono molti framework che ci facilitano la messaggistica e la risoluzione dei problemi di messaggistica. Uno di questi prodotti è Apache Camel.

La maggior parte dei problemi comuni ha soluzioni comprovate chiamate come modelli di progettazione. Il modello di progettazione per la messaggistica è il modello di integrazione aziendale (EIP), che è ben spiegato qui . Apache Camel ci aiuta a implementare la nostra soluzione utilizzando gli EIP.

Il punto di forza di un framework di integrazione è la sua capacità di facilitarci attraverso EIP o altri modelli, numero di trasporti e componenti e facilità di sviluppo su cui Apache Camel si trova in cima alla lista

Ciascuno dei Frameworks ha i suoi vantaggi Alcune delle caratteristiche speciali del cammello Apache sono le seguenti.

1. Fornisce la codifica in molti DSL, ovvero Java DSL e DSL basati su Spring XML, che sono molto popolari.
2. Facile da usare e semplice da usare.
3. Fuse IDE è un prodotto che ti aiuta a programmare attraverso l'interfaccia utente

In parole povere, il cammello fa (molte) cose senza gran parte del codice della piastra della caldaia.

Giusto per darvi una prospettiva, il DSL Java riportato di seguito creerà un endpoint REST che sarà in grado di accettare un XML costituito da un elenco di prodotti e di suddividerlo in più prodotti e invocare il metodo di processo di BrandProcessor con esso. E semplicemente aggiungendo .parallelProcessing (notare la parte commentata) elaborerà in parallelo tutti gli oggetti prodotto. (La classe di prodotto è lo stub Java generato da JAXB / XJC dall'XSD a cui è limitato l'xml di input.) Questo codice (insieme a poche dipendenze di Camel) eseguirà il lavoro che in passato richiedeva centinaia di righe di codice Java.

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

Dopo aver aggiunto l'ID percorso e l'istruzione di registrazione

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);

Questo è solo un esempio, Camel è molto più di un semplice end point REST. Dai un'occhiata all'elenco dei componenti collegabili http://camel.apache.org/components.html

Camel aiuta nel routing, trasformazione, monitoraggio.

Usa le rotte; che può essere descritto come:

Quando il bus di servizio riceve un messaggio particolare, lo instraderà attraverso nessuna delle destinazioni di servizi / broker come coda / argomenti. Questo percorso è noto come route.

Esempio: l'applicazione di magazzino ha ricevuto input dall'analista, verrà elaborata tramite il componente applicazione / web e quindi il risultato sarà pubblicato a tutti gli utenti interessati / registrati per un particolare aggiornamento dello stock.

Supponi di creare un'azienda di e-commerce come Amazon e desideri concentrarti solo sulla strategia / scelta dei prodotti da vendere. a differenza della flotta di consegna di Amazon, invece di gestire te stesso lo spostamento delle merci dai venditori al magazzino, apportandole modifiche in magazzino come imballaggi e inviandole ad altre città e clienti. Assumi un'azienda che fa tutto questo e fornisci loro informazioni su tutte le posizioni del tuo magazzino, i tipi di veicoli, i luoghi di consegna e un elenco di quando fare cosa. Quindi lo gestiscono da soli, sarebbe Apache Camel. Si occupano di spostare le cose da un'estremità all'altra, dopo aver consegnato loro le cose, in modo che tu sia libero di concentrarti su altre cose.

101 Word Intro

Camel è un framework con un'API coerente e un modello di programmazione per l'integrazione di applicazioni insieme. L'API si basa sulle teorie dei modelli di integrazione aziendale , vale a dire un mucchio di modelli di progettazione che tendono a utilizzare la messaggistica. Fornisce implementazioni immediate della maggior parte di questi modelli e inoltre viene fornito con oltre 200 diversi componenti è possibile utilizzare per parlare facilmente con tutti i tipi di altri sistemi. Per usare Camel, prima scrivi la tua logica di business nei POJO e implementa semplici interfacce centrate sui messaggi. Quindi utilizzare DSL di Camel per creare "Percorsi" che sono insiemi di regole per incollare insieme l'applicazione.

Introduzione estesa

In apparenza, la funzionalità di Camel rivaleggia con i tradizionali prodotti Enterprise Service Bus. Generalmente pensiamo che una Camel Route sia un componente di "mediazione" (aka orchestrazione) che vive sul lato server, ma poiché è una libreria Java è facile da incorporare e può vivere anche su un'app lato client e aiutarti a integrarti con servizi punto a punto (aka coreografia). Puoi persino prendere i tuoi POJO che elaborano i messaggi all'interno del percorso di Camel e trasformarli facilmente nei loro processi di consumo remoti, ad esempio se hai bisogno di ridimensionare un solo pezzo in modo indipendente. Puoi usare Camel per collegare rotte o processori attraverso un numero qualsiasi di protocolli / trasporti remoti diversi a seconda delle tue esigenze. Hai bisogno di un protocollo binario estremamente efficiente e veloce, o uno più leggibile dall'uomo e facile da eseguire il debug? E se volessi cambiare? Con Camel questo di solito è facile come cambiare una o due linee nel percorso e non cambiare alcuna logica aziendale. Oppure potresti supportare entrambi: sei libero di percorrere più percorsi contemporaneamente in un contesto cammello.

Non hai davvero bisogno di usare Camel per semplici applicazioni che vivranno in un singolo processo o JVM - sarebbe eccessivo. Ma concettualmente non è più difficile del codice che potresti scrivere da solo. E se le tue esigenze cambiano, la separazione tra logica di business e codice colla ne semplifica la manutenzione nel tempo. Dopo aver appreso l'API Camel, è facile usarlo come un coltellino svizzero e applicarlo rapidamente in molti contesti diversi per ridurre la quantità di codice personalizzato che altrimenti dovresti scrivere. Puoi imparare un sapore - il DSL Java, ad esempio, un'API fluente che è facile da mettere insieme - e raccogliere facilmente gli altri sapori.

Nel complesso Camel è perfetto se stai cercando di fare microservizi. L'ho trovato prezioso per l'architettura evolutiva, perché puoi rimandare molte decisioni difficili, "facili da sbagliare" su protocolli, trasporti e altri problemi di integrazione del sistema fino a quando non sai di più sul tuo dominio problematico. Concentrati sui tuoi EIP e sulla tua logica aziendale principale e passa a nuove rotte con i componenti "giusti" man mano che impari di più.

Sì, probabilmente è un po 'tardi. Ma una cosa da aggiungere ai commenti di tutti è che Camel è in realtà una cassetta degli attrezzi piuttosto che un set completo di funzionalità. Dovresti tenerlo a mente durante lo sviluppo e devi fare varie trasformazioni e conversioni di protocollo.

Lo stesso Camel si basa su altri framework e quindi a volte è necessario capirli anche per capire quale è più adatto alle proprie esigenze. Esistono diversi modi per gestire REST. All'inizio questo può creare un po 'di confusione, ma una volta che inizi a utilizzare e testare ti sentirai a tuo agio e la tua conoscenza dei diversi concetti aumenterà.

Apache Camel è un framework Java per l'integrazione aziendale. Ad esempio: - se stai creando un'applicazione web che interagisce con molte API del fornitore, possiamo usare il cammello come strumento di integrazione esterna. Possiamo fare di più con esso in base al caso d'uso. Camel in Action dalle pubblicazioni di Manning è un ottimo libro per l'apprendimento del cammello. Le integrazioni possono essere definite come di seguito.

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");

Questo serve solo a creare un endpoint API REST che a sua volta chiama un'API esterna e restituisce la richiesta

Primavera 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>

Venendo alle tue domande

1. Che cosa è esattamente? Risp .: - È un framework che implementa modelli di integrazione Enterprise
2. Come interagisce con un'applicazione scritta in Java? Risp .: - può interagire con tutti i protocolli disponibili come http, ftp, amqp ecc
3. È qualcosa che va di pari passo con il server? Risp .: - Può essere distribuito in un contenitore come Tomcat o può essere distribuito indipendentemente come processo Java
4. È un programma indipendente? Ans: - Può essere.

Spero che sia d'aiuto

Apache Camel è un framework di integrazione leggero che implementa tutti i modelli di integrazione aziendale. È possibile integrare facilmente diverse applicazioni utilizzando i modelli richiesti. Puoi usare Java, Spring XML, Scala o Groovy.

Apache Camel funziona su Java Virtual Machine (JVM). ... La funzionalità principale di Apache Camel è il suo motore di routing. Alloca i messaggi in base ai percorsi correlati. Una route contiene flusso e logica di integrazione. È implementato utilizzando EIP e un DSL specifico.

È come una tubazione che si collega

From---->To

Nel frattempo puoi aggiungere tanti canali e pipe. Il rubinetto può essere di qualsiasi tipo automatico o manuale per il flusso di dati e un percorso per canalizzare il flusso.

Supporta e ha implementazione per tutti i tipi e tipi di elaborazione. E per la stessa elaborazione molti approcci perché ha molti componenti e ogni componente può anche fornire l'output desiderato usando diversi metodi sotto di esso.

Ad esempio, il trasferimento di file può essere eseguito in cammello con tipi di file spostati o copiati e anche da cartella, server o coda.

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

Da / a ---- cartella, diretta, seda, vm può essere qualsiasi cosa

Un altro punto di vista (basato su argomenti matematici più fondamentali)

La piattaforma informatica più generale è un [ https://en.wikipedia.org/wiki/Turing_machine]

Si è verificato un problema con la macchina Turing. Tutti i dati di input / output rimangono all'interno della macchina turing. Nel mondo reale ci sono fonti di input e sink di output esterni alla nostra macchina Turing, e in generale regolati da sistemi al di fuori del nostro controllo. Cioè, quel sistema esterno invierà / riceverà i dati a piacimento in qualsiasi formato con qualsiasi programmatore di dati desiderato.

Domanda: Come riusciamo a far dialogare le macchine di scambio indipendenti nel modo più generale, in modo tale che ogni macchina di monitoraggio veda i propri pari come una fonte di dati di input o un pozzo di dati di output?

Risposta: Usando qualcosa come cammello, mulo, BizTalk o qualsiasi altro ESB che allontana la gestione dei dati tra il completamento di macchine di Turing distinte "fisiche" (o software virtuali).