Ich verstehe nicht genau, was Camel tut.

Wenn Sie in 101 Worten eine Einführung in Camel geben könnten:

• Was genau ist das?
• Wie interagiert es mit einer in Java geschriebenen Anwendung?
• Passt das zum Server?
• Ist es ein unabhängiges Programm?

Bitte erklären Sie, was Kamel ist.

Wenn Sie 5 bis 10 Minuten Zeit haben, empfehle ich generell, diese Integration mit Apache Camel von Jonathan Anstey zu lesen . Es ist ein gut geschriebenes Stück, das eine kurze Einführung und einen Überblick über einige Konzepte von Camel gibt und einen Anwendungsfall mit Codebeispielen implementiert. Darin schreibt Jonathan:

Apache Camel ist ein Open-Source-Java-Framework, das die Integration für Entwickler einfacher und zugänglicher macht. Dies geschieht durch Bereitstellung von:

• konkrete Implementierungen aller weit verbreiteten Enterprise Integration Patterns (EIPs)
• Konnektivität zu einer Vielzahl von Transporten und APIs
• Einfach zu verwendende domänenspezifische Sprachen (Domain Specific Languages, DSLs), um EIPs und Transporte miteinander zu verbinden

Es gibt auch ein kostenloses Kapitel von Camel in Action, in dem Camel im ersten Kapitel vorgestellt wird. Jonathan ist mit mir Co-Autor dieses Buches.

Mein Ansatz, dies zugänglicher zu beschreiben ...

Um zu verstehen, was Apache Camel ist, müssen Sie die Enterprise-Integrationsmuster verstehen.

Beginnen wir mit dem, was wir vermutlich bereits wissen: Das Singleton-Muster, das Factory-Muster usw.; Sie sind lediglich Möglichkeiten, Ihre Lösung für das Problem zu organisieren, aber sie sind selbst keine Lösungen. Diese Muster wurden von der Viererbande analysiert und für den Rest von uns extrahiert, als sie ihr Buch: Design Patterns veröffentlichten . Sie haben einigen von uns enorme Mühe erspart, darüber nachzudenken, wie sie ihren Code am besten strukturieren können.

Ähnlich wie die Viererbande haben Gregor Hohpe und Bobby Woolf das Buch Enterprise Integration Patterns (EIP) verfasst, in dem sie eine Reihe neuer Muster und Blaupausen vorschlagen und dokumentieren, wie wir große komponentenbasierte Systeme am besten entwerfen können, in denen Komponenten sein können auf demselben Prozess oder auf einem anderen Computer ausgeführt werden.

Sie schlagen grundsätzlich vor, dass wir unser System so strukturieren, dass es nachrichtenorientiert ist - wobei Komponenten unter Verwendung von Nachrichten als Ein- und Ausgänge miteinander kommunizieren und absolut nichts anderes. Sie zeigen uns einen vollständigen Satz von Mustern, aus denen wir auswählen und in unsere verschiedenen Komponenten implementieren können, die zusammen das gesamte System bilden.

Was ist Apache Camel?

Apache Camel bietet Ihnen die Schnittstellen für die EIPs, die Basisobjekte, häufig benötigte Implementierungen, Debugging-Tools, ein Konfigurationssystem und viele andere Hilfsprogramme, mit denen Sie eine Menge Zeit sparen, wenn Sie Ihre Lösung implementieren möchten, um den EIPs zu folgen.

Nimm MVC. MVC ist theoretisch ziemlich einfach und wir könnten es ohne Framework-Hilfe implementieren. Gute MVC-Frameworks bieten uns jedoch die gebrauchsfertige Struktur und haben sich die Mühe gemacht, alle anderen "Neben" -Dinge zu überdenken, die Sie beim Erstellen eines großen MVC-Projekts benötigen. Deshalb verwenden wir sie die meiste Zeit.

Genau das ist Apache Camel für EIPs. Es ist ein vollständiges produktionsreifes Framework für Personen, die ihre Lösung implementieren möchten, um den EIPs zu folgen.

