Java >> Java tutorial >  >> Java

Tutorial til Apache Camel Routing

1.Introduktion

Data, der udveksles mellem virksomheder, er steget meget. Antallet af applikationer, som skal integreres, er også stigende. Grænsefladerne bruger forskellige teknologier, protokoller og dataformater. Ikke desto mindre skal integrationen af ​​disse applikationer modelleres på en standardiseret måde, realiseres effektivt og understøttes af automatiske tests. En sådan standard findes med Enterprise Integration Patterns (EIP), som er blevet industristandarden til at beskrive, dokumentere og implementere integrationsproblemer. Apache Camel implementerer EIP'erne og tilbyder et standardiseret, internt domænespecifikt sprog (DSL) til at integrere applikationer. Denne artikel giver en introduktion til Apache Camel inklusive adskillige kodeeksempler.

Indholdsfortegnelse

1. Indledning
2. Hvad er Enterprise Integration Patterns
3. Grundlæggende begreber om Apache Camel
3.1. Arkitekturen af ​​Apache Camel
3.2. Hvad er CamelContext
3.3. Hvad er ruter
3.3. Hvad er komponenter
4. Teknologistabel
5. Eksempler på Apache Camel Routing
5.1. Afhængigheder
5.2. XML-anmodning
5.3. Spring XML-baseret konfiguration
5.4. Java DSL-baseret konfiguration
6. Resumé
7. Referencer
8. Download Spring Tool Suite Project

2. Hvad er Enterprise Integration Patterns

Som navnet antyder, er disse testede løsninger til specifikke designproblemer, man støder på i mange år i udviklingen af ​​IT-systemer. Og så meget desto vigtigere er, at de er teknologiagnostiske, hvilket betyder, at det er ligegyldigt, hvilket programmeringssprog eller hvilket operativsystem du bruger.
EIP'er kan bruges til at opdele integrationsproblemer i mindre stykker og modellere dem ved hjælp af standardiseret grafik . Alle kan nemt forstå disse modeller. Desuden er der ingen grund til at genopfinde hjulet hver gang for hvert integrationsproblem.

Mønstre er opdelt i syv sektioner:
1. Beskedsystemer
2. Beskedkanaler
3. Meddelelseskonstruktioner
4. Meddelelsesruting
5. Meddelelsestransformation
6. Beskedslutpunkter
7. Systemstyring

Ved at bruge EIP'er lukker Apache Camel et hul mellem modellering og implementering. Der er næsten et en-til-en forhold mellem EIP-modeller og Apache Camels DSL.

3. Grundlæggende begreber om Apache Camel

