Fusibile JBoss - Guida rapida

In questo capitolo inizieremo con gli elementi essenziali di Enterprise Service Bus. Di seguito è riportata una spiegazione dettagliata dell'ESB insieme ai suoi vantaggi, svantaggi e un paio di diagrammi per una più facile comprensione.

Cos'è ESB?

ESB sta per Enterprise Service Bus. ESB nella sua forma più semplice è un middleware che funge da autostrada dell'informazione che aiuta più applicazioni a comunicare.

Nel mondo aziendale, sviluppiamo soluzioni per molte cose. Queste soluzioni possono utilizzare diverse tecnologie e diversi formati di dati. Diventa scomodo utilizzare queste soluzioni insieme a causa della varianza di compatibilità della comunicazione o del formato dei dati in queste tecnologie. Quindi abbiamo bisogno di una tecnologia che lo permettaloosely coupled integration tra queste diverse soluzioni.

ESB mira a semplificare questo problema di integrazione diventando un "HUB" che si trova al centro di tutte le applicazioni e facilita l'instradamento dei messaggi tra di loro. ESB funge da mediatore, agendo come un'autostrada dell'informazione, occupandosi dell'instradamento della trasformazione dei dati, lasciando che il Coder o lo Sviluppatore si concentrino sulla propria logica applicativa.

Capire ESB diventa molto semplice quando capiamo il problema per il quale è stato appositamente progettato e la soluzione diventa facile. Si dovrebbe avere una chiara comprensione di come abilitare molti sistemi disparati, scritti in lingue diverse e in esecuzione su macchine diverse utilizzando diversi formati di dati per condividere le informazioni e formare una piattaforma aziendale integrata.

Il problema dell'integrazione

Nella piattaforma aziendale, è comune che più applicazioni collaborino e forniscano funzionalità aziendali nel suo insieme, ma l'integrazione di queste applicazioni è il problema più ricorrente. Con il tempo diventa persino difficile man mano che le applicazioni crescono.

Ogni applicazione può inserire e produrre dati nel proprio formato. Questo approccio funziona bene se il numero di applicazioni è inferiore, ma con l'aumentare del numero di applicazioni, anche le ruote di integrazione devono essere sfornate con un approccio migliore. Ad esempio, se una particolare applicazione per un'azienda deve essere modificata, il formato dei dati di output o di input per tutte le applicazioni che dipendono dall'applicazione principale ne risente.

Un tale approccio rappresenta il più grande ostacolo per l'integrazione che prevede un'architettura strettamente accoppiata. È qui che entra in gioco ESB. Ogni applicazione non deve comunicare direttamente con un'altra applicazione; invece, tutte le applicazioni comunicano con l'ESB e l'ESB gestisce l'instradamento delle informazioni e la conversione interna del formato dei dati.

Perché ESB?

Di seguito sono riportati alcuni punti che spiegano perché Enterprise Service Bus è essenziale.

ESB mira a semplificare il problema dell'integrazione con applicazioni compatibili con varianti.
Funge da middleware, che funge da mediatore di tutte le applicazioni e facilita il routing dei messaggi tra di loro.
Invece di ogni applicazione che si interfaccia direttamente con ogni altra applicazione, ogni applicazione ora ha solo un'interfaccia per ESB.
L'ESB è responsabile della traduzione dei messaggi da / verso un formato comune e del loro instradamento alle loro destinazioni.
Il maggiore risparmio in questo approccio è un vantaggio se devi sostituire una qualsiasi delle tue applicazioni esistenti. Invece di scrivere un sacco di nuove interfacce, ora hai solo un'interfaccia di cui preoccuparti (tra la tua applicazione e l'ESB).

SOA ed ESB?

SOA ed ESB sono comunemente usati in modo intercambiabile, ma sono completamente diversi.

SOA è un modello di progettazione che consente all'applicazione di esporre le sue funzionalità come servizio sulla rete tramite protocolli di comunicazione, mentre ESB è un modello che facilita la comunicazione tra sistemi disparati, ma ESB può essere utilizzato come backbone durante l'implementazione SOA.

JBoss Fuse è una soluzione ESB open source di Redhat. È una soluzione aziendale basata su un progetto comunitario, Apache Servicemix.

Integrazione a Fuse

JBoss Fuse è una piattaforma di integrazione leggera e flessibile che consente una rapida integrazione delle applicazioni aziendali.

Fuse è stato inizialmente sviluppato da Progressive software Inc., acquisita da Redhat nel 2012. JBoss Fuse 6.1.0.redhat-379 GA è una versione stabile di Fuse che può essere scaricata dal loro sito web ufficiale.

Architettura

Fuse combina varie tecnologie insieme in un unico prodotto.

Componenti

Apache CXF

Apache CXF è un framework di sviluppo di servizi web open source che supporta anche lo sviluppo di servizi web SOAP & Rest.

Cammello Apache

Apache Camel è un framework di integrazione basato su EIP. I modelli EIP o Enterprise Integration sono soluzioni identificate ai problemi ricorrenti in Enterprise Integration. Una soluzione di integrazione completa può essere ottenuta in modo rapido con combinazioni di questi modelli predefiniti fuori dagli schemi.

Consente di scrivere la logica di routing in diversi linguaggi specifici del dominio come Java, Spring DSL e Scala ecc.

Apache AMQ

Apache AMQ è un JMS che fornisce un sistema di messaggistica affidabile secondo gli standard JMS. Non solo supporta le specifiche JMS, ma fornisce anche alcune funzioni interessanti e utili che non sono incluse nelle specifiche JMS.

Apache Karaf

Apache Karaf è un container OSGi leggero che funge da runtime per gli artefatti. Apache Karaf è di natura più dinamica rispetto a JVM. Permette di installare o disinstallare moduli in fase di esecuzione. Tutti gli artefatti in Fuse sono schierati a Karaf.