Das Erstellen einer Projektbeschreibung sollte nicht kompliziert sein.

Ich sage:

Apache Camel ist Messaging-Technologie mit Routing. Es verbindet Messaging-Start- und -Endpunkte und ermöglicht so die Übertragung von Nachrichten von verschiedenen Quellen zu verschiedenen Zielen. Zum Beispiel: JMS -> JSON, HTTP -> JMS oder Trichter-FTP -> JMS, HTTP -> JMS, JSON -> JMS

Wikipedia sagt:

Apache Camel ist eine regelbasierte Routing- und Mediations-Engine, die eine Java-objektbasierte Implementierung der Enterprise Integration Patterns mithilfe einer API (oder einer deklarativen Java Domain Specific Language) zum Konfigurieren von Routing- und Mediationsregeln bereitstellt. Die domänenspezifische Sprache bedeutet, dass Apache Camel die typsichere intelligente Vervollständigung von Routing-Regeln in Ihrer IDE unter Verwendung von normalem Java-Code ohne große Mengen an XML-Konfigurationsdateien unterstützen kann. Die XML-Konfiguration in Spring wird jedoch ebenfalls unterstützt.

Sehen? Das war nicht schwer, oder?

Zusamenfassend:

Wenn Systeme verbunden / integriert werden müssen, müssen Sie wahrscheinlich eine Verbindung zu einer Datenquelle herstellen und diese Daten dann entsprechend Ihren Geschäftsanforderungen verarbeiten.

Um das zu tun:

1) Sie könnten ein benutzerdefiniertes Programm entwickeln, das dies tun würde (möglicherweise zeitaufwändig und schwer zu verstehen, für andere Entwickler warten).

2) Alternativ können Sie Apache Camel verwenden, um dies auf standardisierte Weise zu tun (es hat die meisten bereits für Sie entwickelten Konnektoren, Sie müssen es nur einrichten und Ihre Logik anschließen - Prozess genannt):

Camel hilft Ihnen dabei:

1. Verbrauchen Sie Daten aus einer beliebigen Quelle / einem beliebigen Format
2. Verarbeiten Sie diese Daten
3. Daten in eine beliebige Quelle / ein beliebiges Format ausgeben

Mit Apache Camel können Sie Ihr System leicht verstehen, warten und auf einen anderen Entwickler ausweiten.

Apache Camel wurde mit Enterprise Integration Patterns entwickelt. Die Muster helfen Ihnen, Systeme gut zu integrieren :-)

Camel sendet Nachrichten von A nach B:

Warum ein ganzer Rahmen dafür? Was ist, wenn Sie:

• viele Sender und viele Empfänger
• ein Dutzend von Protokollen ( ftp, http, jms, etc.)
• viele komplexe Regeln
  • Senden Sie eine Nachricht A nur an die Empfänger A und B.
  • Senden Sie eine Nachricht B als XML an Empfänger C , übersetzen Sie sie jedoch teilweise , bereichern Sie sie (fügen Sie Metadaten hinzu) und die IF-Bedingung X und senden Sie sie dann ebenfalls an Empfänger D, jedoch als CSV .

Jetzt brauchen Sie also:

• zwischen Protokollen übersetzen
• Kleber Komponenten zusammen
• Routen definieren - was geht wohin
• In einigen Fällen einige Dinge filtern

Camel bietet Ihnen die oben genannten (und mehr) sofort einsatzbereit:

mit einer coolen DSL-Sprache, mit der Sie definieren können, was und wie:

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

Siehe auch dies und das und Camel in Action (wie andere gesagt haben, ein ausgezeichnetes Buch!)

Ein Diagramm ist besser als Tausende von Beschreibungen. Dieses Diagramm zeigt die Architektur von Camel.

BASIEREND AUF ANALOGIE

