Je ne comprends pas exactement ce que fait Camel .

Si vous pouviez donner en 101 mots une introduction à Camel:

• C'est quoi exactement?
• Comment interagit-il avec une application écrite en Java?
• Est-ce quelque chose qui va de pair avec le serveur?
• Est-ce un programme indépendant?

Veuillez expliquer ce qu'est Camel.

Si vous disposez de 5 à 10 minutes, je recommande généralement aux gens de lire cette intégration avec Apache Camel de Jonathan Anstey. C'est un article bien écrit qui donne une brève introduction et un aperçu de certains des concepts de Camel, et il implémente un cas d'utilisation avec des exemples de code. Dans ce document, Jonathan écrit:

Apache Camel est un framework Java open source qui vise à rendre l'intégration plus facile et plus accessible aux développeurs. Pour ce faire, il fournit:

• implémentations concrètes de tous les modèles d'intégration d'entreprise (EIP) largement utilisés
• connectivité à une grande variété de transports et d'API
• Langages spécifiques au domaine (DSL) faciles à utiliser pour connecter les EIP et les transports ensemble

Il y a aussi un chapitre gratuit de Camel in Action qui présente Camel dans le premier chapitre. Jonathan est co-auteur de ce livre avec moi.

Ma prise pour décrire cela d'une manière plus accessible ...

Pour comprendre ce qu'est Apache Camel, vous devez comprendre ce que sont les modèles d'intégration d'entreprise.

Commençons par ce que nous savons probablement déjà: le modèle Singleton, le modèle Factory, etc. Ce ne sont que des moyens d'organiser votre solution au problème, mais ce ne sont pas des solutions elles-mêmes. Ces modèles ont été analysés et extraits pour le reste d'entre nous par le Gang of Four, lorsqu'ils ont publié leur livre: Design Patterns . Ils ont épargné à certains d'entre nous des efforts considérables pour réfléchir à la meilleure façon de structurer notre code.

Tout comme le Gang of Four, Gregor Hohpe et Bobby Woolf sont les auteurs du livre Enterprise Integration Patterns (EIP) dans lequel ils proposent et documentent un ensemble de nouveaux modèles et de plans pour la meilleure façon de concevoir de grands systèmes basés sur des composants, où les composants peuvent être fonctionnant sur le même processus ou sur une machine différente.

Ils proposent essentiellement que nous structurions notre système pour qu'il soit orienté message - où les composants communiquent entre eux en utilisant des messages comme entrées et sorties et absolument rien d'autre. Ils nous montrent un ensemble complet de modèles que nous pouvons choisir et implémenter dans nos différents composants qui formeront ensemble le système entier.

Alors qu'est-ce qu'Apache Camel?

Apache Camel vous offre les interfaces pour les EIP, les objets de base, les implémentations couramment nécessaires, les outils de débogage, un système de configuration et de nombreux autres assistants qui vous feront gagner une tonne de temps lorsque vous souhaitez implémenter votre solution pour suivre les EIP.

Prenez MVC. MVC est assez simple en théorie et nous pourrions l'implémenter sans aucune aide du framework. Mais les bons frameworks MVC nous fournissent la structure prête à l'emploi et ont fait un effort supplémentaire et ont pensé à toutes les autres choses "secondaires" dont vous avez besoin lorsque vous créez un grand projet MVC et c'est pourquoi nous les utilisons la plupart du temps.

C'est exactement ce qu'est Apache Camel pour les EIP. Il s'agit d'un cadre complet prêt à la production pour les personnes qui souhaitent mettre en œuvre leur solution pour suivre les EIP.

La création d'une description de projet ne devrait pas être compliquée.

Je dis:

Apache Camel est une technologie de messagerie qui colle avec le routage. Il relie les points de début et de fin de la messagerie, permettant le transfert de messages de différentes sources vers différentes destinations. Par exemple: JMS -> JSON, HTTP -> JMS ou l'entonnoir FTP -> JMS, HTTP -> JMS, JSON -> JMS

Wikipédia dit:

