En quoi consiste exactement Apache Camel?
Je ne comprends pas ce que fait exactement 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 avec le serveur?
- Est-ce un programme indépendant?
S'il vous plaît expliquer ce qu'est Camel.
Si vous avez 5 à 10 minutes, je recommande généralement aux gens de lire ceci Intégration à Apache Camel par Jonathan Anstey. C'est un article bien écrit qui donne une brève introduction et une vue d'ensemble de certains concepts de Camel, et implémente un cas d'utilisation avec des exemples de code. Jonathan y écrit:
Apache Camel est un framework open source Java 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 très utilisés Enterprise Integration Patterns (EIP)
- connectivité à une grande variété de transports et API
- langages spécifiques au domaine (DSL) faciles à utiliser pour connecter des EIP et des 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.
Mon point de vue pour décrire cela de 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 manières 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 . Certains d'entre nous ont épargné 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 ont écrit le livre Enterprise Integration Patterns (EIP) dans lequel ils proposent et documentent un ensemble de nouveaux modèles et blueprints pour savoir comment nous pourrions best concevoir de grands systèmes à base de composants, dans lesquels les composants peuvent s'exécuter sur le même processus ou sur une machine différente.
Ils proposent en gros que notre système soit structuré de manière à être orienté message - les composants communiquant les uns avec les autres en utilisant des messages en entrée et en sortie 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 propose les interfaces pour les EIP, les objets de base, les implémentations généralement nécessaires, des outils de débogage, un système de configuration et de nombreux autres assistants qui vous feront gagner un temps considérable lorsque vous souhaitez implémenter votre solution pour suivre les EIP.
Prenez MVC. MVC est assez simple en théorie et nous pourrions le mettre en œuvre sans aucune aide du framework. Mais de bons frameworks MVC nous fournissent la structure prête à l’emploi et ont fait un effort supplémentaire en pensant à toutes les 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 que Apache Camel est pour les EIP. Il s'agit d'un cadre complet prêt à la production pour les personnes souhaitant mettre en œuvre leur solution pour suivre les EIP.
Créer un description du projet ne devrait pas être compliqué.
Je dis:
Apache Camel est une technologie de messagerie collante avec routage. Il relie les points de départ et d'arrivée de la messagerie, permettant ainsi le transfert de messages de différentes sources vers différentes destinations. Par exemple: JMS -> JSON, HTTP -> JMS ou entonnoir FTP -> JMS, HTTP -> JMS, JSON -> JMS
Wikipedia dit:
Apache Camel est un moteur de routage et de médiation basé sur des règles qui fournit une implémentation Java d'objet des modèles d'intégration d'entreprise à l'aide d'une API (ou d'un langage déclaratif Java spécifique au domaine) pour configurer le routage. règles de médiation. Le langage spécifique à un domaine signifie qu'Apache Camel peut prendre en charge la complétion intelligente des règles de routage dans votre IDE en utilisant un code Java normal sans de grandes quantités de fichiers de configuration XML; bien que la configuration XML à l'intérieur de Spring soit également prise en charge.
Voir? Ce n'était pas difficile était-ce?
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 répondre aux exigences de votre entreprise.
Pour pouvoir faire ça:
1) Vous pourriez développer un programme personnalisé qui le ferait (cela prendrait beaucoup de temps et serait difficile à comprendre, à maintenir pour un autre développeur)
2) Alternativement, vous pouvez utiliser Apache Camel pour le faire de manière standardisée (la plupart des connecteurs sont déjà développés pour vous, il vous suffit de le configurer et de brancher votre logique - appelée Process):
Chameau vous aidera à:
- Consommez des données de n'importe quelle source/format
- Traiter ces données
- Données de sortie vers n'importe quelle source/format
En utilisant Apache Camel, vous faciliterez la compréhension, la maintenance et 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 patterns vous aident à bien intégrer les systèmes :-)
Camel envoie des messages de A à B:
Pourquoi tout un cadre pour cela? Et si vous avez:
- de nombreux expéditeurs et de nombreux destinataires
- une douzaine de protocoles (
ftp,http,jms, etc.) - beaucoup de règles complexes
- Envoyer un message A aux destinataires A et B uniquement
- Envoyez un message B au destinataire C au format XML , mais en partie traduisez-le , , enrichissez (ajoutez des métadonnées) et SI condition X , puis envoyez le récepteur D aussi, mais comme CSV .
Alors maintenant, vous avez besoin de:
- traduire entre les protocoles
- coller des composants ensemble
- définir les itinéraires - ce qui se passe où
- filtrer certaines choses dans certains cas
Chameau vous donne le dessus (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 this et this et Camel in Action (comme d'autres l'ont déjà dit, un excellent livre!)
Un diagramme vaut mieux que des milliers de descriptions. Ce diagramme illustre l'architecture de Camel.
BASÉ SUR L'ANALOGIE
L’acheminement basé sur les chameaux peut être compris très facilement en vous mettant à la place du propriétaire d’une 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 aéronefs de différentes "entreprises aéronautiques" comme Boeing, Airbus, HAL pour transporter des passagers.
Votre compagnie aérienne embarque des passagers utilisant les "aéroports" de la ville et les embarque à l'aide de l'aéroport de la ville. Un passager peut "voyager" dans plusieurs villes, mais il doit partout passer par l'aéroport pour voyager entre les avions de votre compagnie aérienne et la ville.
Notez qu'un passager "en partance" de la ville est essentiellement "en train d'arriver" dans l'avion de votre compagnie aérienne. Et un passager "arrivant" dans la ville, part essentiellement de l'avion. Puisque nous sommes dans la peau du propriétaire de la 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éroport" de chaque ville est utilisée par les passagers "au départ" et les passagers "à l'arrivée". Un aéroport fournit une "infrastructure de départ" pour les passagers au départ, différente de "l'infrastructure d'arrivée" fournie aux passagers.
Les passagers peuvent continuer à faire de leur mieux à leurs activités grâce aux diverses commodités fournies à l'intérieur de l'avion par vos compagnies aériennes, tout en voyageant.
De plus, votre compagnie aérienne fournit également des installations dans le salon 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 les suivants:
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;
comprendre les langues locales: conversions de types;
départ: production, produit
arriver: consommer, consommer
voyage: acheminé
é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 à l'aide du composant "Camel based" du système "de" et les supprime à l'aide du "composant Camel" du système "vers". Un message peut être acheminé vers plusieurs systèmes, mais il doit partout 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 à partir de maintenant. La signification des termes "message du consommateur" et "message du producteur" est donc inversée par rapport à nos notions conventionnelles qui reposent sur la perspective d'un système.
La même infrastructure de codage 'Composant basé sur les chameaux' est utilisée par 'message du producteur' et 'message du consommateur'. Un "composant basé sur les chameaux" fournit un "point de terminaison producteur" pour le "message du producteur" et un "point final consommateur" pour le "message du consommateur".
Les messages peuvent être traités par Camel lors de leur acheminement.
En plus de ce routage, Camel fournit des fonctionnalités spéciales telles que la "conversion de type" et bien d'autres encore ...
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 conscient. Bien que vous puissiez certainement lire le livre Enterprise Integration Patterns, un moyen plus rapide de se mettre à niveau est de lire quelque chose comme l'article de Wikipedia sur Enterprise Application Integration .
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 une infrastructure 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 d'un autre point de vue:
Apache Camel est un framework d'intégration. Il se compose de certaines bibliothèques Java, qui vous aident à mettre en œuvre des problèmes d'intégration sur la plate-forme Java. Ce que cela signifie et ce qui le différencie des API d'un côté et d'un bus de service d'entreprise (ESB) de l'autre côté, est décrit dans mon article " Quand utiliser Apache Camel ".
C'est quoi exactement?
Apache Camel est un framework 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 à l’aide des 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 coup d'œil à ceci article et article sur le modèle 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 d'intégration d'entreprise ou des itinéraires dans une variété de langages spécifiques à un domaine (DSL), comme indiqué ci-dessous.
Java DSL - Un DSL basé sur Java utilisant le style de construction fluide.
L'histoire de Enterprise Integration Pattern résout les problèmes suivants:
Message, noeud final, producteur, consommateur, routage, bus, transformation et traitement .
Jetez un coup d'œil à ceci article Par Anirban Konar pour l'un des cas d'utilisation en temps réel.
Est-ce quelque chose qui va 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 "nouveautés" en informatique ne sont pas vraiment nouvelles, elles constituent simplement 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 ou de coloniser des termes existants dans un but différent (un bon exemple de that est le renversement par les développeurs X de ce que "client" et "serveur" signifie.)
Camel est une API/wrapper basée sur Java pour les intergiciels inter-applications.
Un middleware est un terme général désignant un logiciel fournissant des services d'interprétation entre des entités ne partageant pas un langage ou des types de données communs.
C'est ce que Camel est, au fond. Nous pouvons préciser la description en notant qu’elle fournit 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 dont les applications ont besoin pour 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 final, créer des conditions pour le début et la fin, etc.)
J'espère que ça t'as aidé.
Voici une autre tentative.
Vous savez comment il y a/était 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 Enterprise Application Integration (EAI).
Il y avait principalement des outils de glisser-déposer construits autour de ces technologies et, dans certains cas, vous auriez à écrire des adaptateurs en Java. Ces codes d’adaptateur n’avaient pas été testés ou leur outillage/automatisation était faible autour des tests.
Tout comme pour 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 utilisant un ou plusieurs EIP, Camel tente de le faire dans votre 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 mécanisme DSL et de routage.
Camel est donc une technologie en concurrence avec d'autres outils EAI, avec un meilleur support 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. Il est gratuit et vous rend productif.
Il existe de nombreux cadres qui 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 de la messagerie est constitué de modèles EIP (Enterprise Integration Pattern) bien expliqués ici . Apache camel nous aide à mettre en œuvre notre solution à l'aide des EIP.
La force d'un framework d'intégration réside dans sa capacité à nous faciliter la tâche grâce aux EIP ou autres modèles, au nombre de transports et de composants et à la facilité de développement sur laquelle Apache Chamel se situe en haut de la liste.
Chaque cadre possède ses propres avantages. Certaines des caractéristiques spéciales d’Apache Camel sont les suivantes.
- Il fournit le codage nécessaire à de nombreux DSL, à savoir Java DSL et Spring DSL, qui sont populaires.
- Utilisation facile et simple à utiliser.
- Fuse IDE est un produit qui vous aide à coder via l'interface utilisateur.
En clair, camel fait (beaucoup) de choses sans beaucoup de code de plaque de chaudière.
Juste pour vous donner une perspective, le Java DSL indiqué ci-dessous créera un noeud final REST qui pourra accepter un XML composé de liste de produits et le scinde en plusieurs produits et invoquant Méthode de traitement de BrandProcessor avec elle. Et simplement en ajoutant .parallelProcessing (notez la partie commentée), il traitera en parallèle tous les objets du produit. (La classe de produit est générée par JAXB/XJC Java stub du fichier XSD auquel le xml d'entrée est limité.) Cette quantité de code (ainsi que quelques dépendances Camel) permet d'effectuer le travail qui prenait autrefois des centaines de lignes. de Java code.
from("servlet:item-delta?matchOnUriPrefix=true&httpMethodRestrict=POST")
.split(stax(Product.class))
/*.parallelProcessing()*/
.process(itemDeltaProcessor);
Après avoir ajouté l'ID de route et la déclaration 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);
Ceci est juste un échantillon, Camel est beaucoup plus que juste le point final [REST]. Il suffit de jeter un coup d'œ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 le routera vers aucun des services/destinations du courtier, tel que la file d'attente/les sujets. Ce chemin est appelé route.
Exemple: votre application stock a reçu quelques informations de la part de l’analyste, elle sera traitée par le composant application/Web et ensuite le résultat sera publié à tous les membres intéressés/inscrits pour une mise à jour particulière du stock.
101 mots d'introduction
Camel est un framework avec une API et un modèle de programmation cohérents pour l'intégration d'applications. L'API est basée sur les théories de 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 en outre livré avec plus de 200 composants composants différents, que vous pouvez utiliser pour communiquer facilement avec toutes sortes d'autres systèmes. Pour utiliser Camel, commencez par écrire votre logique métier dans des POJO et implémentez des interfaces simples centrées sur les messages. Ensuite, utilisez Camel’s DSL pour créer des "Routes", qui sont des ensembles de règles permettant de coller votre application ensemble.
Intro étendu
En surface, la fonctionnalité de Camel rivalise avec les produits Enterprise Service Bus traditionnels. Nous pensons généralement qu'une Route des chameaux est un composant de "médiation" (c'est-à-dire d'orchestration) qui vit côté serveur, mais comme c'est une bibliothèque Java, il est facile à intégrer et peut vivre sur une application côté client seulement. ainsi et vous aider à l'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 intégrer facilement à leurs propres processus de consommateur distant, par exemple. si vous aviez besoin de mettre à l'échelle une seule pièce indépendamment. Vous pouvez utiliser Camel pour connecter des itinéraires ou des processeurs via un nombre illimité de protocoles de transport/protocoles distants, en fonction de vos besoins. Avez-vous besoin d'un protocole binaire extrêmement efficace et rapide, ou d'un protocole plus lisible par l'homme et facile à déboguer? Et si vous vouliez changer? Avec Camel, cela est généralement aussi simple que de changer une ligne ou deux de votre itinéraire et de ne changer aucune logique métier. Vous pouvez également 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 dans une machine virtuelle Java - ce serait excessif. Mais ce n’est pas conceptuellement plus difficile que d’écrire vous-même. Et si vos besoins changent, la séparation de la logique métier et du code collé facilite la maintenance dans le temps. Une fois que vous avez appris à utiliser l’API Camel, il est facile de l’utiliser comme un couteau suisse et de l’appliquer rapidement dans de nombreux contextes afin de réduire la quantité de code personnalisé que vous auriez sinon dû écrire. Vous pouvez en apprendre un type - le Java DSL, par exemple, une API fluide facile à enchaîner - et choisir facilement les autres types.
Globalement, Camel est un bon choix si vous essayez de faire des microservices. Je l’ai trouvé très utile pour l’architecture évolutive, car vous pouvez différer un grand nombre des décisions difficiles et faciles à prendre sur les protocoles, les transports et d’autres problèmes d’intégration système jusqu’à ce que vous en sachiez plus sur votre domaine de problèmes. Concentrez-vous simplement sur vos EIP et votre logique métier principale et passez à de nouveaux itinéraires dotés des "bons" composants à mesure que vous en apprenez davantage.
Apache Camel est un framework Java pour l'intégration d'entreprise. Exemple: - si vous construisez une application Web qui interagit avec de nombreuses API de fournisseurs, nous pouvons utiliser Camel comme outil d'intégration externe. Nous pouvons en faire plus en fonction du cas d'utilisation. Camel in Action des publications Manning est un excellent livre pour apprendre Camel. 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");
Ceci consiste simplement à créer un noeud final d'API REST qui appelle à son tour une API externe et renvoie la demande.
DSL de printemps
<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
- C'est quoi exactement? Ans: - C'est un framework qui implémente des modèles d'intégration d'entreprise
- Comment interagit-il avec une application écrite en Java? Réponse: - il peut interagir avec tous les protocoles disponibles tels que http, ftp, amqp, etc.
- Est-ce quelque chose qui va avec le serveur? Réponse: - Il peut être déployé dans un conteneur tel que Tomcat ou peut être déployé indépendamment en tant que processus Java.
- Est-ce un programme indépendant? Ans: - Ça peut être.
J'espère que ça aide
Oui, c'est probablement un peu tard. Mais une chose à ajouter aux commentaires de tous les autres est que Camel est en réalité une boîte à outils plutôt qu'un ensemble complet de fonctionnalités. Vous devez en tenir compte lorsque vous développez et devez effectuer diverses transformations et conversions de protocoles.
Camel lui-même s'appuie sur d'autres cadres et il est donc parfois nécessaire de les comprendre également afin de déterminer celui qui convient le mieux à vos besoins. Il existe par exemple plusieurs manières de gérer REST. Cela peut paraître un peu déroutant au début, mais une fois que vous avez commencé à utiliser et à tester, vous vous sentirez à l'aise et votre connaissance des différents concepts augmentera.
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 transport des marchandises des vendeurs vers les entrepôts, apportez des modifications dans les entrepôts, comme l'emballage, puis envoyez-les à d'autres villes et à vos clients. Vous embauchez une entreprise qui fait tout cela et il vous suffit de leur donner des informations sur tous les emplacements de vos entrepôts, les types de véhicules, les lieux de livraison et une liste des moments où vous devez faire quoi. Ensuite, ils se débrouillent seuls, ce serait Apache Camel. Ils s’occupent de déplacer les choses d’un bout à l’autre, une fois que vous leur remettez des choses, pour que vous soyez libre de vous concentrer sur d’autres choses.
C'est comme un pipeline reliant
From---->To
Entre 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 la mise en œuvre pour tous les types et types de traitement. Et pour le même traitement, de nombreuses approches, car il comporte de nombreux composants et chaque composant peut également fournir le résultat souhaité en utilisant différentes méthodes.
Par exemple, le transfert de fichiers peut être effectué à chameau avec les types de fichiers déplacés ou copiés, ainsi que depuis un dossier, un serveur ou 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 un [ https://en.wikipedia.org/wiki/Turing_machine]
Il y a un problème avec la machine de Turing. Toutes les données d'entrée/sortie restent à l'intérieur de la machine. Dans le monde réel, il existe des sources d’entrée et des puits de sortie extérieurs à notre machine de Turing et, en général, régis par des systèmes indépendants de notre volonté. C'est-à-dire que ces systèmes externes enverront/recevront des données à volonté dans n'importe quel format avec n'importe quel 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 possible, de sorte que chaque machine de turing considère ses pairs comme une source de données d'entrée ou un puits de données de sortie?
Réponse: en utilisant quelque chose comme chameau, mulet, BizTalk ou tout autre ESB qui supprime le traitement des données entre des machines de turing "physiques" (ou des logiciels virtuels) distinctes.