Kamelbasiertes Routing kann sehr leicht verstanden werden, wenn Sie sich in die Lage eines Airline-Besitzers versetzen (z. B. American Airlines, Jet Airways).

Der Zweck von "Ihrer Fluggesellschaft" besteht darin, "Passagiere" von einer "Stadt" zu einer anderen auf der Welt zu "befördern". Sie verwenden Flugzeuge verschiedener Flugzeughersteller wie Boeing, Airbus und HAL, um Passagiere zu befördern.

Die Fluggäste Ihrer Fluggesellschaft nutzen die "Flughäfen" der Stadt und steigen an Bord des Flughafens der Stadt aus. Ein Passagier kann in mehrere Städte "reisen", aber überall muss er den Flughafen passieren, um zwischen dem Flugzeug Ihrer Fluggesellschaft und der Stadt zu reisen.

Beachten Sie, dass ein Passagier, der die Stadt verlässt, im Wesentlichen in das Flugzeug Ihrer Fluggesellschaft eintrifft. Und ein Passant, der in der Stadt ankommt, verlässt im Wesentlichen das Flugzeug. Da wir in den Schuhen des Airline-Eigentümers stehen, werden die Begriffe "ankommender Passagier" und "abfliegender Passagier" von unseren herkömmlichen Vorstellungen, die auf der Perspektive der Städte basieren, umgekehrt.

Die gleiche "Flughafen" -Infrastruktur jeder Stadt wird von "abfliegenden" Passagieren und "ankommenden" Passagieren genutzt. Ein Flughafen bietet eine "Abfluginfrastruktur" für abfliegende Passagiere, die sich von der "Ankunftsinfrastruktur" für ankommende Passagiere unterscheidet.

Passagiere können ihren Tag mit ihren Aktivitäten fortsetzen, da Ihre Fluggesellschaften auf Reisen verschiedene „Annehmlichkeiten“ im Flugzeug bereitstellen.

Darüber hinaus bietet Ihre Fluggesellschaft Lounge-Einrichtungen für spezielle Behandlungen wie das Verstehen der Landessprache und die Vorbereitung auf die Reise.

Ersetzen wir einige der oben verwendeten Wörter / Sätze durch folgende:

Ihre Fluggesellschaft: Apache Camel

Flugzeughersteller: Transportmechanismen

Flugzeug Ihrer Fluggesellschaft: Der zugrunde liegende Transportmechanismus von Apache Camel

tragen: Route

Passagiere: Nachricht;

Stadt: System;

Flughafen: Kamelkomponente;

lokale Sprachen verstehen: Typkonvertierungen;

abreisen: produzieren, produzieren

ankommen: konsumieren, konsumieren

Reisen: geroutet

Ausstattung: zur Verfügung gestellt

Nach dem Ersetzen der Wörter erhalten Sie Folgendes:

Der Zweck von "Apache Camel" besteht darin, "Nachrichten" von einem "System" zu einem anderen auf der Welt weiterzuleiten. Apache Camel verwendet verschiedene Transportmechanismen für das Nachrichtenrouting.

Apache Camel nimmt Nachrichten mit 'Camel based Component' des 'from'-Systems auf und löscht sie mit der' Camel based Component 'des' to'-Systems. Eine Nachricht kann an mehrere Systeme weitergeleitet werden, aber überall müssen sie "Kamelbasierte Komponenten" durchlaufen, um zwischen dem zugrunde liegenden Transportmechanismus von "Apache Camel" und dem System zu wechseln.

Beachten Sie, dass eine vom System "erzeugte" Nachricht im Wesentlichen in den zugrunde liegenden Transportmechanismus von Apache Camel "verbraucht" wird. Und eine Nachricht, die von einem System konsumiert wird, wird im Wesentlichen vom zugrunde liegenden Transportmechanismus des Apache-Kamels erzeugt.

Da wir versuchen, Camel zu verstehen, müssen wir hier aus der Perspektive von Camel denken. Die Bedeutung der Begriffe "Verbraucherbotschaft" und "Produzentenbotschaft" ist daher umgekehrt zu unseren herkömmlichen Begriffen, die auf der Perspektive eines Systems beruhen.

