ESB: The Mule Solution

28/07/11 Titolo presentazione 1

ESB: The Mule Solution

SUMMER LABS 2011

Cagliari

22 luglio 2011

Antonio Ariu & Dino Manca

flosslab s.r.l.


Cos'è Mule?

● E' una piattaforma “Lightweight” per l'integrazione e un Service Container che permette la gestione del routing, la trasformazione e la validazione di messaggi

● Supporta differenti protocolli e formati di messaggi● Facilmente integrabile all'interno di Web Applications e

Application Servers o utilizzabile come applicazione "stand alone"

● Basato sui patterns di EIP ● In una sola parola: Enterprise Service Bus● Mule è tutto ciò che riguarda la connessione di applicazioni


The Mule Project

● Il progetto Mule è partito nel 2003 con Ross Mason

● Trasferito alla MuleSource nel 2006, che ha cambiato nome nel 2009 in MuleSoft

● Esiste una versione gratuita (Mule CE) e una commerciale (Mule EE)

● La versione che vedremo è la 2.2.X● L'ultima versione stabile è la 3.1.2● Nel mondo è usata in aziende quali Adobe,

Amazon, Google, Hp, Ebay, Cisco, FedEx, etc...


Perché integrare?

● Gli Utenti non si preoccupano di dove risiedono le funzioni o le informazioni

● Noi non abbiamo la necessità di avere il controllo di tutti i pezzi, sia in una intranet, sia con partners esterni

● E' meno costoso che costruire nuove soluzioni da zero

● Gli Utenti ormai vogliono accedere alle informazioni da diversi devices (browsers, mobile phone, ...)


Approcci all'integrazione

● Custom o point-to-point

● problema degli information silos

● Service Oriented Architecture (SOA)

● Basso accoppiamento di servizi sia per SO diversi che per diverse tecnologie e/o linguaggi di programmazione

● Web services (SOAP, REST), RPC, CORBA,etc.

● Enterprise Service Bus (ESB)

● Aiuta ad “orchestrare” e gestire il caos

● Si possono centralizzare di servizi generali

● Incoraggia l'uso di best practices


Perché usare un ESB?

● Integration Styles● Batch● File Transfer● Shared Database● Request/Reply● Messaging

– Synchronous– Asynchronous

● Vantaggi● Tutti gli integration styles● Bridges legacy systems● Modularità● Semplice e flessibile● Facile da testare e

manutenere● Scalabile● Può essere un passo

verso la SOA


La regola delle tre R

● Riduci● La complessità e la quantità del codice

● Refactor● Distribuire il codice per responsabilità

– Transformation, Routing, Service Component

● Riuso● Pianificare lo sviluppo per il riuso dei

componenti● Utilizzare componenti e soluzioni “pre-built”


Cosa offre Mule 1/2

● Hosting e creazione di Servizi● Espone transport endpoints, EJBs, Spring beans,

and POJOs come servizi modulari e riusabili● Gestisce i servizi come un lightweight service

container● Service mediation

● Separa la logica di business dalla messagistica● Rende indipendenti i service components dal

formato dei messaggi e dalle tipologie di protocolli● Chiamate ai servizi location-independent


Cosa offre Mule 2/2

● Message routing● Routing dei messaggi sulla base del contenuto e di regole

anche complesse● Filtra, aggrega e rimette in ordine i messaggi in ingresso

● Data transformation● Permette lo scambio di dati tra applicazioni gestendo i

vari formati dei dati● Trasforma i dati solo se necessario e in ogni caso a

seconda delle necessità● Formatta i messaggi su protocolli di trasporto eterogenei


Architettura Mule

● Standards-based e vendor-neutral

● Integrazione facilitata su infrastrutture esistenti

● Architettura a plug-in per un approccio di tipo “building block”

● Utilizzabile con qualsiasi application server o standalone

● L'architettura è stata progettata in accordo con i principi del libro "Enterprise Integration Patterns" di Hohpe e Woolf


Cosa Mule non è...

● Non introduce restrizioni al proprio sistema● Non è un gestore di code di messaggi, usa altri

