Apache Camel - CamelContext

CamelContext fornisce l'accesso a tutti gli altri servizi in Camel come mostrato nella figura seguente:

Vediamo i vari servizi. IlRegistryPer impostazione predefinita, il modulo è un registro JNDI, che contiene il nome dei vari Javabeans utilizzati dall'applicazione. Se usi Camel con la primavera, questa sarà la primaveraApplicationContext. Se usi Camel nel contenitore OSGI, questo saràOSGI registry. IlType converterscome suggerisce il nome contiene i vari convertitori di tipi caricati, che convertono il tuo input da un formato all'altro. È possibile utilizzare i convertitori di tipi incorporati o fornire il proprio meccanismo di conversione. IlComponentsIl modulo contiene i componenti utilizzati dall'applicazione. I componenti vengono caricati tramite rilevamento automatico suclasspathche specifichi. Nel caso del contenitore OSGI, questi vengono caricati ogni volta che viene attivato un nuovo bundle. Abbiamo già discusso diEndpoints e Routesnei capitoli precedenti. IlData formats il modulo contiene i formati di dati caricati e infine il file Languages il modulo rappresenta le lingue caricate.

Lo snippet di codice qui ti darà un'idea di come un file CamelContext viene creato in un'applicazione Camel -

CamelContext context = new DefaultCamelContext();
try {
   context.addRoutes(new RouteBuilder() {
      // Configure filters and routes
   }
}
);

Il DefaultCamelContext class fornisce un'implementazione concreta di CamelContext. NeladdRoutes metodo, creiamo un'istanza anonima di RouteBuilder. Puoi creare più fileRouteBuilderistanze per definire più di un instradamento. Ogni route nello stesso contesto deve avere un ID univoco. I percorsi possono essere aggiunti dinamicamente in fase di esecuzione. Una rotta con l'ID uguale a quella definita in precedenza sostituirà la rotta precedente.

Cosa va dentro il RouteBuilder istanza è descritta di seguito.

Itinerari

Il router definisce la regola per spostare il messaggio from ad un toPosizione. UsateRouteBuilderper definire un percorso in Java DSL. Si crea un percorso estendendo il file built-inRouteBuilderclasse. Il percorso inizia con afromendpoint e termina in uno o più endpoint. Tra i due, si implementa la logica di elaborazione. È possibile configurare un numero qualsiasi di percorsi all'interno di un singolo fileconfigure metodo.

Ecco un tipico esempio di come viene creato il percorso:

context.addRoutes(new RouteBuilder() {
   @Override
   public void configure() throws Exception {
      from("direct:DistributeOrderDSL")
      .to("stream:out");
   }
}

Sostituiamo il metodo di configurazione di RouteBuilderclass e implementare il nostro meccanismo di routing e filtro in esso. Nel caso corrente, reindirizziamo l'input ricevuto dall'endpointDistributeOrderDSL alla console, che è specificata dall'endpoint stream:out.

Scelta della lingua

Puoi creare i percorsi in diverse lingue. Ecco alcuni esempi di come lo stesso percorso è definito in tre lingue diverse:

Java DSL

from ("file:/order").to("jms:orderQueue");

Spring DSL

<route>
   <from uri = "file:/order"/>
   <to uri = "jms:orderQueue"/>
</route>

Scala DSL

from "file:/order" -> "jms:orderQueue"

Filtri

Utilizzare il filtro per selezionare una parte del contenuto di input. Per impostare un filtro, utilizzare qualsiasi implementazione di Predicate arbitraria . L'input filtrato viene quindi inviato all'endpoint di destinazione desiderato. In questo esempio, filtriamo tutti gli ordini per il sapone in modo che possano essere inviati collettivamente a un fornitore di sapone.

from("direct:DistributeOrderDSL")
   .split(xpath("//order[@product = 'soaps']/items"))
      .to("stream:out");

Nell'esempio abbiamo usato xpathpredicato per il filtraggio. Se preferisci utilizzare la classe Java per il filtraggio, utilizza il codice seguente:

from("direct:DistributeOrderDSL")
   .filter()
      .method(new Order(),"filter")
         .to("stream:out");

Il Order è la tua classe Java personalizzata con il tuo meccanismo di filtraggio.

Puoi combinare più predicati in un unico instradamento come qui -

from("direct:DistributeOrderDSL")
   .choice()
      .when(header("order").isEqualTo("oil"))
         .to("direct:oil")
      .when(header("order").isEqualTo("milk"))
         .to("direct:milk")
      .otherwise()
         .to("direct:d");

Quindi ora tutti gli ordini di "petrolio" andranno al venditore di petrolio, gli ordini di "latte" andranno al venditore di latte e il resto a un pool comune.

Processore personalizzato

Puoi anche utilizzare l'elaborazione personalizzata. L'esempio seguente crea un processore personalizzato chiamatomyCustomProcessor e lo utilizza nel generatore di percorsi.

Processor myCustomProcessor = new Processor() {
   public void process(Exchange exchange) {
      // implement your custom processing
   }
};
RouteBuilder builder = new RouteBuilder() {
   public void configure() {
      from("direct:DistributeOrderDSL")
      .process(myProcessor);
   }
};

Puoi utilizzare processori personalizzati insieme alla scelta e al filtro per ottenere un controllo migliore sulla mediazione e sul routing -

from("direct:DistributeOrderDSL")
   .filter(header("order").isEqualTo("milk"))
      .process(myProcessor);

Utilizzando XML

Le rotte possono essere definite in XML più voluminoso, se lo preferisci. Il seguente frammento XML mostra come creare un percorso insieme ad alcuni filtri tramite Spring XML -

<camelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "direct:DistributeOrderXML"/>
      <log message = "Split by Distribute Order"/>
      <split>
         <xpath>//order[@product = 'Oil']/items</xpath>
         <to uri = "file:src/main/resources/order/"/>
         <to uri = "stream:out"/>
      </split>
   </route>
</camelContext>

Dopo aver visto come vengono costruite le rotte, vedremo ora le varie tecniche di creazione degli Endpoint.