Die Codierungsinfrastruktur derselben "Camel based Component" wird von "Producer Message" und "Consumer Message" verwendet. Eine "Kamel-basierte Komponente" bietet einen "Produzenten-Endpunkt" für "Produzenten-Nachricht" und einen "Konsumenten-Endpunkt" für "Konsumenten-Nachricht".

Nachrichten können von Camel verarbeitet werden, wenn sie weitergeleitet werden.

Zusätzlich zu diesem Routing bietet Camel spezielle Funktionen wie "Typkonvertierung" und vieles mehr ...

Eines der Dinge, die Sie verstehen müssen, bevor Sie versuchen, Apache Camel zu verstehen, sind Enterprise Integration Patterns. Nicht jeder auf dem Gebiet kennt sie tatsächlich. Sie können zwar das Buch "Enterprise Integration Patterns" lesen, aber eine schnellere Möglichkeit, sich mit ihnen vertraut zu machen, besteht darin, so etwas wie den Wikipedia-Artikel über Enterprise Application Integration zu lesen .

Wenn Sie den Themenbereich gelesen und verstanden haben, ist es viel wahrscheinlicher, dass Sie den Zweck von Apache Camel verstehen

HTH

Wenn Sie mit Enterprise Integration Patterns vertraut sind, ist Apache Camel ein Integrationsframework, das alle EIPs implementiert.

Und Sie können Camel als eigenständige Anwendung in einem Webcontainer bereitstellen.

Grundsätzlich können Sie Camel verwenden, wenn Sie mehrere Anwendungen mit unterschiedlichen Protokollen und Technologien integrieren müssen.

Eine Definition aus einer anderen Perspektive:

Apache Camel ist ein Integrationsframework. Es besteht aus einigen Java-Bibliotheken, mit denen Sie Integrationsprobleme auf der Java-Plattform implementieren können. Was dies bedeutet und wie es sich von APIs auf der einen Seite und einem Enterprise Service Bus (ESB) auf der anderen Seite unterscheidet, wird in meinem Artikel " Wann wird Apache Camel verwendet? " Beschrieben .

Was genau ist das?

Apache Camel ist ein leichtes Integrationsframework, das alle Enterprise-Integrationsmuster implementiert. Mit den erforderlichen Mustern können Sie problemlos verschiedene Anwendungen integrieren.

Sie können Java, Spring XML, Scala oder Groovy verwenden. Fast jede Technologie, die Sie sich vorstellen können, ist verfügbar, zum Beispiel HTTP, FTP, JMS, EJB, JPA, RMI, JMS, JMX, LDAP, Netty usw.

Schauen Sie sich diesen Artikel und den EIP-Musterartikel an

Wie interagiert es mit einer in Java geschriebenen Anwendung?

Camel verwendet eine Java Domain Specific Language oder DSL zum Erstellen von Enterprise Integration Patterns oder Routes in einer Vielzahl von domänenspezifischen Sprachen (DSL), wie unten aufgeführt.

Java DSL - Ein Java-basiertes DSL, das den fließenden Builder-Stil verwendet.

Die Geschichte von Enterprise Integration Pattern dreht sich um folgende Konzepte:

Nachricht, Endpunkt, Produzent, Verbraucher, Routing, Bus, Transformation und Prozess .

In diesem Artikel von Anirban Konar finden Sie einen Anwendungsfall in Echtzeit.

Passt das zum Server?

Es fungiert als Brücke zwischen mehreren Unternehmenssubsystemen.

Ist es ein unabhängiges Programm?

Apache Camel, ein Integrationsframework, integriert verschiedene unabhängige Anwendungen.

Der Hauptvorteil von Camel : Sie können verschiedene Anwendungen mit unterschiedlichen Technologien (und unterschiedlichen Protokollen) integrieren, indem Sie für jede Integration dieselben Konzepte verwenden.