prodotti (JMS capable)– Non richiede l'utilizzo di code di messaggi

● Non è complesso● Non è necessario essere “the grand master of

all integration endpoints across the enterprise”–– Think big, start small– Lavora anche con altri ESBs


Per cosa usare Mule?

● Disaccoppiamento Business Logic

● Location Transparency

● Transport Protocol

● Conversioni

● Message Transformation

● Message Routing

● Message Enhancement

● Reliability (Transactions)

● Sicurezza

● Scalabilità


Perchè usare Mule?

● Non richiede particolari formati dei messaggi

● XML, CSV, Binary, Streams, Record, Java Objects Mix and match→

● Zero “code intrusion”

● Mule non impone API nei service objects

● Oggetti “fully portable”

● Gli oggetti esistenti possono essere gestiti

● POJOs, IoC Objects, EJB Session Beans, Remote Objects

● REST & Web Services

● Facile da testare

● Mule può funzionare facilmente a partire da un JUnit test case

● Il Framework fornisce un Test compatibility kit


L'architettura dei messaggi 1/3

● E' il cuore della piattaforma Mule

● E' basata sui principi degli ESB

● Esempio: Mule riceve un messaggio da una applicazione, lo trasforma in un formato comprensibile dalla applicazione di destinazione e lo spedisce a quest'ultima



● Esempio:

● Implementazione:



Componenti

● Endpoint:- Source system location- Target system location

● Transport:- Transformation- Protocols- Routing

● Service:- Validation- Archiving- Logging- Etc…


Enterpise Integration Patterns 1/2

● Message Filter● I Service component ricevono specifici message types

● Message Translator● Transformazioni: cambio formato, tag names, etc.

● Content Enricher (Message Enhancement)● Aggiunge dati al messaggio

● Content-based Router● Routing dei messaggi sulla base dei dati contenuti

● Messaging Bridge● Invio di messaggi con differenti protocolli o sistemi di

messaggistica


Enterpise Integration Patterns 2/2

● Content Filter● Ridurre il messaggio a pochi dati

● Polling Consumer● File directory, email, FTP

● Scatter-Gather● Spedire a multipli endpoints / aggregazione repliche

● Splitter● Batches, Lists, Collections, etc.

● Wire Tap● Ispezione messaggi (logging, monitoring...)


Componenti principali di Mule

● Service components● Transports● Endpoints● Transformers● Routers● Filters● Interceptors


Endpoints 1/2

Un endpoint è composto da:● Endpoint URI● Connector● Filter● Transaction● Properties

Endpoint scopes:● Global

- Definitio uno sola volta nel mule-config.xml- Può essere usato ovunque

● Local- Definito per un servizio- Limitato alla sola configurazione di quel servizio


Endpoints 2/2

● Regole di annotazione

● Descritto totalmente in XML

● E' definito un namespace per ogni transport

● Ogni transport ha specifici elementi (transport details)

● Template di annotazione XML:

<[transport ns]:[inbound-endpoint|outbound-endpoint] [transport details] />

● Examples:

● <file:outbound-endpoint path="directory/temp"/>

● <file:inbound-endpoint path="C:/indir" transformer-ref="FileToString"/>

● <cxf:inbound-endpoint address="http://atosorigin.com/webservice"/>

● <vm:inbound-endpoint path="jvmqueue.in"/>

● <http:inbound-endpoint url="http://localhost:8080/MyServletApp/>


Transports 1/2

● Responsabile della traffico di invio/ricezione dei messaggi verso i sistemi target/source

● E' composto da:

● Message receiver/dispatcher● Connector● Transformer


Transports 2/2

● Large number of available transports, such as :● AS400, JCR, SMTPS, FTP, POP3S, XMPP, Axis,

JDBC, SOAP, HTTP, Quartz, SMTP, BPM, Jetty, SSL, HTTPS, RMI, IMAPS, CXF, Jetty SSL, STDIO, IMAP, Servlet, VM, EJB, JMS, UDP, File, POP3, Email