Tessuto

Fabric fornisce un modo semplice per gestire le distribuzioni di artefatti in un ambiente ampio e distribuito. Fornisce una gestione centralizzata per tutte le istanze multiple di fusibili.

Installazione del fusibile

L'installazione di Fuse è abbastanza semplice. Come altri prodotti JBoss, Fuse si presenta come un file zip che può essere estratto e dopo alcune piccole modifiche alla configurazione può essere avviato direttamente.

L'installazione di Fuse è un processo in quattro fasi:

Scarica

Scarica Fuse 6.1.0 GA dal seguente link. http://www.jboss.org/

Decomprimere

Come tutti gli altri prodotti JBoss, anche Fuse è uno zip indipendente dalla piattaforma.

Decomprimere il file scaricato nella directory di destinazione che si desidera utilizzare come directory di installazione di Fuse. Scegli questa directory con saggezza poiché dovrebbe rimanere la stessa per tutta la durata dell'istanza di Fuse.

Note - Anche se Fuse si decomprime e si avvia come altri prodotti JBoss, non è consigliabile spostare l'installazione di Fuse da una posizione a un'altra una volta completata l'installazione.

Configura

Dopo aver decompresso Fuse, troverai le seguenti directory all'interno della directory estratta:

bin
etc
deploy
lib
licenses
extras
quickstarts

Di cui useremo solo due directory bin & etc.

Praticamente dopo aver estratto Fuse, dovremmo essere in grado di avviare direttamente fuse, ma questo avvierà Fuse con tutte le configurazioni predefinite che non è consigliabile per l'ambiente di produzione. Si consiglia vivamente di apportare le seguenti modifiche prima di avviare Fuse.

Imposta le variabili d'ambiente

Imposta le seguenti variabili d'ambiente: JAVA_HOME
La variabile dovrebbe puntare alla directory di installazione di java - M2_HOME
La variabile dovrebbe puntare alla directory di installazione di Maven - PATH
Imposta la variabile di percorso per includere eseguibili Java e Maven.

finestre

Su Windows, le impostazioni possono essere effettuate seguendo le istruzioni fornite di seguito:

Start → Risorse del computer → Fare clic con il pulsante destro del mouse → Proprietà → Impostazioni di sistema avanzate → Variabili d'ambiente.

UNIX e cloni

Per ogni utente c'è un profilo bash nel file *nixsistemi operativi. Possiamo aggiungere o modificare la variabile di sistema esistente cambiando questo file.

$ vi ~/.bash_proflle

Note- Eventuali modifiche in questo file sono permanenti. Si consiglia vivamente di eseguire un backup del file esistente prima di modificare l'originale.

Configurazione di base

Discuteremo della configurazione di base di JBoss Fuse e per questo dobbiamo iniziare con il seguente comando Edit $FUSE_INSTALLATION_DIR/etc/

In user.properties

#admin=admin,admin
Questo deve essere modificato in base al primo amministratore con il nome utente che vogliamo, il secondo amministratore con la password, il terzo potrebbe essere mantenuto così com'è perché indica un ruolo e non dimenticare di rimuovere #
Ad esempio: FuseAdmin = FusePAss, admin

In System.properties
- karafName = root
  - Questo indica il nome che vuoi dare all'istanza di Karaf.
  - Possiamo chiamarlo come vogliamo come Cont1.
  - Assicurati che il nome che fornisci sia univoco e non sia già utilizzato da un'altra istanza di Fuse.
In org.ops4j.pax.web.cfg
- Org.osgi.service.http.port = 8181
- Questa proprietà indica la porta che deve essere utilizzata per accedere all'interfaccia basata su browser HAWTIO fornita da Fuse
- HAWTIO è un'interfaccia browser integrata per Fuse disponibile dalla 6.0 in poi
In org.ops4j.pax.url.mvn.cfg
- org.ops4j.pax.url.mvn.localRepository = D: / repository
- Questa proprietà indica il percorso per localRepository del nostro Maven da cui Fuse installerà i suoi artefatti.
- org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml
- Questa proprietà indica settings.xml che Fuse dovrebbe usare per ottenere artefatti da Maven.

Configurazione di Maven

Maven è un prerequisito per l'installazione di Fuse. Se non sai cosa sia Maven, fai riferimento ahttp://www.tutorialspoint.com/maven/

Maven è uno strumento costruito utilizzato per costruire artefatti Fuse. Fondere le prime ricerche nel repository locale di Maven per gli artefatti quando emettiamo il comando per installare l'artefatto. Quindi dobbiamo far sapere a Fuse dove è installato Maven e il percorso del repository locale di Maven.

Modifica $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Aggiorna le seguenti due proprietà:

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Per favore cambia $local_repo con il percorso effettivo del tuo repository locale menzionato in Mavens settings.xml.

Correre

Dopo aver apportato modifiche alla configurazione di base, ora possiamo avviare Fuse. Tutti i file binari in cui lavorare con Fuse si trovano in$FUSE_INSTALLATION_DIR.

Ci sono due modi per avviare Fuse:

Utilizzando ./fuse
- Ciò ti consentirà di vedere tutti i progressi e i log nella stessa finestra in cui hai avviato Fuse.
- Ti darà la console Karaf nello stesso terminale come mostrato di seguito.

Note- Questo avvierà il fusibile in modalità console, il che significa che il processo di fusibile verrà interrotto anche quando l'utente si disconnette dalla sessione o chiude il terminale, cosa non desiderabile nello scenario di produzione o sviluppo. Questo script dovrebbe essere utilizzato solo per il debug di Fuse.

