streamalism.org

1. Oversikt

Denne artikkelen vil demonstrere hvordan du konfigurerer og bruker Apache Camel with Spring.

Apache Camel tilbyr ganske mange nyttige komponenter som støtter biblioteker som JPA, Hibernate, FTP, Apache-CXF, AWS-S3 og selvfølgelig mange andre - alt for å hjelpe med å integrere data mellom to forskjellige systemer.

Hvis du for eksempel bruker Hibernate og Apache CXF-komponentene, kan du hente data fra en database og sende dem til et annet system over REST API-anrop.

I denne opplæringen går vi over et enkelt Camel-eksempel - å lese en fil og konvertere innholdet til store bokstaver og deretter tilbake til små bokstaver. Vi skal bruke Camels filkomponent og våren 4.2.

Her er de fulle detaljene i eksemplet:

1. Les filen fra kildekatalogen
2. Konverter filinnhold til store bokstaver ved hjelp av en tilpasset prosessor
3. Skriv konvertert utdata til en destinasjonskatalog
4. Konverter filinnhold til små bokstaver ved hjelp av Camel Translator
5. Skriv konverterte utdata til en destinasjonskatalog

2. Legg til avhengigheter

For å bruke Apache Camel with Spring, trenger du følgende avhengigheter i POM-filen:

 2.16.1 4.2.4.RELEASE org.apache.camel kamelkjerne $ {env.camel.version} org.apache.camel kamelfjær $ {env.camel.version} org.apache.camel camel-stream $ { env.camel.version} org.springframework spring-context $ {env.spring.version} 

Så vi har:

• kamelkjerne - den viktigste avhengigheten av Apache Camel
• kamelfjær - gjør at vi kan bruke Camel with Spring
• kamelstrøm - en valgfri avhengighet, som du kan bruke (for eksempel) til å vise noen meldinger på konsollen mens ruter kjører
• vår-kontekst - standard våravhengighet, som kreves i vårt tilfelle da vi skal kjøre kamelruter i vårsammenheng

3. Vårkamelkontekst

Først oppretter vi vårkonfigurasjonsfilen der vi senere vil definere kamelruter.

Legg merke til hvordan filen inneholder alle nødvendige Apache Camel og Spring navneområder og skjemaplasseringer:

De element representerer (ikke overraskende) kamelkonteksten, som kan sammenlignes med en vårapplikasjonskontekst. Nå er kontekstfilen klar til å begynne å definere kamelruter.

3.1. Kamelrute med tilpasset prosessor

Deretter skriver vi vår første rute for å konvertere filinnhold til store bokstaver.

Vi må definere en kilde som ruten vil lese data fra. Dette kan være en database, fil, konsoll eller et hvilket som helst antall andre kilder. I vårt tilfelle blir det arkiv.

Deretter må vi definere prosessoren for dataene som skal leses fra kilden. For dette eksemplet skal vi skrive en tilpasset prosessorklasse. Denne klassen vil være en vårbønne som vil implementere standard Camel Processor Interface.

Når dataene er behandlet, må vi fortelle ruten dit de behandlede dataene skal henvises. Nok en gang kan dette være en av et bredt utvalg av utganger, for eksempel en database, fil eller konsoll. I vårt tilfelle skal vi lagre det i en fil.

For å sette opp disse trinnene, inkludert inngang, prosessor og utgang, legger du til følgende rute i Camel-kontekstfilen:

I tillegg må vi definere myFileProcessor bønne:

3.2. Egendefinert store prosessor

Nå må vi lage den tilpassede filprosessoren vi definerte i bønnen vår. Den må implementere kamel Prosessor grensesnitt, definere en enkelt prosess metode, som tar en Utveksling objektet som inngang. Dette objektet gir informasjon om dataene fra inngangskilden.

Metoden vår må lese meldingen fra Utveksling, store bokstaver og deretter sette det nye innholdet tilbake i Utveksling gjenstand:

offentlig klasse FileProcessor implementerer prosessor {public void process (Exchange exchange) kaster Unntak {String originalFileContent = (String) exchange.getIn (). getBody (String.class); Streng upperCaseFileContent = originalFileContent.toUpperCase (); exchange.getIn (). setBody (upperCaseFileContent); }}

Denne prosessmetoden vil bli utført for hver inngang som mottas fra kilden.

3.3. Små prosessor

Nå vil vi legge til en ny utgang til Camel-ruten vår. Denne gangen vil vi konvertere dataene til den samme inndatafilen til små bokstaver. Denne gangen bruker vi imidlertid ikke en tilpasset prosessor; vi vil bruke Apache Camels Message Translator-funksjon. Dette er den oppdaterte kamelruten:

     $ {body.toLowerCase ()} 

4. Kjøre applikasjonen

For å få våre ruter behandlet, trenger vi bare å laste Camel-kontekstfilen inn i en vår-applikasjonskontekst:

ClassPathXmlApplicationContext applicationContext = ny ClassPathXmlApplicationContext ("camel-context.xml"); 

Når ruten er kjørt vellykket, vil to filer ha blitt opprettet: en med store bokstaver og en med små bokstaver.

5. Konklusjon

Hvis du gjør integrasjonsarbeid, kan Apache Camel definitivt gjøre ting enklere. Biblioteket tilbyr plug-and-play-komponenter som hjelper deg med å redusere kjeleplatekoden og fokusere på hovedlogikken for behandling av data.

Og hvis du vil utforske Enterprise Integration Patterns-konseptene i detalj, bør du ta en titt på denne boka skrevet av Gregor Hohpe og og Bobby Woolf, som konseptualiserer EIP-ene veldig rent.

Eksemplet beskrevet i denne artikkelen er tilgjengelig i et prosjekt på GitHub.