Apache Camel est un moteur de routage et de médiation basé sur des règles qui fournit une implémentation basée sur des objets Java des modèles d'intégration d'entreprise à l'aide d'une API (ou d'un langage déclaratif spécifique au domaine Java) pour configurer les règles de routage et de médiation. Le langage spécifique au domaine signifie qu'Apache Camel peut prendre en charge l'achèvement intelligent de type sécurisé des règles de routage dans votre IDE en utilisant du code Java normal sans une énorme quantité de fichiers de configuration XML; bien que la configuration XML dans Spring soit également prise en charge.

Voir? Ce n'était pas difficile, n'est-ce pas?

En bref:

Lorsqu'il est nécessaire de connecter / intégrer des systèmes, vous devrez probablement vous connecter à une source de données, puis traiter ces données pour qu'elles correspondent aux besoins de votre entreprise.

Pour pouvoir faire ça:

1) Vous pourriez développer un programme personnalisé qui le ferait (pourrait être long et difficile à comprendre, à maintenir pour un autre développeur)

2) Alternativement, vous pouvez utiliser Apache Camel pour le faire de manière standardisée (il a la plupart des connecteurs déjà développés pour vous, il vous suffit de le configurer et de brancher votre logique - appelé Processus):

Chameau vous aidera à:

1. Consommer des données de n'importe quelle source / format
2. Traiter ces données
3. Sortie des données vers n'importe quelle source / format

En utilisant Apache Camel, vous faciliterez la compréhension / la maintenance / l'extension de votre système à un autre développeur.

Apache Camel est développé avec des modèles d'intégration d'entreprise. Les modèles vous aident à intégrer les systèmes dans le bon sens :-)

Camel envoie des messages de A à B:

Pourquoi tout un cadre pour cela? Et si vous avez:

• de nombreux expéditeurs et de nombreux récepteurs
• une douzaine de protocoles ( ftp, http, jms, etc.)
• de nombreuses règles complexes
  • Envoyer un message A aux récepteurs A et B uniquement
  • Envoyez un message B au récepteur C en XML , mais traduisez-le en partie , enrichissez- le (ajoutez des métadonnées) et la condition IF X , puis envoyez-le également au récepteur D, mais en CSV .

Alors maintenant, vous avez besoin de:

• traduire entre les protocoles
• la colle composants ensemble
• définir des itinéraires - ce qui va où
• filtrer certaines choses dans certains cas

Camel vous donne ce qui précède (et plus) hors de la boîte:

avec un langage DSL sympa pour que vous puissiez définir quoi et comment:

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

Voir aussi ceci et cela et Camel in Action (comme d'autres l'ont dit, un excellent livre!)

Un diagramme vaut mieux que des milliers de description. Ce diagramme illustre l'architecture de Camel.

BASÉ SUR L'ANALOGIE

Le routage à dos de chameau peut être compris très facilement en se mettant dans la peau d'un propriétaire de compagnie aérienne (par exemple: American Airlines, Jet Airways).

Le but de «votre compagnie aérienne» est de «transporter» des «passagers» d'une «ville» à une autre dans le monde. Vous utilisez des avions de différentes «compagnies aériennes» comme Boeing, Airbus, HAL pour transporter des passagers.

Votre compagnie aérienne embarque des passagers en utilisant les «aéroports» de la ville et les débarque en utilisant l'aéroport de la ville. Un passager peut «voyager» vers plusieurs villes, mais partout où il doit passer par l'aéroport pour voyager entre l'avion de votre compagnie aérienne et la ville.

Notez qu'un passager «partant» de la ville «essentiellement» arrive dans l'avion de votre compagnie aérienne. Et un passger «arrivant» dans la ville, quitte essentiellement l'avion. Puisque nous sommes dans la peau du propriétaire d'une compagnie aérienne, les termes «passager à l'arrivée» et «passager au départ» sont inversés par rapport à nos notions conventionnelles qui sont basées sur la perspective des villes.

La même infrastructure «aéroportuaire» de chaque ville est utilisée par les passagers «au départ» et «à l'arrivée». Un aéroport fournit une «infrastructure de départ» pour les passagers au départ, qui est différente de «l'infrastructure d'arrivée» prévue pour les passagers à l'arrivée.

Les passagers peuvent continuer à faire leur journée à leurs activités en raison de diverses «commodités» fournies à l'intérieur de l'avion par vos compagnies aériennes, tout en voyageant.

En plus de cela, votre compagnie aérienne propose également des salons pour des traitements spéciaux tels que «comprendre la langue locale» et / ou vous préparer au «voyage».

Permet de remplacer quelques mots / phrases utilisés ci-dessus par ce qui suit:

votre compagnie aérienne: Apache Camel

compagnies aériennes: mécanismes de transport

l'avion de votre compagnie aérienne: le mécanisme de transport sous-jacent d'Apache Camel

porter: route

passagers: message;

ville: système;

aéroport: Camel Component;

compréhension des langues locales: conversions de type;