Die meisten "neuen" Dinge im Computer sind überhaupt nicht neu, sie sind nur eine mysteriöse Hülle um etwas, das bereits gut verstanden wurde. Wenn sie sind schwer zu verstehen, ist es in der Regel , weil jemand neue Sprache Begriffe zu erfinden beschlossen oder kolonisieren bestehenden Bedingungen für einen anderen Zweck (ein gutes Beispiel dafür , dass ist die Umkehrung X - Entwickler von dem, was ‚Client‘ und ‚Server‘ Mittelwert.)

Camel ist ein Java-basierter Wrapper / API für anwendungsübergreifende Middleware.

Middleware ist ein allgemeiner Begriff für Software, die Interpretationsdienste zwischen Entitäten bereitstellt, die keine gemeinsame Sprache oder keinen gemeinsamen Datentyp haben.

Das ist Camel im Grunde. Wir können die Beschreibung präzisieren, indem wir feststellen, dass sie Middleware vom Typ EIP enthält.

Die Middleware selbst wird nicht bereitgestellt, da die Details der Kommunikation der Anwendungen nicht bekannt sind. Es bietet jedoch die API zum Erstellen der unveränderlichen Teile dieser Middleware (Erstellen eines Startpunkts, Erstellen eines Endpunkts, Erstellen von Bedingungen für das Starten und Beenden usw.)

Ich hoffe, das hilft.

Hier ist ein weiterer Versuch.

Sie wissen, wie es Dinge wie Webmethods, ICAN Seebeyond, Tibco BW und IBM Broker gibt / gab. Sie alle haben bei Integrationslösungen im Unternehmen geholfen. Diese Tools sind allgemein unter dem Namen Enterprise Application Integration (EAI) -Tools bekannt.

Es gab meistens Drag-Drop-Tools, die auf diesen Technologien basierten, und in Teilen mussten Sie Adapter in Java schreiben. Diese Adaptercodes waren entweder nicht getestet oder hatten schlechte Werkzeuge / Automatisierung beim Testen.

Genau wie bei Entwurfsmustern in der Programmierung verfügen Sie über Enterprise-Integrationsmuster für gängige Integrationslösungen. Bekannt wurden sie durch ein gleichnamiges Buch von Gregor Hohpe und Bobby Woolf.

Obwohl es durchaus möglich ist, Integrationslösungen zu implementieren, die eine oder mehrere EIP verwenden, ist Camel ein Versuch, dies in Ihrer Codebasis mithilfe von XML, Java, Groovy oder Scala zu tun.

Camel unterstützt alle im Buch aufgeführten Enterprise Integration Patterns über seinen umfangreichen DSL- und Routing-Mechanismus.

Camel ist also eine konkurrierende Technologie für andere EAI-Tools mit besserer Unterstützung für das Testen Ihres Integrationscodes. Der Code ist aufgrund der domänenspezifischen Sprachen (DSLs) präzise. Es ist auch für Geschäftsanwender lesbar, kostenlos und macht Sie produktiv.

Es gibt viele Frameworks, die uns das Versenden von Nachrichten und das Lösen von Problemen beim Versenden von Nachrichten erleichtern. Ein solches Produkt ist Apache Camel.

Die meisten der häufigsten Probleme haben sich als Lösungen erwiesen, die als Entwurfsmuster bezeichnet werden. Das Entwurfsmuster für Messaging sind Enterprise Integration Patterns (EIPs), die hier ausführlich erläutert werden . Apache Camel hilft uns bei der Implementierung unserer Lösung mithilfe der EIPs.

Die Stärke eines Integrationsframeworks liegt in seiner Fähigkeit, uns durch EIPs oder andere Muster, die Anzahl der Transporte und Komponenten sowie die einfache Entwicklung, auf der Apache-Kamel ganz oben auf der Liste steht, zu erleichtern

