Inleiding tot Apache Camel

1. Overzicht

In dit artikel zullen we introduceer Camel en verken een van zijn kernconcepten: berichtroutering.

We beginnen met het behandelen van deze basisconcepten en terminologie, en vervolgens presenteren we twee hoofdopties voor het definiëren van routes: Java DSL en Spring DSL.

We zullen deze ook demonstreren in een voorbeeld - door een route te definiëren die bestanden uit de ene map verbruikt en naar een andere verplaatst, terwijl een tijdstempel wordt toegevoegd aan elke bestandsnaam.

2. Over Apache Camel

Apache Camel is een open source integratieframework dat is ontworpen om het integreren van systemen eenvoudig en gemakkelijk te maken.

Het stelt eindgebruikers in staat om verschillende systemen te integreren met behulp van dezelfde API, en biedt ondersteuning voor meerdere protocollen en gegevenstypen, terwijl het uitbreidbaar is en de introductie van aangepaste protocollen mogelijk maakt.

3. Maven afhankelijkheden

Om Camel te kunnen gebruiken, moeten we eerst de Maven-afhankelijkheid toevoegen:

 org.apache.camel camel-core 2.18.0 

De nieuwste versie van het Camel-artefact is hier te vinden.

3. Domeinspecifieke taal

Routes en routing-engine vormen het centrale deel van Camel. Routes bevatten de stroom en logica van integratie tussen verschillende systemen.

Om routes gemakkelijker en overzichtelijker te definiëren, biedt Camel verschillende domeinspecifieke talen (DSL) voor programmeertalen zoals Java of Groovy. Aan de andere kant biedt het ook het definiëren van routes in XML met Spring DSL.

Het gebruik van Java DSL of Spring DSL heeft meestal de voorkeur van de gebruiker, aangezien de meeste functies in beide beschikbaar zijn.

Java DSL biedt iets meer functies die niet worden ondersteund in Spring DSL. Spring DSL is echter soms voordeliger omdat XML kan worden gewijzigd zonder dat de code opnieuw hoeft te worden gecompileerd.

4. Terminologie en architectuur

Laten we nu de basisterminologie en architectuur van Camel bespreken.

Eerst zullen we de kernconcepten van Camel hier bekijken:

  • Bericht bevat gegevens die naar een route worden overgebracht. Elk bericht heeft een unieke ID en is opgebouwd uit een hoofdtekst, kopteksten en bijlagen
  • Uitwisseling is de container van een bericht en wordt gemaakt wanneer een bericht tijdens het routeringsproces door een consument wordt ontvangen. Exchange maakt verschillende soorten interactie tussen systemen mogelijk - het kan een eenrichtingsbericht of een verzoek-antwoordbericht definiëren
  • Eindpunt is een kanaal waardoor het systeem een ​​bericht kan ontvangen of verzenden. Het kan verwijzen naar een webservice-URI, wachtrij-URI, bestand, e-mailadres, enz
  • Component fungeert als een endpoint-fabriek. Simpel gezegd, componenten bieden een interface naar verschillende technologieën die dezelfde benadering en syntaxis gebruiken. Camel ondersteunt al veel componenten in zijn DSL's voor bijna elke mogelijke technologie, maar het biedt ook de mogelijkheid om aangepaste componenten te schrijven
  • Verwerker is een eenvoudige Java-interface die wordt gebruikt om aangepaste integratielogica aan een route toe te voegen. Het bevat een enkele werkwijze methode die wordt gebruikt om aangepaste bedrijfslogica uit te voeren op een bericht dat door een consument is ontvangen

Op hoog niveau is de architectuur van Camel eenvoudig. CamelContext vertegenwoordigt het Camel runtime-systeem en bedraadt verschillende concepten zoals routes, componenten of eindpunten.

En daaronder zorgen processors voor routing en transformaties tussen eindpunten, terwijl eindpunten verschillende systemen integreren.

5. Een route definiëren

Routes kunnen worden gedefinieerd met Java DSL of Spring DSL.

We zullen beide stijlen illustreren door een route te definiëren die bestanden uit de ene map verbruikt en ze naar een andere map verplaatst, terwijl voor elke bestandsnaam een ​​tijdstempel wordt toegevoegd.

5.1. Routing met Java DSL

Om een ​​route met Java DSL te definiëren, moeten we eerst een DefaultCamelContext voorbeeld. Daarna moeten we verlengen RouteBuilder class en implementeer het configureren methode die routestroom bevat:

privé statische laatste lange DURATION_MILIS = 10000; private static final String SOURCE_FOLDER = "src / test / source-folder"; private static final String DESTINATION_FOLDER = "src / test / bestemmingsmap"; @Test openbare ongeldige moveFolderContentJavaDSLTest () gooit uitzondering {CamelContext camelContext = nieuwe DefaultCamelContext (); camelContext.addRoutes (nieuwe RouteBuilder () {@Override public void configure () genereert Uitzondering {van ("file: //" + SOURCE_FOLDER + "? delete = true"). process (nieuwe FileProcessor ()). naar ("file : // "+ DESTINATION_FOLDER);}}); camelContext.start (); Thread.sleep (DURATION_MILIS); camelContext.stop (); }

De configureren methode kan als volgt worden gelezen: lees bestanden uit de bronmap, verwerkt ze met FileProcessor en stuur het resultaat naar een bestemmingsmap. Instelling delete = true betekent dat het bestand wordt verwijderd uit de bronmap nadat het met succes is verwerkt.

Om Camel te starten, moeten we bellen begin methode op CamelContext. Draad. Slaap wordt aangeroepen om Camel de tijd te geven die nodig is om de bestanden van de ene map naar de andere te verplaatsen.

FileProcessor werktuigen Verwerker interface en bevat single werkwijze methode die logica bevat voor het wijzigen van bestandsnamen:

public class FileProcessor implementeert Processor {public void process (Exchange exchange) gooit uitzondering {String originalFileName = (String) exchange.getIn (). getHeader (Exchange.FILE_NAME, String.class); Datum datum = nieuwe datum (); SimpleDateFormat dateFormat = nieuwe SimpleDateFormat ("jjjj-MM-dd HH-mm-ss"); Tekenreeks changeFileName = dateFormat.format (datum) + originalFileName; exchange.getIn (). setHeader (Exchange.FILE_NAME, gewijzigde bestandsnaam); }}

Om de bestandsnaam op te halen, moeten we een inkomend bericht van een centrale ophalen en toegang krijgen tot de koptekst. Net als dat, om de bestandsnaam te wijzigen, moeten we de berichtkop bijwerken.

5.2. Routing met Spring DSL

Bij het definiëren van een route met Spring DSL gebruiken we een XML-bestand om onze routes en processors in te stellen. Dit stelt ons in staat om routes te configureren zonder code door Spring te gebruiken en geeft ons uiteindelijk het voordeel van totale omkering van de controle.

Dit werd al behandeld in een bestaand artikel, dus we zullen ons concentreren op het gebruik van zowel Spring DSL als Java DSL, wat gewoonlijk een geprefereerde manier is om routes te definiëren.

In deze opstelling wordt CamelContext gedefinieerd in Spring XML-bestand met behulp van aangepaste XML-syntaxis voor Camel, maar zonder de routedefinitie zoals in het geval van "pure" Spring DSL met XML:

Op deze manier vertellen we Camel om te gebruiken FileRouter klasse die de definitie van onze route in Java DSL bevat:

openbare klasse FileRouter breidt RouteBuilder uit {privé statische laatste String SOURCE_FOLDER = "src / test / source-folder"; private static final String DESTINATION_FOLDER = "src / test / bestemmingsmap"; @Override public void configure () gooit uitzondering {from ("file: //" + SOURCE_FOLDER + "? Delete = true"). Proces (nieuwe FileProcessor ()). Naar ("file: //" + DESTINATION_FOLDER); }}

Om dit te testen, moeten we een instantie van ClassPathXmlApplicationContext die onze CamelContext in de lente:

@Test openbare ongeldige moveFolderContentSpringDSLTest () gooit InterruptedException {ClassPathXmlApplicationContext applicationContext = nieuwe ClassPathXmlApplicationContext ("camel-context.xml"); Thread.sleep (DURATION_MILIS); applicationContext.close (); }

Door deze aanpak te gebruiken, krijgen we extra flexibiliteit en voordelen van Spring, evenals alle mogelijkheden van Java-taal door Java DSL te gebruiken.

6. Conclusie

In dit korte artikel hebben we een inleiding tot Apache Camel gepresenteerd en de voordelen aangetoond van het gebruik van Camel voor integratietaken zoals het routeren van bestanden van de ene map naar de andere.

In ons voorbeeld hebben we gezien dat Camel u laat focussen op bedrijfslogica en de hoeveelheid standaardcode vermindert.

Code uit dit artikel is te vinden op GitHub.