● http://www.mulesoft.org/display/MULE2USER/ Available+Transports


Services

● Un service è tutto ciò che permette di creare un'accoppiamento end-to-end tra sistemi

● E' composta da:- Description: nome user friendly- Inbound Routers: con endpoint(s) e transformer(s)- Service Component

- contiene la logica di business necessaria all'esecuzione corretta della transazione- È un classe Java, un webservice o qualsiasi cosa di “pluggabile” nell'ESB

- Outbound Routers: con endpoint(s) e transformer(s)- Exception strategy: gestione delle eccezioni


Services components

● Un service component può essere un qualsiasi tipo di oggetto, uno spring bean, un POJO, un web service o una chiamata REST

● E' possibile scrivere facilmente dei componenti custom

● Mule usa la reflection per capire quale metodo invocare (Spesso sulla base del tipo del payload)

● Nota: un componente può anche non restituire un messaggio. Nell'esempio il log component non restituisce niente

package com.myfactory.muledemo.beans.MessageBean;public class CustomLogComponent implements Serializable {

public void accept(String payload) {System.out.println("Current payload: " +payload);

}}


Standard Service Components


Service Component Entry Point

● Un service component è spesso un POJO o un bean con diversi metodi

● Mule per determinare quale metodo invocare in un POJO segue le seguenti regole:

1. Verifica se è stata specificata la property “method”

2. Se il POJO implementa l'interfaccia org.mule.api.lifecycle.Callable Mule invoca il metodo onCall()

3. Se in configurazione è stato aggiunto un transformer, il tipo restituito da quest'ultimo viene usato per cercare se esiste un metodo che accetta tale tipo.

4. Se sono ancora presenti più metodi che rispondono ai requisiti precedenti Mule prende quello che corrisponde al tipo di payload


Transformers

● Componenti che trasformano da un formato di messaggio ad un altro o arricchiscono il contenuto del messaggio

● Configurati all'interno degli endpoints

● Vengono applicati automaticamente

● Si possono combinare diversi transformers (“chaining”)

● Mule applica transformers impliciti per le comunicazioni interne


Standard Transformers

● FileToString, ObjectToString, StringToEmailMessage● XML

● XmlToObject / ObjectToXml● DomToXml / XmlToDom● JXPath

● Encryption / Decryption● GZipCompress / GZipUncompress● Base64Encoder / Base64Decoder● StringToByteArray / ByteArrayToString


Custom Transformers 1/2

● E' facile scrivere transformers custom:● Estendendo

org.mule.transformer.AbstractTransformer

● o implementandoprotected Object doTransform(Object payload, String encoding)

● I tipi attesi in input e output sono definiti nel costruttore del transformer


Custom Transformers 2/2

public class FileToString extends FileToByteArray {public FileToString() {

//define accepted input typeregisterSourceType(byte[].class);//define return typesetReturnClass(String.class);

}

@Overridepublic Object doTransform(Object payload, String encoding)

throws TransformerException {byte[] bytes;String output;//call transform method from super classbytes = (byte[]) super.doTransform(payload, encoding);output = new String(bytes, encoding);return output;

}}


Filters

● Con i Filters si esprimono le condizioni per le quali un messaggio (o il suo payload) sono accettate e/o dirottate da/verso un determinato service

● Restituiscono un boolean per accettare o meno il passaggio del messaggio

● Standard filters:

● Payload Type Filter, RegEx Filter, Wildcard Filter, XPath Filter, Logic Filters, Message Property Filter

● Ancora una volta, scrivere il proprio filter non è difficile

<payload-type-filter name="payloadFilter" expectedType="java.lang.String"><model><service><inbound>

<tcp:inbound-endpoint host="localhost" port="1234"/><filter ref="payloadFilter"/>

</inbound><echo-component/><service></model>


Interceptors

● Gli Interceptors permettono allo sviluppatore di inserire della logica in determinati punti del flusso esecutivo classico di Mule e potenzialmente anche di alterarne il normale proseguio

● Esistono due tipi di interceptors:

● Envelope interceptor

– Può essere eseguito prima e dopo l'invocazione di un componente

