Xbean, la prossima generazione di JavaBeans, promette di semplificare il processamento di documenti XML. La trasformazione di documenti XML è alla base di molti sistemi di scambio di dati o di ERP System e gli Xbean si propongono di facilitare proprio questo tipo di processamento.
Introduzione
Nel mercato odierno XML sta di fatto diventando lo standard per lo scambio di informazioni tra applicazioni. Non soltanto aziende, ma anche organizzazioni per lo sviluppo di business protocol come RosettaNet, utilizzano XML come standard di riferimento per le transazioni.
Molta strada è stata fatta, specialmente in Java, nel costruire API per facilitare la manipolazione e la trasformazione di documenti XML. Esempi degni di essere menzionati sono naturalmente DOM, il W3C Document Object Model, utilizzato in Xerces e Xalan, librerie di grande successo, e JDOM, più semplice ma meno flessibile.
Un interessante nuovo sviluppo nel mondo XML è l’introduzione degli Xbean: piccoli e semplici componenti che accettano un documento XML come input, lo processano e, in qualche modo, lo passano ad un altro Xbean per una ulteriore trasformazione.
Xbean
È possibile pensare agli Xbean come a una catena di componenti, ognuno dei quali applica una trasformazione ad un documento XML sorgente. L’insieme degli Xbean viene chiamato canale, concetto simile alle pipe in Unix.
Figura 1: Canale di Xbean
Con questo tipo di approccio possiamo costruire delle semplici librerie che possono essere riutilizzate per trasformare documenti XML in una varietà di modi diversi. È bene sottolineare che gli Xbean ricevono e trasmettono documenti DOM e non stringhe che devono essere parsate da un XML parser.
Un Xbean è un JavaBean che trasforma documenti XML. Questo significa che un Xbean ha la classica struttura di un JavaBean:
costruttore con zero argomenti;
metodi set e get per modificare proprietà.
In più, gli Xbean utilizzano bean event per comunicare tra di loro. Questo è un concetto chiave perché, come abbiamo accennato nell’introduzione, gli Xbean formano una catena di trasformazione in cui ogni elemento applica una trasformazione ad un documento XML. Naturalmente dopo la trasformazione l’Xbean deve passare il documento così trasformato all’anello successivo della catena: questo passaggio viene effettuato utilizzando un bean event.
L’Xbean, come ogni altro JavaBean, utilizza la delegazione di eventi come modello di comunicazione. In tale modello la comunicazione avviene attraverso il passaggio di event object. In particolare sono tre gli elementi che definiscono il modello di comunicazione tra Xbean:
Event Object
Event Source
Event Listener
L’implementazione avviene attraverso:
un normale documento DOM come event object;
l’interfaccia DOMSource come event source;
l’interfaccia DOMListener come event listener.
Vediamo in maggior dettaglio queste interfacce.
DOMSource interface
Due metodi vengono definiti in questa interfaccia: setDOMListener(DOMListener destinatario) e getDOMListener(), per definire e ritornare l’Xbean che riceverà l’evento. Un Xbean che implementa la sola interfaccia DOMSource viene chiamato Xbean sorgente.
Figura 2: Xbean sorgente
DOMListener interface
Definisce un unico metodo documentReady(DOMEvent evt) che viene chiamato dall’Xbean sorgente per passare il documento XML. È all’interno di questo metodo che viene eseguita la trasformazione sul documento XML ricevuto. Dopo la trasformazione il documento viene eventualmente passato al successivo anello della catena. Un Xbean che implementa la sola interfaccia DOMListener viene chiamato sink Xbean.
Figura 3: Sink Xbean
Quando si parla di trasformazioni su documenti XML viene naturalmente alla mente XSL. Anche se l’idea originaria non parla esplicitamente dell’utilizzo di XSL per la fase di trasformazione, questa è, a mio parere, il modo più elegante ed efficace per trasformare documenti XML.
Nella letteratura Xbean c’è un accenno all’utilizzo di XSL. In particolare, se si utilizza XSL nella fase di trasformazione, il bean risultante viene chiamato XSLTransformBean. In questo caso viene utilizzata la libreria Xalan per applicare lo stylesheet XSL e generare il documento risultante. L’XSLTransformBean necessita di due nuovi metodi:
Il risultato può essere diretto su un file, uno stream di byte o di caratteri oppure un documento DOM che può essere passato ad un altro Xbean per una ulteriore trasformazione. Il metodo processDocument() verrà esplicitamente riscritto per utilizzare la XSLTProcessorFactory allo scopo di istanziare una implementazione della interfaccia XSLTProcessor.
Per concludere questa sezione e passare quindi ad un esempio concreto vorrei sottolineare il fatto che gli Xbean sono lightweight component, cioè molto semplici e con poche linee di codice. Noterete questa particolarità negli esempi che seguono.
Esempi di uso degli Xbean
Scambio di dati tra enterprise
Gli standard adottati in ogni singola enterprise possono essere descritti attraverso XML Data Type Definition, che rappresentano la semantica ed il formato dei dati che devono essere scambiati. Ma ogni enterprise rappresenta i propri dati in modo diverso e l’idea che vogliamo adottare è quella di raccogliere i dati originali nel database sorgente, trasformarli nel corrispettivo XML secondo uno standard definito da qualche DTD, trasportarli, trasformarli ancora nel formato adottato nell’enterprise di destinazione e finalmente memorizzarli. Questo tipo di trasformazione è alla base di molti ERP System presenti oggi sul mercato.
Figura 4: Semplice sistema ERP
Ogni Xbean è configurato in maniera opportuna:
l’Xbean connector viene configurato per eseguire una particolare query SQL e trasformare il risultato in un documento XML che soddisfa il particolare DTD dell’azienda;
il translator trasforma il documento XML ricevuto dal connector in un nuovo documento XML conforme al formato accettato come formato di scambio;
gli Xbean sender e receiver vengono utilizzati come trasporto di dati e non effettuano nessuna trasformazione, o se volete una trasformazione identità;
il translator sul lato destinazione trasforma il documento nel formato conforme all’azienda di destinazione.
Generici Xbean
I generici Xbean processano ogni tipo di documento XML utilizzando la DOM API e vengono configurati utilizzando il meccanismo standard del property file. Di seguito viene riportata una lista di generici Xbean utili in molte applicazioni:
Accessor: esegue particolari query SQL e rappresenta il risultato come un documento XML. Può anche ricevere un documento come input e memorizzarlo attraverso una query SQL.
Translator: traduce un documento XML da un arbitrario DTD ad un altro.
Sender/Receiver: trasmette documenti XML attraverso la rete senza modificarli.
Viewer: visualizza il contenuto di un documento XML utilizzando uno Swing tree.
Parser: converte un documento XML dal suo formato testuale alla sua rappresentazione DOM.
Writer: converte un documento DOM nella sua rappresentazione testuale e lo memorizza in un file.
Logger: crea una log entry ogni volta che un documento XML viaggia attraverso il logger.
Parallelizer: riceve un singolo DOM che viene passato a molteplici listener.
Synchronizer: riceve molteplici DOM che vengono passati ad un singolo listener.
Esempio reale
Per avere una maggiore confidenza nell’uso degli Xbean, costruiamo un esempio reale. Nel nostro esempio costruiremo un sistema che legge dati da un database sorgente, li trasforma e li memorizza in un database destinazione. Il formato dei dati dal database sorgente a quello destinazione è ovviamente diverso e rappresentato mediante uso di file XML.
Vediamo il sistema che andremo a costruire:
Figura 5: Sistema d'esempio
Potete pensare ai due database come archivi che appartengono a due applicazioni diverse, e questo esempio come un semplice caso di sistema ERP in cui applicazioni possono comunicare tra di loro. La trasformazione verrà applicata utilizzando una catena di Xbean.
Come database sorgente è stato utilizzato MS SQL, in particolare il famoso Northwind. La tabella prescelta è Orders con la seguente struttura:
Orderid nvarchar(15)
Customerid int
Date smalldate
TrackingNumber nvarchar(50)
Status smallint
CardType smallint
CardHolder nvarchar(50)
CardNumber nvarchar(20)
CardExp nvarchar(8)
Address nvarchar(50)
City nvarchar(50)
State nvarchar(50)
Zip nvarchar(10)
Country nvarchar(50)
Come destinazione è stato utilizzato lo stesso database, anche se in realtà dovrebbe essere un database completamente diverso, e la tabella in cui vengono inserite le informazioni trasformate ha la seguente struttura:
OrderNumber int (automatico)
ClientiD nvarchar(50)
POReference nvarchar(50)
Date smalldate
Da osservare che il sistema destinazione avrà il proprio numero d’ordine ed il codice cliente sarà il codice assegnato all’azienda sorgente dall’azienda destinazione. Il POReference sarà l’Orderid nella tabella sorgente. Il mapping che verrà eseguito sarà:
Figura 6: Mapping dei dati
XFileReader
Questa classe estende direttamente Xbean ed aggiunge il metodo setFile(String f) per leggere il file XML specificato. Il metodo documentReady() parsa semplicemente il file letto e costruisce un documento XML DOM. Il documento costruito viene quindi passato al componente successivo.
Figura 7: XFileReader
XQueryBean
Questo Xbean viene utilizzato per eseguire delle query su un database. In particolare le informazioni necessarie per la connessione al DB e la stessa query vengono specificate nel documento XML in input, nel nostro caso il file letto da XFileReader.
Figura 8: XQueryBean
In questo esempio, per la connessione al database viene utilizzato il bridge ODBC che è parte integrante della JDK Java e quindi disponibile a tutti. Per eseguire questo esempio potete utilizzare un database qualsiasi, anche Access, e creare una system DSN in modo da accedere al database attraverso il bridge.
Il formato del file XML è il seguente:
<?xml version="1.0" ?>
<connection>
<dsn>specificare il driver da utilizzare</dsn>
<user>user id</user>
<password>password</password>
<sql_query>select statement</sql_query>
</connection>
Per lo sviluppo dell’esempio è stata utilizzata una system ODBC chiamata XbeanSource ed il file di connessione è il seguente:
Il metodo documentReady esegue la query sul database specificato dai parametri passati ed il ResultSet ricevuto come risultato viene trasformato in un documento XML nel modo seguente:
Anche questo componente è molto semplice: riceve un documento DOM che viene trasformato utilizzando un file XSL. Il risultato viene quindi passato al successivo anello della catena, nel nostro caso un XDBWriter.
Il metodo setXslFile(String f) viene utilizzato per specificare il file XSL usato per la trasformazione. Il metodo processDocument chiama semplicemente il processore XSLT per la trasformazione. In questo esempio è stato utilizzato il processore Xalan 1.0.
Figura 9: XTransform
Il documento trasformato conterrà le informazioni necessarie per memorizzare i dati nel database destinazione. In particolare verrà utilizzato il seguente formato:
Come potete notare ho preferito inserire le informazioni per la connessione direttamente nel file trasformato, ma riconosco che questa scelta, seppur valida, non è molto elegante. È possibile ad esempio inserire un nuovo metodo nella classe XDBWriter per poter specificare un file di connessione, oppure leggere un file specifico nel costruttore della classe XDBWriter quando questa viene istanziata.
Il tag column_name viene utilizzato come nome del field in cui inserire il valore value nella tabella destinazione, indicata a sua volta dall’attributo table dell’elemento record.
XDBWriter
Questo componente si occupa di memorizzare le informazioni contenute nel documento DOM ricevuto sul database destinazione. Tutte le informazioni necessarie per la connessione e per il mapping nel database destinazione sono fornite dal file XML in input. Il metodo processDocument esegue quindi i seguenti passi:
utilizzando il file in input, crea una connessione con il database destinazione;
per ogni tag record esegue una INSERT sulla tabella specificata dall’attributo table;
i valori da inserire nelle colonne sono specificati dal contenuto dei tag figli.
Figura 10: XDBWriter
Di seguito riporto i listati dei componenti sopra descritti. La classe Controller è la classe che definisce la catena di Xbean e che inizia il processo di trasformazione.
Controller.java
import java.beans.Beans;
import java.io.*;
import com.ERPexample.*;
// Questa classe definisce il canale di Xbean e inizializza la catena di eventi
public class Controller extends Object {
public Controller() {
}
public static void main(String args[]) {
String reader = "com.ERPexample.XFileReader";
String query = "com.ERPexample.XQueryBean";
String transform = "com.ERPexample.XTransform";
String writer = "com.ERPexample.XDBWriter";
try {
com.ERPexample.XFileReader xfr =
(com.ERPexample.XFileReader) Beans.instantiate(null, reader);
com.ERPexample.XQueryBean xqb =
(com.ERPexample.XQueryBean) Beans.instantiate(null, query);
com.ERPexample.XTransform xtr =
(com.ERPexample.XTransform) Beans.instantiate(null, transform);
com.ERPexample.XDBWriter wtr =
(com.ERPexample.XDBWriter) Beans.instantiate(null, writer);
xfr.setFile("d:\\test\\connection.xml");
xtr.setXslFile("d:\\test\\DatabaseMapping.xsl");
xfr.setDOMListener(xqb);
xqb.setDOMListener(xtr);
xtr.setDOMListener(wtr);
xfr.processDocument();
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
}
XFileReader.java
public class XFileReader extends Xbean {
private String fileName;
private Document doc;
private InputSource is;
private DOMParser parser = new DOMParser();
public void setFile(String f) {
is = new InputSource(f);
fileName = f;
System.out.println("XFileReader->setFile called " + fileName);
}
public void processDocument() {
if (fileName != null) {
try {
parser.parse(is);
doc = parser.getDocument();
DOMEvent devent = new DOMEvent(this, doc);
doml.documentReady(devent);
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
System.out.println("XFileReader->processDocument called");
}
}
XQueryBean.java
public class XQueryBean extends Xbean {
String dsn;
String query;
String userID;
String password;
Connection conn;
DOMParser parser = new DOMParser();
public Document getDOMFromRecordset() {
StringBuffer XMLString = new StringBuffer();
Document result = null;
int count = 0;
String value;
String[] column;
if (dsn != null) {
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
if (userID != null)
conn = DriverManager.getConnection("jdbc:odbc:" + dsn, userID, password);
else
conn = DriverManager.getConnection("jdbc:odbc:" + dsn);
Statement stm = conn.createStatement();
ResultSet rs = stm.executeQuery(query);
ResultSetMetaData rsmd = rs.getMetaData();
int numColumns = rsmd.getColumnCount();
column = new String[numColumns];
for (int i = 1; i <= numColumns; ++i)
column[i - 1] = rsmd.getColumnName(i);
XMLString.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\\n");
XMLString.append("<table>\\n");
while (rs.next()) {
XMLString.append(" <record id=\\"" + count + "\\">\\n");
for (int i = 1; i <= numColumns; i++) {
value = rs.getString(i);
if (value != null && value.indexOf("&") > -1)
value = value.replace('&', ' ');
XMLString.append(" <" + column[i - 1] + ">" + value + "</" + column[i - 1] + ">\\n");
}
XMLString.append(" </record>\\n");
count++;
}
XMLString.append("</table>");
} catch (Exception e) {
System.out.println("An error occured: " + e.getMessage());
}
}
return result;
}
}
XTransform.java
public class XTransform extends Xbean {
private String xslFile;
private XSLTInputSource xsltis;
public void setXslFile(String f) {
xslFile = f;
xsltis = new XSLTInputSource(xslFile);
System.out.println("XTransform: setXslFile() method called ...");
}
public Document processDocument(Document d) {
XSLTResultTarget result = null;
Document xresult = new DocumentImpl();
if (d != null) {
try {
XSLTProcessor proc = XSLTProcessorFactory.getProcessor();
XSLTInputSource input = new XSLTInputSource(d);
result = new XSLTResultTarget(xresult);
proc.process(input, xsltis, result);
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
return xresult;
}
}
XDBWriter.java
public class XDBWriter extends Xbean {
String dsn;
String useriD;
String password;
Connection conn;
public void getDBinfo(Document d) {
// estrae dal DOM le informazioni di connessione
}
public void writeRecord(Document d) {
// per ogni record esegue la INSERT sulla tabella destinazione
}
public Document processDocument(Document d) {
if (d != null) {
getDBinfo(d);
writeRecord(d);
}
return null;
}
}
Ricordate di includere la Xbean library quando proverete questi esempi. La libreria è disponibile presso www.xbeans.org. Includete anche le librerie Xalan 1.0 e Xerces 1.0. I sorgenti con le rispettive librerie erano distribuiti via FTP nel folder /pub/Xbean.
Conclusione
Gli Xbean sono un interessante e valido strumento per la manipolazione e trasformazione di dati provenienti da diverse sorgenti. Sono particolarmente adatti nell’uso di applicazioni JSP per la loro naturale semplicità e velocità di esecuzione. Inoltre la loro specializzazione permette una facile riconfigurazione del sistema per arrivare a soluzioni diverse riutilizzando gli stessi componenti.
Nella vita reale la combinazione di Xbean insieme con XSL si è rivelata vincente in molti progetti di ERP integration.
Per qualsiasi dubbio o curiosità l’autore indicava come contatto crocettig@aol.com.
Bibliografia
`
[1]` Bruce Martin, `Xbeans` White Paper, `www.xbeans.org`
`
[2]` O'Donahue John, `The new face of Java Beans`, 2000
`
[3]` Sun, `Java Beans API`, `java.sun.com`
MokaByte®
è un marchio registrato da MokaByte s.r.l.
Java®, Jini® e tutti i nomi derivati sono marchi
registrati da Sun Microsystems.
Tutti i diritti riservati. E' vietata la riproduzione
anche parziale.
Per comunicazioni inviare una mail a info@mokabyte.it