départ: production, production

arrivant: consommer, consommé

voyage: en déroute

équipements: fournis

Après avoir remplacé les mots, voici ce que vous obtenez:

Le but de «Apache Camel» est d'acheminer les «messages» d'un «système» à un autre dans le monde. Apache camel utilise différents mécanismes de transport pour le routage des messages.

Apache Camel récupère les messages en utilisant le «composant basé sur Camel» du système «de» et les supprime en utilisant le «composant basé sur Camel» du système «vers». Un message peut être acheminé vers plusieurs systèmes, mais partout où ils doivent passer par des «composants basés sur Camel» pour voyager entre le «mécanisme de transport sous-jacent d'Apache Camel» et le système.

Notez qu'un message «produit» à partir du système est essentiellement «consommé» dans le mécanisme de transport sous-jacent d'Apache Camel ». Et un message consommé par un système, est essentiellement produit par le «mécanisme de transport sous-jacent d'Apache Camel».

Puisque nous essayons de comprendre Camel, nous devons penser du point de vue de Camel ici. La signification des termes «message du consommateur» et «message du producteur» est ainsi inversée par rapport à nos notions conventionnelles basées sur la perspective d'un système.

La même infrastructure de codage du «composant basé sur le chameau» est utilisée par le «message du producteur» et le «message du consommateur». Un «composant basé sur le chameau» fournit un «point de terminaison producteur» pour le «message producteur» et un «point final consommateur» pour le «message consommateur».

Les messages peuvent être traités par Camel lorsqu'ils sont acheminés.

En plus de ce routage, Camel fournit des fonctionnalités spéciales telles que la `` conversion de type '' et bien d'autres ...

Avant d’essayer de comprendre Apache Camel, vous devez comprendre les modèles d’intégration d’entreprise. Tout le monde sur le terrain n'en est pas réellement conscient. Bien que vous puissiez certainement lire le livre sur les modèles d'intégration d'entreprise, un moyen plus rapide de les mettre à jour serait de lire quelque chose comme l'article Wikipedia sur l' intégration des applications d'entreprise .

Une fois que vous avez lu et compris le sujet, vous seriez beaucoup plus susceptible de comprendre le but d'Apache Camel

HTH

Si vous connaissez les modèles d'intégration d'entreprise, Apache Camel est un cadre d'intégration qui implémente tous les EIP.

Et vous pouvez déployer Camel en tant qu'application autonome dans un conteneur Web.

Fondamentalement, si vous devez intégrer plusieurs applications avec différents protocoles et technologies, vous pouvez utiliser Camel.

Une définition sous un autre angle:

Apache Camel est un cadre d'intégration. Il se compose de quelques bibliothèques Java, qui vous aident à implémenter des problèmes d'intégration sur la plate-forme Java. Ce que cela signifie et en quoi il diffère des API d'un côté et d'un ESB (Enterprise Service Bus) de l'autre côté est décrit dans mon article " Quand utiliser Apache Camel ".

C'est quoi exactement?

Apache Camel est un cadre d'intégration léger qui implémente tous les modèles d'intégration d'entreprise. Vous pouvez facilement intégrer différentes applications en utilisant les modèles requis.

Vous pouvez utiliser Java, Spring XML, Scala ou Groovy. Presque toutes les technologies imaginables sont disponibles, par exemple HTTP, FTP, JMS, EJB, JPA, RMI, JMS, JMX, LDAP, Netty, etc.

Jetez un œil à cet article et à l'article sur les modèles EIP

Comment interagit-il avec une application écrite en Java?

Camel utilise un langage spécifique au domaine Java ou DSL pour créer des modèles ou des itinéraires d'intégration d'entreprise dans une variété de langages spécifiques au domaine (DSL), comme indiqué ci-dessous.

Java DSL - Un DSL basé sur Java utilisant le style de générateur fluide.

L'histoire du modèle d'intégration d'entreprise se résout autour de ces concepts:

Message, point final, producteur, consommateur, routage, bus, transformation et processus .

Jetez un œil à cet article d'Anirban Konar pour l'un des cas d'utilisation en temps réel.

Est-ce quelque chose qui va de pair avec le serveur?

Il agit comme un pont entre plusieurs sous-systèmes d'entreprise.

Est-ce un programme indépendant?

Apache Camel, un framework d'intégration, intègre différentes applications indépendantes.

Le principal avantage de Camel : vous pouvez intégrer différentes applications avec différentes technologies (et différents protocoles) en utilisant les mêmes concepts pour chaque intégration.