Utilizzando ./start
- Questo non mostrerà alcun registro sullo schermo, nemmeno l'avanzamento, ma avvierà Fuse in background e il servizio Fuse non verrà interrotto quando l'utente esce dalla sessione o chiude il terminale.
- Nell'applicazione del mondo reale, questo tipo di comportamento è desiderato. Fuse dovrebbe essere in esecuzione in background anche se chiudiamo il terminale.
- Se vuoi connetterti a Fuse in esecuzione in background, puoi usare client script che si trova nella stessa cartella.
- Dovresti ottenere il display come mostrato nello screenshot seguente.
- L'uscita dallo script client non interromperà il servizio Fuse. Chiuderà semplicemente la console di Fuse.

HAWTIO

Fuse fornisce anche un accesso GUI completo utilizzando FMC (console di gestione dei fusibili). Puoi trovare la GUI sul seguente URLhttp://localhost:8181.

Tutto ciò che abbiamo fatto eseguendo i comandi può essere fatto anche accedendo a questa GUI basata su browser. Diventa estremamente utile quando abbiamo più di un container e siamo in esecuzione in un ambiente Fabric.

In questo capitolo, discuteremo di Apache Karaf e del motivo per cui è chiamato come contenitore OSGi leggero insieme ai suoi vantaggi e ad altre importanti caratteristiche.

Il problema JVM

JVM o Java virtual Machine non funziona come una vera macchina virtuale. Una macchina che ti permetterà di arrestare, avviare o riavviare al volo i componenti in esecuzione al suo interno. A volte può consentire distribuzioni a caldo a livello di classe, ma non è possibile distribuire o annullare la distribuzione di un componente dell'applicazione nella macchina virtuale senza riavviarla.

Per risolvere questo problema e consentire la modularità nell'applicazione Java, Fuse utilizza un runtime basato su OSGi noto come Apache Karaf.

OSGi

La tecnologia OSGi è un insieme di specifiche che definiscono un sistema di componenti dinamici per java. Queste specifiche consentono un modello di sviluppo in cui le applicazioni sono (dinamicamente) composte da molti componenti diversi (riutilizzabili).

Vantaggi di OSGi

Reduced Complexity - L'applicazione è costruita come componenti collaboranti che nascondono i loro dettagli di implementazione l'uno dall'altro con conseguente riduzione della complessità.
Reusability - Molti componenti possono sfruttare lo stesso componente distribuito in un contenitore.
Deployment - OSGi fornisce supporto per l'avvio, l'arresto e l'aggiornamento dei componenti al volo con le sue API di gestione del ciclo di vita senza riavvio del contenitore.

Bundle vs caratteristiche

Di seguito è riportato il confronto tra bundle e funzionalità.

gruppi

I bundle sono equivalenti a OSGi come i jar sono a JVM. I bundle sono artefatti che possono essere distribuiti in un contenitore OSGi. I bundle sono componenti che lavorano insieme o indipendentemente per formare un'applicazione.

Questi bundle possono essere installati, disinstallati, aggiornati, avviati o arrestati in fase di esecuzione senza riavviare il contenitore.

Caratteristiche

Le funzionalità sono un modo per distribuire più bundle insieme. A volte ha più senso distribuire i pacchetti in gruppo. Le funzionalità ci consentono di distribuire un gruppo di bundle con un solo comando.

Perché un altro contenitore?

Apache Karaf è un runtime basato su OSGi, è dove vengono eseguiti i nostri bundle di applicazioni. Fuse utilizza Apache Karaf come runtime in cui i bundle vengono eseguiti e collaborano per fornire funzionalità aziendali.

Karaf è costruito su Felix ed equinox che sono OSGi Frameworks.

Architettura Karaf

Apache Karaf aggiunge le seguenti funzionalità aggiuntive al runtime OSGi di base.

Distribuzione a caldo

Karaf supporta la distribuzione a caldo. Contiene una directory di distribuzione a caldo. Tutto ciò che viene inserito in questa directory viene automaticamente distribuito e installato in Karaf come pacchetto.

Registrazione

Karaf fornisce la registrazione centralizzata generando i registri per tutti i pacchetti in $Fuse_home/data/log. Possiamo modificare la configurazione del logger inorg.ops4j.pax.logging.cfg in $Fuse_home/etc directory.

Console di amministrazione

Karaf fornisce una console di amministrazione sofisticata e lucida per interagire con l'istanza in esecuzione di fuse. Fornisce inoltre una serie di comandi preinstallati che possono essere utilizzati per gestire e monitorare i componenti (Bundle) in fase di esecuzione. Questa console è estensibile, quindi ci permette di aggiungere nuovi comandi alla console aggiungendo nuovi bundle alla console.

Accesso SSH

Karaf consente l'accesso remoto a questa Console di amministrazione con SSH. Chiunque disponga di credenziali valide può connettersi alla console di amministrazione di karaf tramite il terminale SSH.

In questo capitolo, discuteremo cos'è Apache Camel e come instrada efficacemente i dati tra gli endpoint, insieme ad alcuni esempi.

Cos'è Apache Camel?

Apache Camel è un framework di integrazione open source che è stato avviato all'inizio del 2007.

È un approccio basato su EIP (Enterprise Integration Pattern) che fornisce diverse implementazioni di modelli predefiniti che possono essere utilizzati per risolvere i problemi di integrazione aziendale. Gli EIP non sono altro che soluzioni comprovate ai problemi ben documentati e ricorrenti dell'integrazione aziendale.

Camel è anche noto come motore di routing e mediazione poiché instrada efficacemente i dati tra gli endpoint, assumendo carichi pesanti come la trasformazione dei formati di dati, la connettività degli endpoint e molti altri.

Esempio di base

I prerequisiti per utilizzare Apache Camel sono:

Java
Maven
Fusibile Redhat JBoss 6.1-GA-379

Crea lo scheletro di base dell'applicazione

