Relation entre le processeur et Java API for XML Processing (JAXP)

Dans la plupart des cas, vous devrez migrer toutes les applications qui utilisaient l'API JAXP (Java™ API for XML Processing) vers la nouvelle API.

Les étapes de traitement pour XSLT et XPath de l'API JAXP sont définies pour XSLT 1.0 et XPath 1.0. L'API JAXP n'est pas conçue pour traiter des données de XSLT 2.0 et XPath 2.0. En particulier, dans certaines situations, un processeur XSLT 2.0 ou XPath 2.0 doit produire un résultat différent de celui généré par un processeur XSLT 1.0 ou XPath 1.0 à partir d'une entrée identique et d'une feuille de style ou d'une expression également identiques. Il est donc impossible d'instancier le processeur actuel avec JAXP.

JAXP ne prend pas en charge les séquences, XQuery 1.0, ou les nombreux types de données disponibles dans XSLT 2.0, XPath 2.0 et XQuery 1.0. JAXP est également soumis à certaines restrictions s'agissant du format des entrées et des sorties. Pour toutes ces raisons, JAXP est un outil peut adapté au traitement des feuilles de style XSLT 2.0 et XPath 2.0 et des expressions XQuery 1.0.

Les exemples suivants décrivent des scénarios de migration courants et détaillent comment utiliser l'API actuelle pour créer un code équivalent à celui que vos pourriez créer avec JAXP.

Traitement d'une feuille de style XSLT avec l'API

L'exemple suivant montre comment traiter une feuille de style XSLT et l'appliquer à une entrée afin de créer une instance de l'interface javax.xml.transform.Result.
XFactory factory = XFactory.newInstance();
XSLTExecutable style = factory.prepareXSLT(new StreamSource("style.xsl"));
style.execute(new StreamSource("input.xml"), new StreamResult(System.out));

Traitement d'une expression XPath avec l'API

L'exemple suivant montre comment traiter une expression XPath et l'appliquer à une entrée.
XFactory factory = XFactory.newInstance();
XPathExecutable pathExpr = factory.prepareXPath("/doc/child[@id='N1378']");

// Process input from a StreamSource
XSequenceCursor result1 = pathExpr.execute(new StreamSource("input.xml"));

// Process input from a DOM node
XSequenceCursor result2 = pathExpr.execute(new DOMSource(node));

Résolution des références d'URI

Si vous avez utilisé une instance de l'interface JAXP URIResolver pour résoudre les références à la fonction XSLT document(), vous pouvez maintenant utiliser l'interface XSourceResolver pour faire la même chose. Pour résoudre les références à la fonction document() ou à la fonction fn:doc(), vous pouvez définir une instance de l'interface XSourceResolver sur une instance de l'interface XDynamicContext. Pour résoudre les références aux feuilles de style importées via des déclarations xsl:import et xsl:include, vous pouvez définir une instance de l'interface XSourceResolver sur une instance de l'interface XStaticContext.

L'exemple suivant montre comment définir une instance de l'interface XSourceResolver qui traite les documents d'entrée comme des feuilles de style XSLT et les utiliser pour générer les données d'entrée requises pour référencer les fonctions doc ou document dans une autre feuille de style XSLT.
final XFactory factory = XFactory.newInstance();
XSLTExecutable style = factory.prepareXSLT(new StreamSource("style.xsl"));
XDynamicContext dContext = factory.newDynamicContext();

// Create and set an instance of an anonymous inner class as the
// XSourceResolver
dContext.setSourceResolver(new XSourceResolver() {
    // Create an item to use as the initial context node for
    // transformations in the getSource method
    private XItemView fDummyNode =
        factory.getItemFactory()
            .item(new StreamSource(
                new StringReader("<doc/>")));

    // Resolve URIs by loading the resource as an XSLT stylesheet
    // and evaluating it - return the result as the Source to use
    public Source getSource(String href, String base) {
        java.net.URI baseURI;
        try {
            // Get base URI object
            baseURI = new java.net.URI(base);
        } catch (java.net.URISyntaxException use) {
            throw new RuntimeException(use);
        }
        // Resolved relative reference against base URI
        String resolvedURI = baseURI.resolve(href).toString();

        // Prepare and execute the stylesheet
        XItemView transformResult =
            factory.prepareXSLT(new StreamSource(resolvedURI))
                .execute(fDummyNode);
        return new XItemSource(transformResult);
    }
});

XSequenceCursor result = style.execute(new StreamSource("input.xml"), dContext);

Définition des fonctions d'extension et des fonctions externes

Si vous utilisez JAXP pour évaluer des expressions XPath, vous pouvez enregistrer une instance de l'interface XPathFunctionResolver pour fournir les implémentations des fonctions d'extension que ces expressions XPath appelleront le cas échéant. La section XSLT de JAXP ne possède pas de mécanisme équivalent.