La plupart des "nouvelles" choses dans l'informatique ne sont pas vraiment nouvelles du tout, elles sont juste une enveloppe mystifiante autour de quelque chose qui est déjà bien compris. Quand ils sont difficiles à comprendre, c'est généralement parce que quelqu'un a décidé d'inventer de nouveaux termes linguistiques ou de coloniser des termes existants dans un but différent (un bon exemple de cela est l'inversion par les développeurs X de ce que "client" et "serveur" signifient).

Camel est un wrapper / API basé sur Java pour le middleware inter-applications.

Le middleware est un terme général pour un logiciel qui fournit des services d'interprétation entre des entités qui ne partagent pas une langue ou des types de données communs.

Voilà ce qu'est Camel, au fond. Nous pouvons étoffer la description en notant qu'elle prévoit un middleware de type EIP.

Il ne fournit pas le middleware lui-même, car il ne peut pas connaître les détails de ce que les applications doivent communiquer. Mais il fournit l'API pour créer les parties invariantes de ce middleware (créer un point de départ, créer un point de fin, créer des conditions de début et de fin, etc.)

J'espère que cela pourra aider.

Voici une autre tentative.

Vous savez comment il existe / existait des choses comme Webmethods, ICAN Seebeyond, Tibco BW, IBM Broker. Ils ont tous aidé avec des solutions d'intégration dans l'entreprise. Ces outils sont généralement connus sous le nom d'outils EAI (Enterprise Application Integration).

Il y avait principalement des outils de glisser-déposer construits autour de ces technologies et dans certaines parties, vous auriez à écrire des adaptateurs en Java. Ces codes d'adaptateur n'ont pas été testés ou ont été mal outillés / automatisés lors des tests.

Tout comme avec les modèles de conception en programmation, vous disposez de modèles d'intégration d'entreprise pour les solutions d'intégration courantes. Ils ont été rendus célèbres par un livre du même nom de Gregor Hohpe et Bobby Woolf.

Bien qu'il soit tout à fait possible d'implémenter des solutions d'intégration qui utilisent un ou plusieurs EIP, Camel est une tentative de le faire dans votre base de code en utilisant XML, Java, Groovy ou Scala.

Camel prend en charge tous les modèles d'intégration d'entreprise répertoriés dans le livre via son riche DSL et son mécanisme de routage.

Camel est donc une technologie en concurrence avec d'autres outils EAI avec une meilleure prise en charge pour tester votre code d'intégration. Le code est concis en raison des langages spécifiques au domaine (DSL). Il est lisible même par les utilisateurs professionnels et il est gratuit et vous rend productif.

Il existe de nombreux cadres qui nous facilitent la messagerie et la résolution des problèmes de messagerie. Un tel produit est Apache Camel.

La plupart des problèmes courants ont des solutions éprouvées appelées modèles de conception. Le modèle de conception pour la messagerie est les modèles d'intégration d'entreprise (EIP) qui sont bien expliqués ici . Apache camel nous aide à implémenter notre solution à l'aide des EIP.

La force d'un cadre d'intégration est sa capacité à nous faciliter la tâche via des EIP ou d'autres modèles, le nombre de transports et de composants et la facilité de développement sur laquelle Apache Camel se trouve en tête de liste.

Chacun des cadres a ses propres avantages Certaines des caractéristiques spéciales d'Apache camel sont les suivantes.

1. Il fournit le codage dans de nombreux DSL, à savoir Java DSL et Spring xml, qui sont populaires.
2. Utilisation facile et simple à utiliser.
3. Fuse IDE est un produit qui vous aide à coder via l'interface utilisateur

En clair, le chameau fait (beaucoup) de choses sans beaucoup de code de plaque de chaudière.

Juste pour vous donner une perspective, le DSL Java donné ci-dessous créera un point de terminaison REST qui pourra accepter un XML composé d'une liste de produits et le divisera en plusieurs produits et invoquera la méthode Process de BrandProcessor avec lui. Et juste en ajoutant .parallelProcessing (notez la partie commentée), il traitera en parallèle tous les objets produit. (La classe de produit est le stub Java généré par JAXB / XJC à partir du XSD auquel le XML d'entrée est limité.) Cette quantité de code (avec quelques dépendances Camel) fera le travail qui nécessitait auparavant des centaines de lignes de code Java.

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

Après avoir ajouté l'ID de l'itinéraire et l'instruction de journalisation

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