Apache Camel er et open source-projekt og implementering af berømte Enterprise Integration Patterns. Kernen i Apache Camel er meget lille og indeholder blot almindeligt anvendte komponenter (dvs. forbindelser til flere teknologier og API'er) såsom Log, File, Mock eller Timer.

Yderligere komponenter kan nemt tilføjes på grund af den modulære opbygning af Apache Camel. Maven anbefales til afhængighedsstyring, fordi de fleste teknologier kræver yderligere biblioteker. Selvom biblioteker selvfølgelig også kan downloades manuelt og tilføjes til klassestien.

Kernefunktionaliteten i Apache Camel er dens routingmotor. Den tildeler beskeder baseret på de relaterede ruter. En rute indeholder flow og integrationslogik. Det implementeres ved hjælp af EIP'er og en specifik DSL. Hver besked indeholder en brødtekst, flere overskrifter og valgfri vedhæftede filer. Beskederne sendes fra en udbyder til en forbruger. Ind imellem kan beskederne behandles, f.eks. filtreret eller transformeret.

Beskeder mellem en udbyder og en forbruger administreres af en meddelelsesudvekslingsbeholder, som indeholder et unikt meddelelses-id, undtagelsesinformation, indgående og udgående meddelelser (dvs. anmodning og svar) og det anvendte meddelelsesudvekslingsmønster (MEP). In-Only MEP bruges til envejsmeddelelser såsom JMS, mens In-Out MEP udfører anmodning-svar-kommunikation såsom en klient-side HTTP-baseret anmodning og dens svar fra serversiden.

Efter en kort forklaring af de grundlæggende begreber i Apache Camel, vil de følgende afsnit give flere detaljer og kodeeksempler.

3.1 Arkitekturen af ​​Apache Camel

Camel bruger et Java-baseret Routing Domain Specific Language (DSL) eller en XML-konfiguration til at konfigurere routing- og formidlingsregler, som føjes til en CamelContext for at implementere de forskellige Enterprise Integration Patterns.

På et højt niveau består Camel af en CamelContext, som indeholder en samling af komponentforekomster. En komponent er i bund og grund en fabrik af Endpoint-instanser. Du kan eksplicit konfigurere komponentforekomster i Java-kode eller en IoC-beholder som Spring eller Guice, eller de kan automatisk opdages ved hjælp af URI'er.

Et slutpunkt fungerer snarere som en URI eller URL i en webapplikation eller en Destination i et JMS-system; du kan kommunikere med et slutpunkt; enten at sende beskeder til det eller indtage beskeder fra det. Du kan derefter oprette en producent eller forbruger på et slutpunkt for at udveksle meddelelser med den.

DSL gør stor brug af pluggbare sprog til at skabe et udtryk eller prædikat for at lave en virkelig kraftfuld DSL, som kan udvides til det mest passende sprog afhængigt af dine behov.

For at få detaljerede oplysninger om arkitekturen, brug dette link http://camel.apache.org/architecture.html

3.2 Hvad er CamelContext

CamelContext er Apache Camels runtime-system og forbinder dets forskellige koncepter såsom ruter, komponenter eller endepunkter.

Nedenfor er de trin, vi skal overveje, når vi konfigurerer CamelContext:

  1. Opret CamelContext.
  2. Tilføj slutpunkter eller komponenter.
  3. Tilføj ruter for at forbinde slutpunkterne.
  4. Bring CamelContext.start() – Dette starter alle kamel-interne tråde, som er ansvarlige for at modtage, sende og behandle beskeder i endepunkterne.
  5. Til sidst skal du kalde CamelContext.stop() når alle beskeder udveksles og behandles. Dette vil yndefuldt stoppe alle kamel-interne tråde og endepunkter.

Følgende kodestykke viser en Java-hovedmetode, som starter CamelContext og stopper den efter 30 sekunder. Normalt startes CamelContext, når applikationen indlæses, og stoppes ved nedlukning.

CamelStarter.java

public class CamelStarter {
public static void main(String[] args) throws Exception {
	CamelContext context = new DefaultCamelContext();
	context.addRoutes(new IntegrationRoute());
	context.start();
	Thread.sleep(30000);
	context.stop();
	}
}

3.3 Hvad er ruter

Ruter er en afgørende del af Apache Camel. En integrations flow og logik er specificeret her. Følgende eksempel viser en rute ved hjælp af Java DSL:

MyFirstRouterBuilder.java

import org.apache.camel.builder.RouteBuilder;

public class MyFirstRouterBuilder extends RouteBuilder {
     @Override
    public void configure() throws Exception {
        try{
            from( "file:d:/vids").to("file:d:/temp");
        }catch(Exception e){

        }
     }
}

DSL er let at bruge. Alle burde være i stand til at forstå ovenstående eksempel uden overhovedet at kende Apache Camel. Ruten realiserer en del af den beskrevne use case. Ordrer lægges i en filmappe fra en ekstern kilde. Ordrerne behandles og flyttes til sidst til målkataloget.

Ruter skal forlænge RouteBuilder klasse og tilsidesætte configure metode. Selve ruten begynder med en from slutpunkt og slutter ved en eller flere to endepunkter. Ind imellem implementeres al nødvendig proceslogik. Et vilkårligt antal ruter kan implementeres inden for én configure metode.

Følgende uddrag viser den samme rute realiseret via Spring XML DSL:

applicationcontext.xml

<beans … >
<bean class="mwea.TransformationBean" id="transformationBean"/>
<bean class="mwea.LoggingProcessor" id="loggingProcessor"/>
<camelContext xmlns="http://camel.apache.org/schema/spring">
<package>mwea</package>
<route>
        <from uri="file:target/inbox"/>
                    <process ref="loggingProcessor"/>
                    <bean ref="transformationBean"/>
        <to uri="file:target/outbox"/>
    </route>
</camelContext>
</beans>

3.4 Hvad er komponenter

I mellemtiden er over 100 komponenter tilgængelige. Udover udbredte teknologier som HTTP, FTP, JMS eller JDBC, understøttes mange flere teknologier, herunder skytjenester fra Amazon, Google, GoGrid og andre. Nye komponenter tilføjes i hver udgivelse. Ofte bygger også fællesskabet nye brugerdefinerede komponenter, fordi det er meget nemt.

Den mest fantastiske egenskab ved Apache Camel er dens ensartethed. Alle komponenter bruger samme syntaks og koncepter. Enhver integration og endda dens automatiske enhedstest ser ens ud. Dermed reduceres kompleksiteten meget. Overvej at ændre ovenstående eksempel:Hvis ordrer skal sendes til en JMS-kø i stedet for en filmappe, skal du bare ændre to slutpunkt fra file:target/outbox til jms:queue:orders . Det er det! (JMS skal selvfølgelig konfigureres én gang i applikationen før).

For at få en fornemmelse af Camels alsidighed kan du gennemse listen over komponenter og URI'er, den understøtter ved at bruge linket http://camel.apache.org/components.html

4. Teknologistabel

I dette eksempel vil vi bruge følgende teknologistak:

  1. Maven 4.0 – Byg og afhængighedsværktøj. Du kan besøge her for at få flere detaljer
  2. Apache Camel 2.15.1 – Open source integrationsramme baseret på kendte Enterprise Integration Patterns.
  3. Forår 4.1.5.RELEASE – Omfattende programmerings- og konfigurationsmodel til moderne Java-baserede virksomhedsapplikationer
  4. Spring Tool Suite (STS) – Et Eclipse-baseret udviklingsmiljø, der er tilpasset til udvikling af Spring-applikationer.
  5. ActiveMQ binære distributioner – Den seneste stabile udgivelse er ActiveMQ 5.14.5-udgivelsen. Se downloadarkiverne for alle tidsudgivelser.

5. Eksempler på Apache Camel Routing

Hvordan man implementerer de forskellige måder at Apache Camel Routing på.

5.1 Afhængigheder

For at fortsætte med at bruge vores eksempel, skal vi tilføje de afhængige jar-filer til klassestien. Dette kan opnås enten ved at implementere jar-filen direkte eller ved at bruge Maven. Da vi bruger Maven til vores eksempel, vil vi bruge pom.xml til afhængigheden af ​​følgende krukker:

  • Camel-Core
  • Camel-Stream
  • Camel-JMS
  • ActiveMQ-Camel
  • Kamel-Forår
  • Forår-kontekst

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.springframework.samples</groupId>
  <artifactId>AMQP</artifactId>
  <version>0.0.1-SNAPSHOT</version>
	<dependencies>
		<dependency>
			<groupId>org.apache.camel</groupId>
			<artifactId>camel-core</artifactId>
			<version>2.15.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.camel</groupId>
			<artifactId>camel-stream</artifactId>
			<version>2.15.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.camel</groupId>
			<artifactId>camel-jms</artifactId>
			<version>2.15.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-camel</artifactId>
			<version>5.6.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-pool</artifactId>
			<version>5.11.1</version>
		</dependency>		
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.1.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.apache.camel</groupId>
			<artifactId>camel-spring</artifactId>
			<version>2.15.1</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.12</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.12</version>
		</dependency>
	</dependencies>	
</project>

5.2 XML-anmodning

Nedenstående XML-anmodning bruges til at sende som en inputmeddelelse til en JMS-kø eller et emne og forbruge meddelelser fra en JMS-kø eller et emne.

order.xml

<?xml version="1.0" encoding="UTF-8"?>
<orders>
	<order product="electronics">
		<items>
			<item>Laptop</item>
			<item>Mobile</item>
		</items>
	</order>
	<order product="books">
		<items>
			<item>Design Patterns</item>
			<item>XML</item>
		</items>
	</order>
</orders>

5.3 Spring XML-baseret konfiguration

Camel Spring XML-udvidelserne giver dig mulighed for at bruge en meget kortfattet XML-syntaks til at beskrive din Camel-konfiguration, når du bruger Spring til at forbinde din applikation.

SpringXMLRoute.java

package com.camelrouting;

import java.io.FileInputStream;
import java.io.InputStream;

import org.apache.camel.CamelContext;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.spring.SpringCamelContext;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringXMLRoute {

	public static void main(String[] args) throws Exception { 
	ApplicationContext appContext = new ClassPathXmlApplicationContext(
            "SpringXMLRouteContext.xml");
    CamelContext camelContext = SpringCamelContext.springCamelContext(
            appContext, false);
    try {            
        camelContext.start();
        ProducerTemplate template = camelContext.createProducerTemplate();
        InputStream orderxml = new FileInputStream("src/main/resources/order.xml");
        template.sendBody("direct:SpringXMLRouteStart", orderxml);
    } finally {
        camelContext.stop();
    }

	}

}

Applikationskontekstfil til at filtrere routingmeddelelse til den eksterne fil.

SpringXMLRouteContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
       ">
       
	<camelContext xmlns="http://camel.apache.org/schema/spring" >
		<route>
			<from uri="direct:SpringXMLRouteStart" />
			<log message="Split by article Element"/>
			
			<!--To printout the filter routing message to the external file  -->
			<split>
				<xpath>//order[@product='electronics']/items</xpath>
				<to uri="file:src/main/resources/orderxmlroute/"  />
			</split>
		</route>
	
	</camelContext>

</beans>

Application Context File til at udskrive routingmeddelelsen på IDE-konsollen.

SpringXMLRouteContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
       ">
       
        
	<camelContext xmlns="http://camel.apache.org/schema/spring" >
		<route>
			<from uri="direct:SpringXMLRouteStart" />
			<!-- To printout the routing message on the IDE console  -->
			<to uri="stream:out" /> 
		</route>
	
	</camelContext>

</beans>

Applikationskontekstfil til at konfigurere Active MQ Messaging Queue.

SpringXMLRouteContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
       ">
       
	<!--The Active MQ messaging Queue configuration  -->    
	<!-- Active MQ WebConsole URL : http://localhost:8161/ -->   
	
	<bean id="jmsConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://localhost:61616/" />
	</bean>
	<bean id="jmsConfig" 
	   class="org.apache.camel.component.jms.JmsConfiguration">
	   <property name="connectionFactory" ref="jmsConnectionFactory"/>
	   <property name="concurrentConsumers" value="10"/>
	</bean>   
    <bean id="activemq"
            class="org.apache.activemq.camel.component.ActiveMQComponent">
            <property name="configuration" ref="jmsConfig"/>
    </bean>
    
       
       
       
	<camelContext xmlns="http://camel.apache.org/schema/spring" >
		<route>
			<from uri="direct:SpringXMLRouteStart" />
			<log message="Split by article Element"/>
	
			<!--To send the filter routing message to the Messaging Queue  -->
			<!-- <choice>
	            <when>
	                <xpath>//order[@product='electronics']/items</xpath>
	                <to uri="activemq:queue:Q1"/>
	            </when>
	            <when>
	                <xpath>//order[@product='books']/items</xpath>
	                <to uri="activemq:queue:Q2"/>
	            </when>
	            <otherwise>
	                <to uri="activemq:queue:Q3"/>
	            </otherwise>
       	     </choice>
			
			
		</route>
	
	</camelContext>
</beans>

5.4 Java DSL-baseret konfiguration

Apache Camel tilbyder en Java-baseret DSL ved hjælp af den flydende builder-stil. Java DSL er tilgængelig ved at udvide RouteBuilder klasse og implementer configure metode.

JavaDSLRoute Java-klasse for at filtrere routingmeddelelse til den eksterne fil.

JavaDSLRoute.java

package  com.camelrouting;

import java.io.FileInputStream;
import java.io.InputStream;

import org.apache.camel.CamelContext;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;

public class JavaDSLRoute {
	
	public static void main(String[] args) throws Exception {
		CamelContext context = new DefaultCamelContext();
		
		try {
		
			context.addRoutes(new RouteBuilder() {
				@Override
				public void configure() throws Exception {
					from("direct:JavaDSLRouteStart").
				
					//To filter routing message to the external file 
						split(xpath("//order[@product='electronics']/items")).
						to("file:src/main/resources/orderxmlroute/");
				}
			});
			context.start();
			ProducerTemplate template = context.createProducerTemplate();
			InputStream orderxml = new FileInputStream("src/main/resources/order.xml");
			template.sendBody("direct:JavaDSLRouteStart", orderxml);
		} finally {
			context.stop();
		}
	}
}

JavaDSLRoute Java-klasse til at dirigere besked på IDE-konsollen.

JavaDSLRoute.java

package  com.camelrouting;

import java.io.FileInputStream;
import java.io.InputStream;

import org.apache.camel.CamelContext;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;

public class JavaDSLRoute {
	
	public static void main(String[] args) throws Exception {
		CamelContext context = new DefaultCamelContext();
		
		try {
			context.addRoutes(new RouteBuilder() {
				@Override
				public void configure() throws Exception {
					from("direct:JavaDSLRouteStart").
					// To route message on the IDE console  
						to("stream:out");
				}
				});
			context.start();
			ProducerTemplate template = context.createProducerTemplate();
			InputStream orderxml = new FileInputStream("src/main/resources/order.xml");
			template.sendBody("direct:JavaDSLRouteStart", orderxml);
		} finally {
			context.stop();
		}
	}
}

6. Resumé

Her i dette Apache Camel Routing-eksempel har vi lært om den forskellige måde at konfigurere kamelruten til forskellige formål på som følger:

  • For at filtrere routingmeddelelse til den eksterne fil.
  • For at udskrive routingmeddelelsen på IDE-konsollen.
  • For at konfigurere Active MQ Messaging Queue.

Så nu er du klar til at implementere ruterne i Apache Camel-applikationerne.

7. Referencer

  1. http://camel.apache.org/
  2. http://camel.apache.org/routes.html
  3. http://camel.apache.org/message-router.html
  4. http://camel.apache.org/enterprise-integration-patterns.html

8. Download Spring Tool Suite Project


Java tag