mvn:archetype generate 
–DgroupId = com.tutorialpoint.app 
–DartifactId = camel-first-app 
–DarchetypeGroupId = org.apache.camel.archetypes
–DarchetypeArtifactId = camel-archetype-spring 
–DinteractiveMode = false -X

Questo dovrebbe generare la seguente struttura di directory.

Questo è uno scheletro di base della nostra applicazione Camel che viene generata.

Modifica camel-context.xml

modificare camel-first-app → src → main → resources → META-INF\spring\camel-context.xml in modo che corrisponda come di seguito

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<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">
      <!-- here is a sample which processes the input file
         (leaving them in place - see the 'noop' flag) 
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "file:///d:/src/data?noop=false"/>
         <choice>
            <when>
               <xpath>/person/city = 'London'</xpath>
               <log message = "UK message"/>
               <to uri = "file:///d:/target/messages/uk"/>
            </when>
				
            <otherwise>
               <log message = "Other message"/>
               <to uri = "file:///d:/target/messages/others"/>
            </otherwise>
				
         </choice>
			
      </route>
   </camelContext>
</beans>

Modifica pom.xml

Aggiungi il seguente codice all'interno di <plugins> </plugins>

<plugin>
   <groupId>org.apache.felix</groupId>
   <artifactId>maven-bundle-plugin</artifactId>
   <version>2.3.4</version>
   <extensions>true</extensions>
	
   <configuration>
      <instructions>
         <Bundle-SymbolicName>
            ${project.artifactId}
         </Bundle-SymbolicName>
         <Import-Package>*</Import-Package>
      </instructions>
   </configuration>
	
</plugin>

Cambia tipo di confezione da jar → bundle.

<packaging>bundle</packaging>

Compila il progetto utilizzando il seguente comando:

mvn clean install

Installa il progetto in Fuse

Avvia Fuse usando Fuse.bat/start.bat. Se avvii Fuse usandostart.bat, uso client.batper connettersi a Fuse. Dovresti ottenere l'interfaccia utente come mostrato nello screenshot seguente.

Questa è la CLI per accedere ai comandi Karaf e Fuse.

install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Verifica se il tuo progetto è in esecuzione

Ora la tua applicazione dovrebbe essere installata in Fuse. Copia la directory dei dati all'internocamel-first-app e inseriscilo D:/src/ e dovrebbe copiare il messaggio con city = London in D:/target/merssages/uk.

Posiziona il file di input in D:/src/data

Input

Message1.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

Message2.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

Output

In D: / target / messages / uk

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

In D: / target / messages / others

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

In questo capitolo capiremo i diversi concetti di Camel. Cominciamo con un esempio di base per comprendere i concetti fondamentali per cominciare.

CamelContext

Ogni applicazione cammello avrà almeno un CamelContext. Questo è il luogo in cui aggiungiamo le rotte dei cammelli. È simile aApplicationContext di primavera.

Il contesto cammello può essere pensato come un contenitore che tiene insieme tutte le cose. Un contesto di cammello può avere più percorsi al suo interno.

Itinerari

CamelContext può contenere uno o più percorsi. Le rotte sono la logica di integrazione che definisce il modo in cui i dati fluiranno nel contesto del cammello da un endpoint a un altro.

Endpoint

L'endpoint è la fine del canale attraverso il quale il sistema può inviare o ricevere messaggi. Questo è ciò che chiamiamo destinazione o fonte nel linguaggio di comunicazione.

Componenti

I componenti sono un punto di estensione in Camel. I componenti possono essere un'interfaccia per la tecnologia, il formato dei dati, i trasformatori, ecc. Possono anche fungere da fabbrica per gli endpoint.

EIP

EIP sta per Enterprise Integration Pattern. Si tratta di soluzioni identificate e ben note a un problema ricorrente. Camel supporta la maggior parte dei modelli di integrazione aziendale.

Router basato sui contenuti

I modelli CBR ci consentono di instradare i dati in base al contenuto del file di input.

Questo modello viene utilizzato quando dobbiamo instradare valori in base al contenuto del corpo dell'input.

Il seguente esempio leggerà i dati da D:/data/inputdirectory. Dopo la lettura, controllerà il tag di valore all'interno del tag di dati. Se il tag del valore contienevalue1, verrà inviato a D:/value1, Se contiene value2, verrà inviato a D:/value2 e se nessuno di questi entrambi, verrà inviato ad altri.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/data/input"/>
      <choice>
         <when>
            <xpath>/data/value = 'value1'</xpath>
            <to uri = "file:///D:/value1"/>
         </when> 
         <when>
            <xpath>/data/value = 'value2'</xpath>
            <to uri = "file:///D:/value2"/>
         </when>  
			
         <otherwise>
            <to uri = "file:///D:/others "/>
         </otherwise>
			
      </choice>
   </route>
</camelContext>

Input

D: /data/input/message1.xml

<data>
   <value>value1</value>
</data>

D: /data/input/message2.xml

<data>
   <value>value2</value>
</data>

Output

D: / valore1 /

<data>
   <value>value1</value>
</data>

D: / valore2 /

<data>
   <value>value2</value>
</data>

Splitter

Un modello di divisione viene utilizzato per dividere i dati di input in blocchi più piccoli.

Questo modello viene utilizzato la maggior parte delle volte con un enorme input di dati che richiede di essere diviso in blocchi, quindi diventa processabile. Suddividi l'input in frammenti più piccoli in base alla stringa del token di input.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/inbox"/>
      <split streaming = "true">
         <tokenize token = "order" xml = "true"/>
         <to uri = "activemq:queue:order"/>
      </split>
   </route>
</CamelContext>

Input

D: /inbox/message.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

Se controlli AMQ troverai 3 messaggi pubblicati.

<order>
   <data>
      <value>value4</value>
   </data>
</order>

