Java sdk per mule

Come estendere Mule con SDK per Java

Ciao Developer, in questo articolo ti voglio spiegare e mostrare tramite un esempio funzionante, come estendere il Runtime Mule con il nuovo Mule SDK per Java.

Estendere? Si, con SDK possiamo creare moduli che includono connettori o componenti creati da noi.
Esistono due versioni del SDK: Java e XML.
In questo articolo vedremo la versione Java.

Anche per la versione 3 del Runtime Mule esiste un SDK che viene chiamato DevKit.
Sebbene l’SDK si basi sulla stessa idea di classi Java, internamente funziona in modo diverso:

  • L’SDK non genera codice. Il modulo compilato non contiene alcun codice generato. Il tuo modulo interagisce con Mule Runtime tramite  un’API chiamata Extension API . Tuttavia, non è necessario apprendere i dettagli di questa API.
  • Rispetto a DevKit, l’SDK è più potente e supporta più funzionalità:
    • Transazioni
    • Origini dei messaggi di richiesta-risposta
    • Configurazioni dinamiche
    • Router
    • Operazioni non bloccanti
    • Isolamento del carico di classe
    • Interoperabilità migliorata con i servizi di runtime

Iniziamo.

Scelta della versione

Ti starai già chiedendo: beh prendo l’ultima no?
Da sviluppatore come te anch’io, in prima istanza pensai la stessa cosa, ma su questo Mule invita a fare attenzione.
Ovvero, ci invita ad adottare un approccio diverso basato sulle seguenti considerazioni:

  • identifica le funzionalità di cui hai bisogno;
  • scegli la versione più bassa che include le funzionalità di cui hai bisogno.

Questo ragionamento va fatto perchè l’unico collegamento tra il nostro codice custom e il runtime avviene attraverso l’API Exstension. Ogni versione di Mule Runtime contiene la sua particolare versione.
Ad esempio, supponi che entrambi siano veri:

  • Mule 4.1 viene fornito con la versione SDK 1.1.
  • Mule 4.2 viene fornito con la versione SDK 1.2.

Mule 4.2 supporterà pienamente qualsiasi modulo sviluppato con le versioni SDK 1.21.11.0. Se Mule 4.3 introduce l’SDK 1.3, supporterà anche 1.21.1, e così via.

Come creare un connettore

Nell’esempio riportato in seguito si vuole creare un connettore per l’interazione con in feed rss di un generico blog.
In generale, ogni blog dovrebbe esporre una URL ad hoc per i feed rss.
Tale URL, di solito, è pubblicata in un particolare tag link nell’header della pagina index del sito, per il blog corrente risulta:

<link rel="alternate" type="application/rss+xml" title="LUCA BONALDO Feed" href="https://www.lbonaldo.it/feed/" />

In questo modo la logica di cercare il link e estrarre i feed sarà a carico del connettore e sarà trasparente al modulo utilizzatore del connettore stesso.
A tale scopo, il connettore metterà a disposizione due operazioni:

  • GET RSS URL: Effettua un parsing della pagina html per cercare il link rss (come esempio sopra) e lo ritorna come output;
  • GET RSS: Ritorna il contenuto dei feed in formato XML.

Mulesoft palette
Vista dalla Mule Palette

Mediante il plugin Maven di Mulesoft creiamo il progetto e lo rendiamo Eclipse oriented, questo per facilitare l’import del progetto su Studio.

### Create extension ###

$> mvn org.mule.extensions:mule-extensions-archetype-maven-plugin:1.2.0:generate

### Output ###

[INFO] Scanning for projects...
[INFO] 
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO] 
[INFO] --- mule-extensions-archetype-maven-plugin:1.2.0:generate (default-cli) @ standalone-pom ---
* Enter the name of the extension (empty for default): 
Feed Connector
* Enter the extension's groupId (empty for default): 
it.lbonaldo
* Enter the extension's artifactId (empty for default): 
mule-feed-connector
* Enter the extension's version (empty for default): 
1.0.0
* Enter the extension's main package (empty for default):
it.lbonaldo.feed
[INFO] Generating project in Batch mode
[INFO] Archetype repository not defined. Using the one from [org.mule.extensions:mule-extensions-archetype:1.2.0] found in catalog remote
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: mule-extensions-archetype:1.2.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: it.lbonaldo
[INFO] Parameter: artifactId, Value: mule-feed-connector
[INFO] Parameter: version, Value: 1.0.0
[INFO] Parameter: package, Value: it.lbonaldo.feed
[INFO] Parameter: packageInPathFormat, Value: it/lbonaldo/feed
[INFO] Parameter: package, Value: it.lbonaldo.feed
[INFO] Parameter: version, Value: 1.0.0
[INFO] Parameter: groupId, Value: it.lbonaldo
[INFO] Parameter: extensionName, Value: Feed
[INFO] Parameter: extensionNameNoSpaces, Value: Feed
[INFO] Parameter: artifactId, Value: mule-feed-connector
[WARNING] Don't override file C:\dev\repository\mule-feed-connector\src\main\java\it\lbonaldo\feed
[WARNING] Don't override file C:\dev\repository\mule-feed-connector\src\test\java\it\lbonaldo\feed
[WARNING] Don't override file C:\dev\repository\mule-feed-connector\src\test\resources
[INFO] Project created from Archetype in dir: C:\dev\repository\mule-feed-connector
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 51.104 s
[INFO] Finished at: 2020-12-02T07:53:32+01:00
[INFO] ------------------------------------------------------------------------