– Utile per azioni di logging e profiling● Message Interceptor

– Intercetta il messaggio e poi lo inoltra al prossimo elemento– Può stoppare il flusso stoppando l'inoltro– Utile per la verifica dei permessi

● Gli Interceptors possono essere raggrupati in interceptor-stacks


Interceptor Stack


Interceptor example

<interceptor-stack name="bunchOfInterceptors"><custom-interceptor class="com.mc.muledemo.CustomInterceptor"/><logging-interceptor/>

</interceptor-stack><model name="MyModel">

<service name="MyService"><component>

<custom-interceptor class="com.mc.muledemo.MyFirstInterceptor"/>

<logging-interceptor/><interceptor-stack ref="bunchOfInterceptors"/><timer-interceptor/>

</component></service>

</model>


Custom Interceptors

● Message Interceptors

● Implenta l'interfaccia Interceptor

MuleMessage intercept(Invocation invocation) throws MuleException;

● Deve restituire un MuleMessage che viene passato al successivo componente

● Envelope interceptors

● Implementa l'interfaccia EnvelopeInterceptor

MuleMessage before(Invocation invocation) throws MuleException;

MuleMessage after(Invocation invocation) throws MuleException;

● In configurazione sono definiti con il tag <custom-interceptor>


Routers

● Determinano cosa e dove i messaggi vengono inviati o ricevuti

● Due tipi principali● Outbound router

– Per definire l'invio dei messaggi in uscita● Inbound router

– Per configurare l'ascolto sui messaggi in entrata

● Definiti nei tag <inbound></inbound> e <outbound></outbound>


Piattaforma Tecnologica

Sistemi operativi:

Windows XP SP2, Windows 2000, Windows 2003 Server (32-bit if using the Java Service Wrapper), Linux, Solaris, AIX, HP-UX, and Mac OSX

Application Servers:

Tomcat, JBoss, WebSphere, WebLogic, and Jetty

Java JDK 1.5 and 1.6


Download e Installazione

● URL per il download:http://www.mulesoft.org/download-mule-esb-community-edition

● Scaricare il file .tar.gz ● Estrarre il file nella cartella scelta come Home

Directory di Mule● Creare la variabile d'ambiente MULE_HOME in

modo che punti alla directory di installazione di Mule


Struttura della cartella ROOT di Mule

● /bin - Startup scripts● /conf – File di configurazione● /examples - Esempi (ozionale)● /lib/user - JARs aggiuntive● /logs - Logs


Mule IDE per Eclipse (1)

● Accedere alla sezione Help>Install New Software di Eclipse

● Aggiungere il repository:http://dist.muleforge.org/mule-ide/updates/3.4/

● Selezionare Mule IDE e installare● Riavviare Eclipse

http://dist.muleforge.org/mule-ide/updates/3.4/


Mule IDE per Eclipse (2)

● Accedere alla sezione Window>Preferences

● Selezionare la voce Mule e poi Add● Specificare la Home Directory di Mule● Applicare le modifiche


Creazione di un progetto Mule su Eclipse

● Accedere alla sezione File > New > Project, selezionare la voce Mule > Mule Project.

● Dare un nome al progetto, assicurandosi che non esistano directory con lo stesso nome all'interno del workspace.

● Per aggiungere un progetto d'esempio spuntare la voce 'Add sample project content' e selezionare l'esempio desiderato.

● Verificare che siano installate le librerie Java 5 o versioni superiori e cliccare su Finish.


Lanciare un'applicazione Mule

● Nel caso di Mule IDE è sufficiente accedere alla cartella /conf del progetto e cliccare con il destro sul file your-config.xml e selezionare la voce Runs As > Mule Server

● Nel caso di un utilizzo esterno ad Eclipse è necessario: ● che il file di configurazione sia all'interno della

cartella /conf nella Home Directory di Mule● da questa posizione lanciare sul terminale il

comando mule [-config your-config.xml].

In questo caso inoltre è necessario inserire eventuali file .jar nella cartella /lib/user


Il file di configurazione