Elenco destinatari

Un modello elenco destinatari viene utilizzato quando è necessario recuperare un elenco di destinatari dal corpo del messaggio stesso.

Nell'esempio seguente, un messaggio verrà inviato a tutti i destinatari elencati nel tag del cliente come elenco di stringhe separato da virgole.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "jms:xmlOrders" />
      <recipientList>
         <xpath>/order/customer</xpath>
      </recipientList>
   </route>
</camelContext>

Altri PEI

Camel fornisce supporto a quasi tutti gli EIP identificati. Alcuni degli EIP comunemente usati sono indicati di seguito.

Log - Per registrare il messaggio completo o parte di esso
Message Filter - Filtraggio dei contenuti dei messaggi
Re-Sequencer - Per ottenere tutti i gettoni in sequenza
Wiretap - Ispezionare i messaggi di viaggio

L'elenco completo di EIP e il loro utilizzo può essere trovato nella documentazione ufficiale di Camel http://camel.apache.org/eip.html

Gestione delle eccezioni in Camel

Using Error Handler - Questo è il modo più semplice per gestire le eccezioni in cammello.

Per usarlo, dobbiamo configurare il bean di classe del gestore degli errori e fornirlo come riferimento a CamelContext errorHandlerRef attributo.

<bean id = "loggingErrorHandler" class = "org.apache.camel.builder.LoggingErrorHandler">
   <property name = "logName" value = "mylogger.name"/>
   <property name = "level" value = "DEBUG"/>
</bean>

<camelContext errorHandlerRef = ” loggingErrorHandler” >
   …
</camelContext>

Utilizzando Try Catch Finalmente

Camel supporta anche lo stile Java Try Catch Finally block per la gestione degli errori.

Proprio come Java, ha i seguenti tre blocchi:

doTry block contiene codice che può generare un'eccezione.
doCatch block contiene codice che deve essere eseguito in caso di eccezione.
doFinallyIl blocco ha un codice che deve essere eseguito indipendentemente dall'eccezione. Verrà sempre eseguito indipendentemente dal fatto che l'eccezione sia stata sollevata o meno.

Note- Mock è un componente di test e non è raccomandato per altri scopi. È il componente in camel utilizzato per i test proprio come il componente jMOck nello sviluppo basato su test.

<route>
   <from uri = "direct:start"/>
   <doTry>
      <process ref = "someProcesorThatmayFail"/>
      <to uri = "mock:result"/>
		
      <doCatch>
         <exception>java.io.IOException</exception>
         <exception>java.lang.IllegalStateException</exception>
         <to uri = "mock:catch"/>
      </doCatch>
		
      <doFinally>
         <to uri = "mock:finally"/>
      </doFinally>
		
   </doTry>
</route>

Nell'esempio precedente, possiamo fornire un elenco di eccezioni che devono essere gestite dal blocco catch.

Distribuzione di bundle in Fuse

Avvia Fuse usando Fuse.bat/start.bat.

Se avvii Fuse usando start.bat, usa client.bat per connetterti a Fuse. Dovresti ottenere l'interfaccia utente come mostrato nello screenshot seguente.

Questa è la CLI per accedere ai comandi Karaf e Fuse.

install –s mvn:group.id /artifact.id/version 
e.g. install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

In questo capitolo, discutiamo di cos'è Apache CXF e di come può essere utile nello sviluppo di SOAP e Rest Web Services.

Cos'è Apache CXF?

Apache CXF è un framework di sviluppo di servizi Web che può essere utilizzato per sviluppare servizi Web SOAP e Rest. CXF è completamente conforme aJAX-RS and JAX-Ws standard.

Attualmente è il framework di sviluppo di servizi Web più utilizzato. CXF ha appreso e migliorato rispetto ad Axis2, che ora viene gradualmente sostituito da CXF.

CXF contro Axis2

	CXF	Axis2
Miglioramenti	CXF è il framework più utilizzato al momento. Ha molti miglioramenti rispetto ad Axis2	Axis2 viene gradualmente sostituito da CXf. Richiede più codice rispetto a CXF
Codice richiesto	CXF richiede meno codice rispetto ad Axis2	Axis2 richiede più codice in confronto
Conformità agli standard	CSF è completamente conforme a JAX-RS e JAX-WS	Axis2 non è completamente compatibile con JAX-RS e JAX-WS
Compatibile con la primavera	sì	No
Separazione dei front-end	Separazione netta del front-end dal codice JAX-WS	Non è prevista una separazione netta

SAPONE

SOAP è l'acronimo di Simple Object Access Protocol. È un protocollo per lo scambio di informazioni strutturate su servizi web tra due sistemi. Si basa principalmente su XML per strutturare i dati e utilizza HTTP o SMTP per la negoziazione e la trasmissione dei messaggi.

Esistono due approcci per sviluppare servizi Web SOAP:

Code first - In questo approccio, WSDL viene generato dal codice.
Contract first - Per prima cosa nel contratto, il codice viene generato da WSDL.

Sviluppo SOAP utilizzando CXF

Configura Maven

Aggiungi il seguente profilo al tuo settings.xml di Maven.

<profiles>
   <profile>
      <id>Jboss-Fuse</id>
		
      <activation>
         <activeByDefault>true</activeByDefault>
      </activation>
		
      <repositories>
         <repository>
            <id>fusesource</id>
            <url>http://repo.fusesource.com/nexus/content/groups/public/</url>
            <snapshots>
               <enabled>false</enabled>
            </snapshots>
            <releases>
               <enabled>true</enabled>
            </releases>
         </repository>
      </repositories>
		
   </profile>
</profiles>

Crea scheletro

