TRAX(Transformation Api for XML) in Java

Jaxp è un API(Application Programming Interface) offerta da Java per manipolare documenti XML, l’implementazione di Jaxp è reperibile mediante il jar di Xercer (http://xerces.apache.org/). Jaxp offre anche una API per la trasformazione a runtime dei fogli XSLT con Java.
Qualora si voglia sfruttare questa tecnologia è opportuno inserire xalan.jar all’interno del proprio progetto Java.
XSLT (eXtensible Stylesheet Language Transformations) è un linguaggio Turing completo che estende il concetto di foglio di stile per gli XSL permettendone mediante appositi costrutti (ad esempio per i template xsl:template,…) la manipolazione dello stile del documento. Gli XSLT in parole povere non sono altro che la trasformazione di documenti XML in documenti XHTML, i quali saranno poi visualizzabili sui browser.

Ma tornando a TRAX(traxtransformation api for xml in java), i passi da seguire per effettuare una trasformazione XSLT con Java sono:

Passaggi trasformazione XSLT in Java.

Semplifichiamo la trattazione con un esempio supposto aver un file XML e un file XSLT nel nostro progetto Java, chiamando il seguente metodo otterremo una stringa di codice XHTML che potrà essere passata alla JSP(Java Server Page) per visualizzare la trasformazione XSLT.

    /**
     * Transformazione in codice XHTML mediante TRAX.
     * Autore: Gianluca Di Vincenzo.
     *
     * @param f file xml.
     * @param xslt file xslt.
     * @return stringa XHTML.
    */
    public String transformDocument(File f, File xslt) {
        // Definizione dell'ErrorListener.
        MyErrorListener errorListner = new MyErrorListener();
        // Istanziazione del TransformerFactory mediante il metodo newIstance().
        TransformerFactory tsf = TransformerFactory.newInstance();
        // Settaggio dell'ErrorListner sulla Factory.
        tsf.setErrorListener(errorListner);
        try {
            /*
             * Generazione del Trasformer partendo dalla TransformerFactory
             * associata alla risorsa XSLT, oggetto di tipo Source.
             */
            Transformer t = tsf.newTransformer(new StreamSource(xslt));
            t.reset();

            // Settaggio dell'ErrorListner sul Transformer.
            t.setErrorListener(errorListner);

            // StringWriter su cui effettuare la trasformazione.
            StringWriter w = new StringWriter();

            /*
             * Trasformazione mediante il metodo transform di Transformer, 
             * il quale prende in input un oggetto Source e un oggetto Result.
             */
            t.transform(new StreamSource(f), new StreamResult(w));

            // Restituisco la stringa dopo la transcodifica.
            return w.toString();
        } catch (TransformerConfigurationException ex) {
            Logger.getLogger(TraXTechnology.class.getName()).log(Level.SEVERE, null, ex);
        } catch (TransformerException ex) {
            Logger.getLogger(TraXTechnology.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }

Per essere completi nella trattazione nel codice è possibile scorgere un ErrorListner customizzato (MyErrorListener) definito da me a seconda delle evenienze.
E’ buona norma definire in questa sede un ErrorListner per scovare possibile errori nel file XSLT a tal proposito si riporta il codice sorgente della classe java MyErrorListener.java per può essere semplicemente riadattata a seconda delle vostre esigenze.

import javax.xml.transform.ErrorListener;
import javax.xml.transform.TransformerException;

/**
 * Implementazione delle operazioni dell'ErrorListner.
 *
 * @autore Gianluca Di Vincenzo.
 */
public class MyErrorListener implements ErrorListener {

    private int nErrors, nWarnings, nFatals;

    /**
     * Costruttore del mio ErrorListner.
     */
    public MyErrorListener() {
        reset();
    }

    /**
     * Reset dell'ErrorListner.
     */
    public void reset() {
        nErrors = 0;
        nWarnings = 0;
        nFatals = 0;
    }

    /**
     * Problemi legati all'ErrorListner.
     *
     * @return true se ho dei problemi, false altrimenti.
     */
    public boolean hasErrors() {
        return ((nFatals + nErrors) > 0);
    }

    /**
     * Warning legati all'ErrorListner.
     *
     * @param ex TransformerException.
     * @throws TransformerException
     */
    @Override
    public void warning(TransformerException exception) throws TransformerException {
        System.err.println(
                "Warning (" + exception.getLocator().getSystemId()
                + ": " + exception.getLocator().getLineNumber()
                + "," + exception.getLocator().getColumnNumber()
                + ") " + exception.getMessage());
        nWarnings++;
    }

    /**
     * Errori legati all'ErrorListner.
     *
     * @param ex
     * @throws TransformerException
     */
    @Override
    public void error(TransformerException exception) throws TransformerException {
        System.err.println(
                "Errore (" + exception.getLocator().getSystemId()
                + ": " + exception.getLocator().getLineNumber()
                + "," + exception.getLocator().getColumnNumber()
                + ") " + exception.getMessage());
        nErrors++;
    }

    /**
     * Errori fatali legati all'ErrorListner.
     *
     * @param ex eccezione da valutare.
     * @throws TransformerException
     */
    @Override
    public void fatalError(TransformerException exception) throws TransformerException {
        System.err.println(
                "Errore fatale (" + exception.getLocator().getSystemId()
                + ": " + exception.getLocator().getLineNumber()
                + "," + exception.getLocator().getColumnNumber()
                + ") " + exception.getMessage());
        nFatals++;
        throw exception;
    }
}