Un esempio di applicazione Mule: Echo (1)

<?xml version="1.0" encoding="UTF-8"?><mule xmlns="http://www.mulesource.org/schema/mule/core/2.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:spring="http://www.springframework.org/schema/beans" xmlns:stdio="http://www.mulesource.org/schema/mule/stdio/2.2" xmlns:vm="http://www.mulesource.org/schema/mule/vm/2.2" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.mulesource.org/schema/mule/core/2.2 http://www.mulesource.org/schema/mule/core/2.2/mule.xsd http://www.mulesource.org/schema/mule/stdio/2.2 http://www.mulesource.org/schema/mule/stdio/2.2/mule-stdio.xsd http://www.mulesource.org/schema/mule/vm/2.2 http://www.mulesource.org/schema/mule/vm/2.2/mule-vm.xsd">

<description> This is a simple component example that demostrates how to expose a component over multiple transports. </description> <stdio:connector name="SystemStreamConnector" promptMessage="Please enter something: " messageDelayTime="1000"/>........</mule>


Un esempio di applicazione Mule: Echo (2)

<model name="echoSample"> <service name="EchoUMO"> <inbound> <stdio:inbound-endpoint system="IN"/> <vm:inbound-endpoint path="echo"/> </inbound>

<echo-component/>

<outbound> <pass-through-router> <stdio:outbound-endpoint

system="OUT"/> </pass-through-router> </outbound> </service> </model>


Un esempio di applicazione Mule: Echo esposto come web service SOAP

<?xml version="1.0" encoding="UTF-8"?><mule xmlns="http://www.mulesource.org/schema/mule/core/2.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:spring="http://www.springframework.org/schema/beans" xmlns:soap="http://www.mulesource.org/schema/mule/soap/2.2" xmlns:axis="http://www.mulesource.org/schema/mule/axis/2.2" xmlns:vm="http://www.mulesource.org/schema/mule/vm/2.2" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.mulesource.org/schema/mule/core/2.2 http://www.mulesource.org/schema/mule/core/2.2/mule.xsd http://www.mulesource.org/schema/mule/soap/2.2 http://www.mulesource.org/schema/mule/soap/2.2/mule-soap.xsd http://www.mulesource.org/schema/mule/axis/2.2 http://www.mulesource.org/schema/mule/axis/2.2/mule-axis.xsd http://www.mulesource.org/schema/mule/vm/2.2 http://www.mulesource.org/schema/mule/vm/2.2/mule-vm.xsd">

<description> Per invocare il servizio: http://localhost:65081/services/EchoUMO?method=echo&param=GERONIMOOOO WSDL del servizio hall'indirizzo: http://localhost:65081/services/EchoUMO?wsdl </description>

<model name="echoSample"> <service name="EchoUMO"> <inbound> <axis:inbound-endpoint address="http://localhost:65081/services"> <soap:http-to-soap-request-transformer/> </axis:inbound-endpoint> <axis:inbound-endpoint address="http://localhost:65082/services"/> <vm:inbound-endpoint path="echo" /> </inbound> <echo-component/> </service> </model>

</mule>


Link Utili

● Guida Utente:http://www.mulesoft.org/display/MULE2USER/Home

● API documentation:http://www.mulesoft.org/docs/site/current2/apidocs/

● Esempi:http://www.mulesoft.org/display/MULE2INTRO/Examples

● Blog "From the Mule's mouth"http://blogs.mulesoft.org/

● Corso Online: Mule ESB Fundamentalshttp://www.mulesoft.com/virtual-course-mule-esb-fundamentals

● Mule ESB & Integration resourceshttp://www.mulesoft.com/esb-integration-resources

http://www.mulesoft.org/display/MULE2USER/Home

http://www.mulesoft.org/docs/site/current2/apidocs/

http://www.mulesoft.org/display/MULE2INTRO/Examples

http://blogs.mulesoft.org/

http://www.mulesoft.com/virtual-course-mule-esb-fundamentals

http://www.mulesoft.com/esb-integration-resources

Technology

ESB: The Mule Solution