Jedes der Frameworks hat seine eigenen Vorteile. Einige der Besonderheiten von Apache Camel sind die folgenden.

1. Es bietet die Codierung für viele DSLs, nämlich Java DSL und Spring XML-basiertes DSL, die sehr beliebt sind.
2. Einfach zu bedienen und einfach zu bedienen.
3. Fuse IDE ist ein Produkt, mit dem Sie über die Benutzeroberfläche codieren können

Im Klartext erledigt Kamel (viele) Dinge ohne viel Kesselplattencode.

Um Ihnen eine Perspektive zu geben, erstellt das unten angegebene Java-DSL einen REST-Endpunkt, der ein aus einer Produktliste bestehendes XML akzeptieren und in mehrere Produkte aufteilen und damit die Process-Methode von BrandProcessor aufrufen kann. Durch einfaches Hinzufügen von .parallelProcessing (beachten Sie den auskommentierten Teil) werden alle Produktobjekte parallel verarbeitet. (Die Produktklasse ist ein von JAXB / XJC generierter Java-Stub aus der XSD, auf den sich die Eingabe-XML beschränkt.) Mit so viel Code (zusammen mit wenigen Camel-Abhängigkeiten) wird die Aufgabe erledigt, die früher 100 Zeilen Java-Code benötigt hat.

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

Nach dem Hinzufügen der Routen-ID und der Protokollierungsanweisung

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

Dies ist nur ein Beispiel, Camel ist viel mehr als nur ein REST-Endpunkt. Schauen Sie sich einfach die Liste der steckbaren Komponenten an: http://camel.apache.org/components.html

Camel hilft beim Routing, der Transformation und der Überwachung.

Es verwendet Routen; was beschrieben werden kann als:

Wenn der Servicebus eine bestimmte Nachricht empfängt, leitet er diese durch keine der Services / Broker-Ziele wie Warteschlange / Themen. Dieser Weg wird als Route bezeichnet.

Beispiel: Ihre Aktienanwendung wurde vom Analysten eingegeben. Sie wird über die Anwendung / Webkomponente verarbeitet und das Ergebnis wird allen interessierten / registrierten Mitgliedern für eine bestimmte Aktienaktualisierung veröffentlicht.

Angenommen, Sie gründen ein E-Commerce-Unternehmen wie Amazon und möchten sich nur auf die Strategie / Auswahl der zu verkaufenden Produkte konzentrieren. Im Gegensatz zur Amazon-Lieferflotte müssen Sie die Waren nicht vom Verkäufer zum Lager transportieren, sondern sie im Lager wie die Verpackung ändern und an andere Städte und Kunden versenden. Sie beauftragen ein Unternehmen, das all dies erledigt, und geben ihm lediglich Informationen zu all Ihren Lagerorten, Fahrzeugtypen, Lieferorten und eine Liste, wann was zu tun ist. Dann erledigen sie das alleine, das wäre Apache Camel. Sie kümmern sich darum, Dinge von einem Ende zum anderen zu bewegen, sobald Sie ihnen etwas übergeben, damit Sie sich auf andere Dinge konzentrieren können.

101 Word Intro

Camel ist ein Framework mit einer konsistenten API und einem Programmiermodell für die Integration von Anwendungen. Die API basiert auf Theorien in Enterprise Integration Patterns, dh einer Reihe von Entwurfsmustern, die tendenziell Messaging verwenden. Es bietet sofort einsatzbereite Implementierungen der meisten dieser Muster und wird zusätzlich mit über 200 verschiedenen Komponenten geliefert, mit denen Sie problemlos mit allen Arten anderer Systeme kommunizieren können. Um Camel zu verwenden, schreiben Sie zuerst Ihre Geschäftslogik in POJOs und implementieren Sie einfache Schnittstellen, die sich um Nachrichten drehen. Verwenden Sie dann das DSL von Camel, um "Routen" zu erstellen, die Regeln zum Zusammenkleben Ihrer Anwendung darstellen.

Erweitertes Intro