### Prepare Eclipse project ###

$> mvn eclipse:clean
$> mvn eclipse:eclipse

A questo punto basta importare il progetto in Studio ed inizia il divertimento 😀

Iniziando ad esplorare il progetto possiamo notare, che sono state generate cinque classi Java:

Vista del progetto da Studio
Vista da Studio
FeedConfiguration

Questa classe rappresenta la configurazione dell’estensione, cioè un insieme di parametri che servono al connettore. Nel nostro caso la URL del blog (la configurazione di un connettore non è necessaria in quanto avrei potuto passare tale parametro direttamente come input alle operazioni).

FeedConnection

Questa classe contiene la vera logica di connessione applicativa del connettore.

FeedConnectionProvider

Questa è un’interfaccia responsabile della creazione, della disconnessione e della connessione del connettore in modo che il runtime possa gestirla correttamente, pur rimanendo astratta dalle preoccupazioni della gestione di tali connessioni.

FeedExtension

Questa classe descrive il connettore e viene utilizzata per esportare tutte le funzionalità del modulo e tutti gli elementi ad esso associati.

FeedOperations

In una o più classi è possibile specificare le operazioni messe a disposizione dal connettore (nel nostro caso get rss e get rss url).

Non amo spalmare codice sorgente (troverai il link a git in calce al post) nei miei post ma, faccio eccezione per quanto riguarda la dipendenza da librerie esterne.
Per rispondere a questa esigenza l’SDK mette a disposizione l’annotation: @ExternalLib, con la quale è possibile specificare la dipendenza.
Sarà onere di Studio evidenziare il setup della dipendenza nello wizard di configurazione del connettore (esempio quando il DB connector chiede i driver jdbc).

In questo esempio ho utilizzato la libreria jsoup.org per facilitare il parsing del contenuto HTML:

@ExternalLib(
		name = "JSOUP", 
		description = "Libraty for html parse support", 
		nameRegexpMatcher = "(.*)\\.jar", 
		requiredClassName = "org.jsoup.Jsoup", 
		coordinates = "org.jsoup:jsoup:1.13.1", 
		type = ExternalLibraryType.DEPENDENCY,
		optional = false
)
public class FeedConnectionProvider implements PoolingConnectionProvider<FeedConnection> {

.....

}

Nel paragrafi successivi vedremo come Studio segnala la necessità di aggiungere la dipendenza al pom.xml di progetto.

Come utilizzare il connettore

Bene, ora è arrivato il momento di usufruire delle potenzialità del nostro connettore, per far ciò basta creare un semplice progetto Mule e aggiungere il riferimenti del connettore nel pom.xml:

        <dependency>
            <groupId>it.lbonaldo</groupId>
            <artifactId>mule-feed-connector</artifactId>
            <version>1.0.5</version>
            <classifier>mule-plugin</classifier>
        </dependency>

Dopo il rebuild di Studio potremmo utilizzare il connettore nei nostri flussi:

Vista flussi nel progetto di esempio

Andando a configurare le componenti Feed utilizzate dai due flussi, si nota che Studio evidenzia la necessità di configurazione della dipendenza dalla libreria jsoup:

Wizard setup vista da Studio
Vista da Studio aggiunta dipendenza jsoup.org

All’interno del progetto di test troverai, in formato json, il progetto Postman con le due request di prova.

Conclusioni

Sono veramente contento dal lavoro fatto da Mulesoft sul nuovo SDK, perché ammetto che simpatizzo per le annotation 🙂

Ciò non toglie che mi sorgano alcune perplessità sul quando è veramente necessario creare un connettore, a grandi linee avrei comunque potuto creare una System API con la logica relativa ai feed.
Probabilmente in casi di implementazione spinta basata su codice nativo Java, la creazione di un connettore faciliterebbe lo sviluppo a discapito dell’uso del modulo Java di Mule.

Su questo aspetto mi farebbe piacere confrontarmi con te, se ti va lascia un commento.

Repository GIT dei progetti: https://Bonny@bitbucket.org/Bonny/mule-feed-connector.git

Doc ufficiale MuleSoft: https://docs.mulesoft.com/mule-sdk/1.1/

Leggi anche: Proprietà di configurazione in Mule

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

12 − otto =