mvn archetype:generate
-DarchetypeGroupId = org.apache.servicemix.tooling 
-DarchetypeArtifactId = servicemix-cxf-code-first-osgi-bundle 
-DarchetypeVersion=2012.01.0.redhat-60024 
-DgroupId = org.fusesource.example 
-DartifactId = cxf-basic 
-Dversion = 1.0-SNAPSHOT

Build Web Service Project.

mvn clean install

Install web-service into Fuse using the following command.

JBossFuse:[email protected]>install -s mvn:org.fusesource.example/cxf-basic/1.0-SNAPSH

Check if bundle has registered SOQP web-service

Apri URL http://localhost:8181/cxf

Il servizio web dovrebbe essere elencato come segue.

Testing Web-Service

mvn -Pclient

INFO - Creazione del servizio {http://ws.totorials.com/} PersonService dalla classe com.to

torials.ws.Person
Invoking getPerson...
getPerson._getPerson_personId = Guillaume
getPerson._getPerson_ssn = 000-000-0000
getPerson._getPerson_name = Guillaume
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 30.668 s
[INFO] Finished at: 2016-02-15T21:01:20+05:30
[INFO] Final Memory: 10M/37M
[INFO] ------------------------------------------------------------------------

Per cominciare, REST sta per Representational State Transfer. È un modo per sviluppare servizi Web basati su protocollo client-server senza stato, memorizzabile nella cache, che nella maggior parte dei casi è HTTP.

I servizi Web REST utilizzano richieste HTTP per inviare, ottenere, eliminare dati dalla rete.

Sviluppo REST utilizzando CXF

Crea un semplice progetto di avvio rapido Maven

mvn archetype:generate 
-DgroupId = com.tuts.abhinav 
-DartifactId = rest-service
-DarchetypeArtifactId = maven-archetype-quickstart 
-DinteractiveMode = false

Aggiungi dipendenze

<dependency>
   <groupId>org.apache.servicemix.specs</groupId>
   <artifactId>org.apache.servicemix.specs.jsr311-api-1.1.1</artifactId>
   <version>1.9.0</version>
   <scope>provided</scope>
</dependency>

<dependency>
   <groupId>org.apache.servicemix</groupId>
   <artifactId>servicemix-http</artifactId>
   <version>2013.01</version>
</dependency>

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.16</version>
</dependency>

Aggiungi istruzioni di costruzione

<build>
   <defaultGoal>install</defaultGoal>
   <plugins>
      <plugin>
         <groupId>org.apache.felix</groupId>
         <artifalctId>maven-bundle-plugin</artifactId>
         <version>2.3.4</version>
         <extensions>true</extensions>
			
         <configuration>
            <instructions>
               <Bundle-SymbolicName>rest-example-database-post-method
                  </Bundle-SymbolicName>
               <Import-Package>* </Import-Package>
            </instructions>
         </configuration>
			
      </plugin>
   </plugins>
</build>

Aggiungi archivi di plug-in Fuse

<pluginRepositories>
   <pluginRepository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
   </pluginRepository>
<pluginRepositories>

Aggiungi repository

<repositories>
   <repository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
		
   </repository>
	
   <repository>
      <id>fusesource.ea</id>
      <name>FuseSource Community Early Access Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/groups/ea</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
      <releases>
         <enabled>true</enabled>
      </releases>
   </repository>
	
</repositories>

Crea classe di servizio

Crea la classe UserService.java sotto com / tuts /

package com.tuts;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/UserService_1")
public class UserService {
   @GET
   @Path("/get_data")
   @Produces(MediaType.APPLICATION_JSON)
	
   public String getUser() {
      String reponse = "This is standard response from REST";
      return reponse;
   }
}

Crea Blueprint.xml

Crea blueprint.xml in / src / main / resources / OSGI-INF / blueprint blueprint.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<blueprint xmlns = "http://www.osgi.org/xmlns/blueprint/v1.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:jaxrs = "http://cxf.apache.org/blueprint/jaxrs"
   xsi:schemaLocation = "http://www.osgi.org/xmlns/blueprint/v1.0.0 
   http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
   http://cxf.apache.org/blueprint/jaxrs 
   http://cxf.apache.org/schemas/blueprint/jaxrs.xsd">
	
   <jaxrs:server id = "service" address = "/users">
      <jaxrs:serviceBeans>
         <ref component-id = "userService" />
      </jaxrs:serviceBeans>
   </jaxrs:server>
	
   <bean id = "userService" class = "com.tuts.UserService" />
</blueprint>

Installa il servizio Rest in Fuse

install -s mvn:com.tuts.abhinav/rest-service/1.0-SNAPSHOT

Controlla se Bundle ha un servizio web registrato

Apri URL http://localhost:8181/cxf

Test del servizio Web

Apri URL http://localhost:8181/cxf/users12/UserService_1/get_data

In questo capitolo impareremo a conoscere ActiveMQ e come agisce da broker di messaggi per consentire alle applicazioni di comunicare tra loro.

Cos'è AMQ?

ActiveMQ è un broker di messaggi open source scritto in Java. È completamente conforme agli standard JMS 1.1.

JMS è una specifica che consente lo sviluppo di un sistema basato su messaggi. ActiveMQ funge da broker di messaggi che si trova tra le applicazioni e consente loro di comunicare in modo asincrono e affidabile.

Tipi di messaggistica

Esistono due tipi di opzioni di messaggistica spiegate di seguito per una migliore comprensione.

Punto a punto

In questo tipo di comunicazione, il broker invia messaggi a un solo consumatore, mentre gli altri consumatori aspetteranno fino a quando non riceveranno i messaggi dal broker. Nessun consumatore riceverà lo stesso messaggio.

Se non ci sono consumatori, il broker manterrà i messaggi finché non ottiene un consumatore. Questo tipo di comunicazione è anche chiamato comeQueue based communicationdove il produttore invia messaggi a una coda e solo un consumatore riceve un messaggio dalla coda. Se è presente più di un consumatore, potrebbe ricevere il messaggio successivo ma non riceverà lo stesso messaggio dell'altro consumatore.

Pubblica / Iscriviti

In questo tipo di comunicazione, il Broker invia la stessa copia dei messaggi a tutti i consumatori attivi. Questo tipo di comunicazione è anche noto comeTopic based communicationdove il broker invia lo stesso messaggio a tutti i consumatori attivi che hanno sottoscritto un determinato argomento. Questo modello supporta la comunicazione unidirezionale in cui non è prevista alcuna verifica dei messaggi trasmessi.

Creazione di code e argomenti

Fuse viene fornito in bundle con ActiveMQ. Possiamo accedere ad ActiveMQ utilizzando la console FMC (l'interfaccia basata su browser per lavorare con AMQ).

Accedi a FMC utilizzando localhost:8181 e seleziona ActiveMQ tab.

Fare clic su + Crea
Immettere il nome della coda / argomento
Seleziona Coda / Argomento dal pulsante di opzione
Fare clic su Crea coda / Crea argomento

Ora dovresti essere in grado di vedere il file TestQ creato sotto root → Queue →

Per controllare l'argomento creato segui root → Argomento.

Esplorazione / eliminazione dei contenuti della coda

Accedi a FMC utilizzando localhost:8181
Seleziona la scheda ActiveMQ
Root → Queue → TestQ <seleziona la coda che vuoi esplorare> → Browse

Per controllare il contenuto di questo messaggio, fare clic su quel particolare messaggio.

È possibile eliminare un particolare messaggio facendo clic sul pulsante Elimina visualizzato nell'angolo in alto a destra

In questo capitolo impareremo le basi di come ActiveMQ funziona con Camel.

Configurazione in ActiveMQ Component

Prima di poter utilizzare la coda o l'argomento ActiveMQ nel nostro codice, dobbiamo configurare ActiveMQComponent. La configurazione minima di ActiveMQComponent può essere eseguita come mostrato nel seguente programma:

<bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
   <property name = "brokerURL" value = "tcp://localhost:61616"/>
   <property name = "userName" value = "admin"/>
   <property name = "password" value = "admin"/>
</bean>

brokerURL - Specifica l'host e la porta per AMQ Broker.
username - Specifica il nome utente da utilizzare per la connessione a AMQ Broker.
password - specifica la password per la connessione a AMQ Broker.

Connessione alla coda

Ora che abbiamo configurato ActiveMQComponent, possiamo usarlo nel nostro CamelContext come endpoint.

Useremo l'endpoint AMQ nel seguente formato:

Activemq:[queue|topic]:[queueName|topicName]

Scrivere messaggi ad AMQ

<?xml version = "1.0" encoding="UTF-8"?>
<!-- Configures the Camel Context-->
<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">

Dopo aver distribuito questo bundle nel contenitore Fuse, dovresti essere in grado di vedere i messaggi pubblicati su AMQ che sono stati inseriti come file in D:/src/data.

Input

D: /src/data/input.txt

Test me

Output

Lettura da AMQ

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->

<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">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "activemq:queue:TestQ"/>
         <to uri = "file:///d:/src"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

Dopo aver distribuito questo pacchetto, dovresti vedere un file generato in D: / src e i messaggi vengono consumati. Anche Consumer dovrebbe essere mostrato per quella coda.

Output

D: / src

Test me

Scrivendo all'argomento

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<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">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "file:///d:/src"/>
         <to uri = "activemq:topic:TestTopic” />
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Lettura dall'argomento

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<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">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "activemq:topic:TestTopic"/>
         <to uri = "file:///d:/src2"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value="tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

D: /src/file1.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

D: / src /

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Cos'è il tessuto?

Fabric fornisce funzionalità di gestione e orchestrazione per più istanze di Fuse. Fabric ci consente di controllare tutte le istanze di Fuse ad esso collegate da un unico punto. Un normale contenitore di fusibili può essere convertito per agire come un tessuto. Fabric ha un registro di fabric al suo interno che funge da archivio dati che contiene tutte le informazioni sui contenitori, gestisce.

Perché il tessuto?

Fabric ha le seguenti capacità speciali che lo rendono un candidato ideale per l'uso in ambienti distribuiti.

Monitoraggio dello stato di tutti i contenitori nel tessuto.
Avvio e arresto di container remoti.
Fornisce un container remoto per eseguire una particolare applicazione.
Aggiornamento delle applicazioni e distribuzione di patch nel sistema live.
Avvio e provisioning di nuovi container rapidamente, ad esempio per far fronte all'aumento del carico sul sistema.

Configurazione del tessuto

Creazione di tessuto

Il normale contenitore Fuse può essere convertito in Fabric utilizzando il comando seguente

fabric: create --clean --zookeeper-password myZooPass

Collegamento di un altro contenitore a Fabric -

fabric:join --zookeeper-password myZooPass <fabric_host>:2181 Cont1

Note - Sostituisci <fabric_host> con il nome host effettivo su cui è in esecuzione il fabric.

Quando accedi alla console di gestione dei fusibili dal tuo browser utilizzando localhost:8181, dovresti essere in grado di vedere due contenitori come mostrato nello screenshot seguente. Il contenitore del tessuto è indicato da un piccolo simbolo di nuvola davanti ad esso.

Profili

Un profilo contiene le seguenti informazioni:

Pacchetti da installare
Funzionalità da installare
Configurazioni da applicare

Un profilo fornisce un modo nell'ambiente fabric per installare lo stesso set di bundle, funzionalità e configurazione su più server.

Se lo stesso profilo viene applicato a più contenitori e apportiamo modifiche a quel profilo da qualsiasi contenitore, modifiche simili verranno distribuite automaticamente ai contenitori rimanenti a cui è applicato.

Creazione di profili

Accedi a FMC localhost:8181
Runtime → Gestisci
Nella parte sinistra del menu Profilo fare clic su +

Immettere il nome che si desidera dare al profilo e fare clic su crea.

Dopo questo, il profilo dovrebbe essere creato.

Applicazione del profilo al contenitore

Runtime → Contenitori → root (seleziona il contenitore che desideri)

Clic Addche porterà a una finestra pop-up. Cerca il profilo che desideri e poi fai di nuovo clicAdd.

Il profilo dovrebbe essere mostrato nell'elenco come mostrato nella seguente schermata.

Distribuzione di un bundle

Per distribuire un pacchetto, utilizzare il seguente percorso:

Runtime → Containers → root (seleziona il container che desideri) → First_profile (seleziona profilo)

Fare clic sulla scheda Pacchetti. Impostare il percorso del pacchetto nel seguente formato e quindi fare clic su+.

mvn:group.id/artifact.id/version

Per esempio: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Un bundle verrà aggiunto al profilo e verrà distribuito su tutti i container a cui è assegnato il profilo.

Annullamento della distribuzione di un bundle

Per annullare la distribuzione di un pacchetto, utilizzare il percorso seguente:

Runtime → Containers → root (seleziona il container che desideri) → First_profile (seleziona il profilo)

Fare clic sulla scheda Pacchetti e cercare il pacchetto che si desidera eliminare, quindi fare clic su X. Il pacchetto verrà eliminato da tutti i contenitori a cui è applicato il profilo.

Un contenitore figlio fornisce il modo più semplice per gestire il carico in aumento. Quando il sistema subisce un carico improvviso nel traffico e un singolo container non è in grado di far fronte al carico, possiamo facilmente creare un set di container figlio e distribuire il carico tra di loro, invece di creare un container completamente nuovo.

Creazione di un contenitore figlio

Accedi a FMC utilizzando localhost:8181

Ora segui il percorso: Runtime → container → + Crea (pulsante sul lato destro)

Inserisci dettagli come il nome del bambino, il numero del contenitore principale di istanze ecc.

Clic Create And Start Container

Gestione di un contenitore figlio

Un contenitore figlio funge solo da contenitore normale.

Arresto di un contenitore figlio

Per fermare un contenitore figlio, segui il percorso: Runtime → Contenitore → Figlio1

Fare clic su Stop per arrestare il contenitore figlio.

Avvio di un contenitore figlio

Per avviare un contenitore figlio, segui il percorso: Runtime → Contenitore → Figlio1

Fare clic su Start per avviare il contenitore figlio.

In questo capitolo discuteremo alcuni problemi noti che potresti incontrare lavorando con Fuse. Discuteremo anche di come superare questi problemi.

Le modifiche al codice non vengono riflesse

Connettiti all'istanza di Fuse utilizzando uno script client. Cerca il pacchetto per il quale stai riscontrando un problema, utilizzando il seguente comando.

JBossFuse:[email protected] > list|grep <Bundle Description>
For Example:
JBossFuse:[email protected] > list|grep Camel
[ 255] [Active ] [ ] [ ] [ 60] Fabric8 :: Camel Component (1.0.0.redhat-379)
[ 266] [Active ] [ ] [Started] [ 60] A Camel Spring Route (1.0.0.SNAPSHOT)

Note - ID bundle per il bundle dall'output del comando precedente e utilizzare il comando seguente.

JBossFuse:[email protected] > update <bundle id>
JBossFuse:[email protected] > update 266

Pacchetto non in fase di download

Può accadere per i seguenti due motivi:

Repository Maven non specificato
Pacchetto non presente nel repository

Repository Maven non specificato

Maven è uno strumento costruito utilizzato per costruire artefatti Fuse. Fondere le prime ricerche nel repository locale di Maven per gli artefatti, quando emettiamo il comando per installare l'artefatto. Quindi dobbiamo far sapere a Fuse dove è installato Maven e il percorso del repository locale di Mavens.

Modifica $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Aggiorna le seguenti due proprietà:

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Modifica $ local_repo con il percorso effettivo del tuo repository locale menzionato in Mavens settings.xml

Pacchetto non presente nel repository

Se le impostazioni di Maven sono presenti ma continui a riscontrare problemi durante il download del pacchetto, assicurati che siano presenti JAR è presente nella posizione corretta in Maven Repository.

Ad esempio, se il seguente pacchetto genera errori durante il download:

mvn:com.tutorialpoint.app/camel-first-app/1.0-SNAPSHOT

Dobbiamo controllare $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT se è presente il JAR effettivo.

Note - $ M2_REPO deve essere sostituito con il percorso effettivo del repository Maven che abbiamo configurato per utilizzare Fuse.

Impossibile accedere a FMC (GUI basata su browser)

Users not Created - Se stai ricevendo la seguente interfaccia utente ma non riesci ad accedere con un messaggio che dice "Accesso non riuscito, vietato".

Controlla se hai aggiunto utenti in $FUSE_INSTALLATION_HOME/etc/users.properties

Il formato corretto per aggiungere utenti è:

Username = Password,Role

La porta HAWTIO è diversa

Se non sei nemmeno in grado di ottenere l'interfaccia utente su localhost: 8181 nel browser, controlla di aver menzionato la porta corretta nell'URL.

$FUSE_INSTALLATION_HOME/etc/org.ops4j.pax.web.cfg

Modificare la seguente proprietà nel file per utilizzare la porta a cui si desidera accedere.

org.osgi.service.http.port=8181

Broker AMQ non funziona

Assicurati che la porta 61616 sia aperta e non sia attualmente utilizzata da un'altra porta. Se vuoi cambiare la porta 61616 predefinita per la stessa, puoi modificarla in$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616

↰ Previous page