An der Oberfläche kann die Funktionalität von Camel mit herkömmlichen Enterprise Service Bus-Produkten mithalten. Wir denken normalerweise, dass eine Camel Route eine "Vermittlungs" -Komponente (auch bekannt als Orchestrierungskomponente) ist, die auf der Serverseite ausgeführt wird. Da es sich jedoch um eine Java-Bibliothek handelt, ist sie einfach einzubetten und kann genauso gut in einer clientseitigen App ausgeführt werden und Ihnen bei der Integration helfen es mit Punkt-zu-Punkt-Diensten (auch bekannt als Choreografie). Sie können sogar Ihre POJOs, die die Nachrichten innerhalb der Camel-Route verarbeiten, nehmen und sie einfach in ihre eigenen Remote-Consumer-Prozesse ausgliedern, z. B. wenn Sie nur ein Stück unabhängig skalieren müssen. Sie können Camel verwenden, um Routen oder Prozessoren je nach Ihren Anforderungen über eine beliebige Anzahl verschiedener Ferntransporte / -protokolle zu verbinden. Benötigen Sie ein äußerst effizientes und schnelles Binärprotokoll? oder eine, die menschlicher lesbar und einfach zu debuggen ist? Was wäre, wenn Sie wechseln wollten? Mit Camel ist dies normalerweise so einfach wie das Ändern einer oder zweier Linien auf Ihrer Route und das Ändern keiner Geschäftslogik. Oder Sie können beides unterstützen - Sie können viele Routen gleichzeitig in einem Kamelkontext ausführen.

Sie müssen Camel nicht wirklich für einfache Anwendungen verwenden, die in einem einzigen Prozess oder in einer JVM ausgeführt werden - das wäre übertrieben. Aber konzeptionell ist es nicht schwieriger als Code, den Sie selbst schreiben können. Und wenn sich Ihre Anforderungen ändern, erleichtert die Trennung von Geschäftslogik und Klebercode die Wartung im Laufe der Zeit. Sobald Sie die Camel-API gelernt haben, können Sie sie einfach wie ein Schweizer Taschenmesser verwenden und schnell in vielen verschiedenen Kontexten anwenden, um die Menge an benutzerdefiniertem Code zu reduzieren, die Sie sonst schreiben müssten. Sie können eine Variante erlernen - beispielsweise Java DSL, eine fließende API, die sich leicht miteinander verketten lässt - und die anderen Varianten leicht erlernen.

Insgesamt ist Camel eine gute Wahl, wenn Sie versuchen, Microservices zu machen. Ich habe festgestellt, dass es für die evolutionäre Architektur von unschätzbarem Wert ist, da Sie viele der schwierigen, leicht zu verwerfenden Entscheidungen über Protokolle, Transporte und andere Systemintegrationsprobleme aufschieben können, bis Sie mehr über Ihre Problemdomäne wissen. Konzentrieren Sie sich einfach auf Ihre EIPs und die Kerngeschäftslogik und wechseln Sie zu neuen Routen mit den "richtigen" Komponenten, wenn Sie mehr erfahren.

Ja, das ist wahrscheinlich etwas spät. Eine Sache, die Sie zu den Kommentaren aller anderen hinzufügen sollten, ist, dass Camel eigentlich eher eine Toolbox als ein vollständiger Satz von Funktionen ist. Sie sollten dies bei der Entwicklung berücksichtigen und verschiedene Transformationen und Protokollkonvertierungen durchführen müssen.

Camel selbst stützt sich auf andere Frameworks und daher müssen Sie diese manchmal auch verstehen, um zu verstehen, welches für Ihre Bedürfnisse am besten geeignet ist. Es gibt zum Beispiel mehrere Möglichkeiten, mit REST umzugehen. Dies kann zunächst etwas verwirrend sein, aber sobald Sie mit dem Verwenden und Testen beginnen, werden Sie sich wohl fühlen und Ihr Wissen über die verschiedenen Konzepte wird zunehmen.