Ce n'est qu'un exemple, Camel est bien plus qu'un simple point de terminaison REST. Jetez un œil à la liste des composants enfichables http://camel.apache.org/components.html

Camel aide au routage, à la transformation et à la surveillance.

Il utilise des routes; qui peut être décrit comme:

Lorsque le bus de service reçoit un message particulier, il l'achemine via aucun des services / destinations de courtier tels que la file d'attente / les sujets. Ce chemin est appelé route.

Exemple: votre application de stock a reçu des informations de la part d'un analyste, elle sera traitée via l'application / le composant Web, puis le résultat sera publié pour tous les membres intéressés / enregistrés pour une mise à jour de stock particulière.

Supposons que vous créez une société de commerce électronique comme Amazon et que vous souhaitez vous concentrer uniquement sur la stratégie / le choix des produits à vendre. contrairement à la flotte de livraison d'Amazon, au lieu de gérer vous-même le déplacement des marchandises des vendeurs vers l'entrepôt, de les modifier dans l'entrepôt comme l'emballage et de les envoyer à d'autres villes et clients. Vous embauchez une entreprise qui fait tout cela et vous leur donnez simplement des informations sur tous les emplacements de votre entrepôt, les types de véhicules, les lieux de livraison et une liste de quand faire quoi. Ensuite, ils gèrent cela par eux-mêmes, ce serait Apache Camel. Ils s'occupent de déplacer les choses d'un bout à l'autre, une fois que vous leur avez remis des choses, afin que vous soyez libre de vous concentrer sur d'autres choses.

101 Word Intro

Camel est un cadre avec une API et un modèle de programmation cohérents pour intégrer les applications ensemble. L'API est basée sur les théories des modèles d'intégration d'entreprise , c'est-à-dire un ensemble de modèles de conception qui ont tendance à utiliser la messagerie. Il fournit des implémentations prêtes à l'emploi de la plupart de ces modèles et est également livré avec plus de 200 composants différents . prêtes à l'emploi vous pouvez utiliser pour parler facilement à toutes sortes d'autres systèmes. Pour utiliser Camel, écrivez d'abord votre logique métier dans des POJO et implémentez des interfaces simples centrées sur les messages. Ensuite, utilisez le DSL de Camel pour créer des "itinéraires" qui sont des ensembles de règles pour coller votre application ensemble.

Intro étendue

En surface, la fonctionnalité de Camel rivalise avec les produits traditionnels Enterprise Service Bus. Nous pensons généralement qu'une route de chameau est un composant de «médiation» (ou orchestration) qui vit du côté serveur, mais parce que c'est une bibliothèque Java, il est facile à intégrer et il peut également vivre sur une application côté client et vous aider à intégrer avec des services point à point (alias chorégraphie). Vous pouvez même prendre vos POJO qui traitent les messages à l'intérieur de la route Camel et les transformer facilement en leurs propres processus de consommation à distance, par exemple si vous aviez besoin de mettre à l'échelle une seule pièce indépendamment. Vous pouvez utiliser Camel pour connecter des routes ou des processeurs à travers un certain nombre de protocoles / transports distants différents en fonction de vos besoins. Avez-vous besoin d'un protocole binaire extrêmement efficace et rapide, ou qui est plus lisible par l'homme et plus facile à déboguer? Et si vous vouliez changer? Avec Camel, cela est généralement aussi simple que de changer une ligne ou deux sur votre itinéraire et de ne changer aucune logique métier. Ou vous pouvez prendre en charge les deux - vous êtes libre d'exécuter plusieurs itinéraires à la fois dans un contexte chameau.

Vous n'avez pas vraiment besoin d'utiliser Camel pour des applications simples qui vont vivre dans un seul processus ou JVM - ce serait exagéré. Mais ce n'est pas conceptuellement plus difficile que le code que vous pouvez écrire vous-même. Et si vos besoins changent, la séparation de la logique métier et du code de collage facilite la maintenance au fil du temps. Une fois que vous avez appris l'API Camel, il est facile de l'utiliser comme un couteau de l'armée suisse et de l'appliquer rapidement dans de nombreux contextes différents pour réduire la quantité de code personnalisé que vous auriez autrement à écrire. Vous pouvez apprendre une saveur - la Java DSL, par exemple, une API fluide qui est facile à enchaîner - et choisir facilement les autres saveurs.