L'API actuelle vous permet de déclarer des fonctions d'extension sur une instance de l'interface XStaticContext en spécifiant les types d'arguments et les types de résultats attendus après l'appel de la fonction. Vous pouvez aussi enregistrer les implémentations des fonctions d'extension sur une instance de l'interface XDynamicContext. La feuille de style XSLT et les expressions XQuery et XPath que vous définissez de cette manière peuvent appeler n'importe quelle fonction d'extension que vous avez enregistrée.

Définition des valeurs des paramètres de feuille de style et des variables externes

Avec JAXP, vous pouvez fournir les valeurs initiales des paramètres de feuille de style en appelant la méthode Transformer.setParameter et vous pouvez fournir les valeurs des variables des expressions XPath en fournissant une instance de l'interface XPathVariableResolver. L'API vous permet de déclarer les variables à l'aide des méthodes declareVariable() de l'interface XStaticContext en indiquant un nom de variable et son type. Vous pouvez aussi indiquer les valeurs des paramètres de feuille de style, des variables XPath et des variables externes XQuery via l'une des méthodes bind() de l'interface XDynamicContext.

L'exemple suivant montre comment utiliser une variable dans une expression XPath afin de rechercher des entrées de produit dans un catalogue sur la base des identificateurs de produit.
XFactory factory = XFactory.newInstance();
XStaticContext sContext = factory.newStaticContext();

// Declare the XPath variable "query-id" in the static context
QName queryIdVar = new QName("query-id");
sContext.declareVariable(queryIdVar, XTypeConstants.STRING_QNAME);

// Prepare the XPath expression
XItemFactory itemFactory = factory.getItemFactory();
XPathExecutable expr =
    factory.prepareXPath("/catalog/product[id eq $query-id]", sContext);

XItemView catalog = itemFactory.item(new StreamSource("catalog.xml"));
XDynamicContext dContext = factory.newDynamicContext();

// Set the value of the "query-id" variable, and evaluate the
// expression with that variable value
dContext.bind(queryIdVar, "ID43785");
XSequenceCursor product1 = expr.execute(catalog, dContext);

// Set the value of the "query-id" variable, and evaluate the
// expression with the new variable value
dContext.bind(queryIdVar, "ID18574");
XSequenceCursor product2 = expr.execute(catalog, dContext);

Transformation des identités

La transformation d'identité figure également parmi les opérations fréquemment réalisées dans JAXP. Il s'agit d'une méthode pratique pour convertir des données d'un format vers un autre, par exemple pour sérialiser une arborescence DOM ou pour générer une arborescence DOM à partir d'événements SAX. L'API permet d'exécuter ces transformations d'identité. Voir Exécution d'opérations de base avec XSLT pour obtenir un exemple.

Configuration au moment de la préparation et de l'exécution

Avec JAXP, vous devez fournir une grande partie des données de configuration d'exécution pour les feuilles de style XSLT, c'est-à-dire les valeurs des paramètres des feuilles de style, les URIResolvers, etc, directement dans les objets qui seront utilisés pour exécuter les transformations, c'est-à-dire les instances de l'interface Transformer et de l'interface TransformerHandler. De même vous devez fournir les données de configuration requises pour la préparation des feuilles de style et des expressions XPath directement dans les instances des classes TransformerFactory et XPathFactory dans JAXP.

Grâce à l'API, vous pouvez fournir ces données de configuration pendant la préparation d'une feuille de style ou d'une expression, en particulier les liaisons d'espace de noms, les types de fonctions externes et de variables, etc, avec une instance de l'interface XStaticContext. De même, vous pouvez fournir les données de configuration requises pour évaluer une feuille de style ou une expression, c'est-à-dire les valeurs des variables, celles des paramètres de sortie, etc, dans une instance de l'interface XDynamicContext que vous transmettrez comme argument aux méthodes execute de l'interface XExecutable et de ses sous-interfaces.

Cette séparation des données de configuration entre plusieurs objets sécurise davantage les unités d'exécution de l'API. Votre application peut utiliser la même instance de l'interface XExecutable dans différentes unités d'exécution sans exiger de synchronisations. Ceci contraste avec JAXP, où les instances des interfaces Transformer, TransformerHandler et XPathExpression ne bénéficient pas de la même sécurité au niveau des unités d'exécution. En effet, chaque unité d'exécution qui utilise ces interfaces doit synchroniser l'accès aux instances partagées de ces objets ou en créer des copies distinctes et réservées à son usage exclusif.

Gestion des erreurs

Dans JAXP, vous pouvez fournir une instance de l'interface ErrorHandler pour contrôler la manière dont le processeur répond aux erreurs. Vous pouvez le faire dans l'API en fournissant une instance de l'interface XMessageHandler dans une instance de l'interface XStaticContext pour les erreurs de préparation ou dans une instance de l'interface XDynamicContext pour les erreurs d'exécution.


Icône indiquant le type de rubrique Rubrique de concept



Icône d'horodatage Dernière mise à jour: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=cxml_jaxp
Nom du fichier : cxml_jaxp.html