Apache Camel ist ein Java-Framework für die Enterprise-Integration. Beispiel: - Wenn Sie eine Webanwendung erstellen, die mit vielen Hersteller-APIs interagiert, können wir das Kamel als externes Integrationstool verwenden. Je nach Anwendungsfall können wir mehr daraus machen. Camel in Action aus Manning-Veröffentlichungen ist ein großartiges Buch zum Erlernen von Camel. Die Integrationen können wie folgt definiert werden.

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

Hierbei wird lediglich ein REST-API-Endpunkt erstellt, der wiederum eine externe API aufruft und die Anforderung zurücksendet

Frühling 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>

Kommen wir zu Ihren Fragen

1. Was genau ist das? Antwort: - Es ist ein Framework, das Enterprise-Integrationsmuster implementiert
2. Wie interagiert es mit einer in Java geschriebenen Anwendung? Antwort: - Es kann mit allen verfügbaren Protokollen wie http, ftp, amqp usw. Interagieren
3. Passt das zum Server? Antwort: - Es kann in einem Container wie Tomcat oder unabhängig als Java-Prozess bereitgestellt werden
4. Ist es ein unabhängiges Programm? Ans: - Es kann sein.

Ich hoffe es hilft

Apache Camel ist ein leichtes Integrationsframework, das alle Enterprise-Integrationsmuster implementiert. Mit den erforderlichen Mustern können Sie problemlos verschiedene Anwendungen integrieren. Sie können Java, Spring XML, Scala oder Groovy verwenden.

Apache Camel läuft auf der Java Virtual Machine (JVM). ... Die Kernfunktionalität von Apache Camel ist die Routing-Engine. Es ordnet Nachrichten basierend auf den zugehörigen Routen zu. Eine Route enthält Fluss- und Integrationslogik. Es wird mit EIPs und einem bestimmten DSL implementiert.

Es ist wie eine Pipeline, die verbindet

From---->To

Dazwischen können Sie beliebig viele Kanäle und Pipes hinzufügen. Der Wasserhahn kann von jeder Art automatisch oder manuell für den Datenfluss und eine Route zur Kanalisierung des Flusses sein.

Es unterstützt und implementiert alle Arten und Arten der Verarbeitung. Und für die gleiche Verarbeitung viele Ansätze, da es viele Komponenten hat und jede Komponente auch die gewünschte Ausgabe mit verschiedenen Methoden liefern kann.

Beispielsweise kann die Dateiübertragung in Kamel mit verschobenen oder kopierten Dateitypen sowie aus Ordnern, Servern oder Warteschlangen erfolgen.

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

Von / nach ---- Ordner, Direkt, Seda, VM kann alles sein

Ein anderer Gesichtspunkt (basierend auf grundlegenderen mathematischen Themen)

Die allgemeinste Computerplattform ist eine [ https://en.wikipedia.org/wiki/Turing_machine]

Es liegt ein Problem mit der Turing-Maschine vor. Alle Eingabe- / Ausgabedaten verbleiben in der Turingmaschine. In der realen Welt gibt es Eingangsquellen und Ausgangssenken außerhalb unserer Turing-Maschine, die im Allgemeinen von Systemen gesteuert werden, die außerhalb unserer Kontrolle liegen. Das heißt, diese externen Systeme senden / empfangen Daten nach Belieben in einem beliebigen Format mit einem beliebigen gewünschten Datenplaner.

Frage: Wie schaffen wir es, unabhängige Turingmaschinen so allgemein wie möglich miteinander zu sprechen, so dass jede Turingmaschine ihre Kollegen entweder als Quelle für Eingabedaten oder als Senke für Ausgabedaten sieht?

Antwort: Verwenden Sie etwas wie Kamel, Maultier, BizTalk oder ein anderes ESB, das die Datenverarbeitung zwischen der Fertigstellung bestimmter "physischer" (oder virtueller Software-) Turing-Maschinen abstrahiert.