Globalement, Camel est un excellent choix si vous essayez de faire des microservices. Je l'ai trouvé inestimable pour l'architecture évolutive, car vous pouvez reporter beaucoup de décisions difficiles et "faciles à se tromper" sur les protocoles, les transports et autres problèmes d'intégration de système jusqu'à ce que vous en sachiez plus sur votre domaine de problème. Concentrez-vous simplement sur vos EIP et votre logique métier principale et passez à de nouveaux itinéraires avec les «bons» composants au fur et à mesure que vous en apprenez.

Oui, c'est probablement un peu tard. Mais une chose à ajouter aux commentaires de tout le monde est que Camel est en fait une boîte à outils plutôt qu'un ensemble complet de fonctionnalités. Vous devez garder cela à l'esprit lors du développement et devez effectuer diverses transformations et conversions de protocole.

Camel lui-même repose sur d'autres cadres et, par conséquent, vous devez parfois les comprendre également pour comprendre celui qui convient le mieux à vos besoins. Il existe par exemple plusieurs façons de gérer REST. Cela peut devenir un peu déroutant au début, mais une fois que vous commencerez à utiliser et à tester, vous vous sentirez à l'aise et votre connaissance des différents concepts augmentera.

Apache Camel est un cadre Java pour l'intégration d'entreprise. Par exemple: - si vous construisez une application Web qui interagit avec de nombreuses API de fournisseurs, nous pouvons utiliser le chameau comme outil d'intégration externe. Nous pouvons en faire plus en fonction du cas d'utilisation. Camel in Action des publications de Manning est un excellent livre pour apprendre le chameau. Les intégrations peuvent être définies comme ci-dessous.

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

Il s'agit simplement de créer un point de terminaison d'API REST qui à son tour appelle une API externe et renvoie la demande

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>

Venir à vos questions

1. C'est quoi exactement? Rép: - C'est un cadre qui implémente les modèles d'intégration d'entreprise
2. Comment interagit-il avec une application écrite en Java? Rép: - il peut interagir avec tous les protocoles disponibles comme http, ftp, amqp, etc.
3. Est-ce quelque chose qui va de pair avec le serveur? Rép: - Il peut être déployé dans un conteneur comme tomcat ou peut être déployé indépendamment en tant que processus java
4. Est-ce un programme indépendant? Ans: - C'est possible.

J'espère que cela aide

Apache Camel est un cadre d'intégration léger qui implémente tous les modèles d'intégration d'entreprise. Vous pouvez facilement intégrer différentes applications en utilisant les modèles requis. Vous pouvez utiliser Java, Spring XML, Scala ou Groovy.

Apache Camel s'exécute sur la machine virtuelle Java (JVM). ... La fonctionnalité principale d'Apache Camel est son moteur de routage. Il alloue des messages en fonction des itinéraires associés. Un itinéraire contient un flux et une logique d'intégration. Il est implémenté à l'aide d'EIP et d'une DSL spécifique.

C'est comme un pipeline reliant

From---->To

Entre les deux, vous pouvez ajouter autant de canaux et de tuyaux. Le robinet peut être de tout type automatique ou manuel pour le flux de données et un itinéraire pour canaliser le flux.

Il prend en charge et a une implémentation pour tous les types et types de traitement. Et pour un même traitement, de nombreuses approches car il a de nombreux composants et chaque composant peut également fournir la sortie souhaitée en utilisant différentes méthodes.

Par exemple, le transfert de fichiers peut être effectué à dos de chameau avec des types de fichiers déplacés ou copiés et également à partir d'un dossier, d'un serveur ou d'une file d'attente.

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

De / à ---- dossier, direct, seda, vm peut être n'importe quoi

Un autre point de vue (basé sur des sujets mathématiques plus fondamentaux)

La plate-forme informatique la plus générale est une [ https://en.wikipedia.org/wiki/Turing_machine]

Il y a un problème avec la machine Turing. Toutes les données d'entrée / sortie restent à l'intérieur de la machine de turing. Dans le monde réel, il existe des sources d'entrée et des puits de sortie externes à notre machine Turing, et en général régis par des systèmes hors de notre contrôle. Autrement dit, ces systèmes externes enverront / recevront des données à volonté dans n'importe quel format avec le programmateur de données souhaité.

Question: Comment pouvons-nous faire en sorte que les machines de turing indépendantes se parlent de la manière la plus générale afin que chaque machine de turing considère leurs pairs comme une source de données d'entrée ou un puits de données de sortie?

Réponse: Utiliser quelque chose comme chameau, mule, BizTalk ou tout autre ESB qui résume la gestion des données entre l'achèvement de machines de turing "physiques" (ou logiciels virtuels) distinctes.