Java API för XML -bearbetning - Java API for XML Processing

I beräkning , den Java API för XML Processing , eller JAXP ( / dʒ æ k s p jag / Jaks -pee ), en av de Java XML programmeringsgränssnitt , tillhandahåller möjligheten att validera och tolka XML -dokument. Den har tre grundläggande analysgränssnitt:

• den Document Object Model tolkning gränssnitt eller DOM -gränssnitt
• det enkla API för XML -analysgränssnitt eller SAX -gränssnitt
• den strömmande API för XML eller STAX gränssnitt (del av JDK 6, separat burk tillgängligt för JDK 5)

Förutom parsing -gränssnitten tillhandahåller API: et ett XSLT -gränssnitt för att tillhandahålla data och strukturella transformationer i ett XML -dokument.

JAXP utvecklades under Java Community Process som JSR 5 (JAXP 1.0), JSR 63 (JAXP 1.1 och 1.2) och JSR 206 (JAXP 1.3).

JAXP version 1.4.4 släpptes den 3 september 2010. JAXP 1,3 förklarades end-of-life den 12 februari, 2008.

DOM -gränssnitt

DOM-gränssnittet analyserar ett helt XML-dokument och konstruerar en fullständig in-memory-representation av dokumentet med hjälp av klasserna och modellering av begreppen som finns i Document Object Model Level 2 Core Specification.

DOM-parsern kallas a DocumentBuilder, eftersom den bygger en Documentrepresentation i minnet . Javax.xml.parsers.DocumentBuilder skapas av javax.xml.parsers.DocumentBuilderFactory. Den DocumentBuilderskapar en org.w3c.dom.Documentinstans - en trädstruktur som innehåller noder i XML -dokumentet. Varje trädnod i strukturen implementerar org.w3c.dom.Nodegränssnittet. Bland de många olika typerna av trädnoder, var och en representerar typen av data som finns i ett XML -dokument, är de viktigaste:

• elementnoder som kan ha attribut
• textnoder som representerar texten som finns mellan start- och sluttaggarna för ett dokumentelement.

SAX -gränssnitt

Javax.xml.parsers.SAXParserFactory skapar SAX -parsern, kallad SAXParser. Till skillnad från DOM-parsern skapar SAX-parsern ingen representation i XML-dokumentet i minnet och körs därför snabbare och använder mindre minne. Istället informerar SAX -parsern klienter om XML -dokumentstrukturen genom att åberopa återuppringning, det vill säga genom att anropa metoder på en org.xml.sax.helpers.DefaultHandler -instans som tillhandahålls parsern. Detta sätt att komma åt dokument kallas Streaming XML .

De DefaultHandlerklass implementerar den ContentHandler, den Errorhandler den DTDHandler och EntityResolver gränssnitt. De flesta klienter kommer att vara intresserade av metoder som definieras i ContentHandlergränssnittet som anropas när SAX-analysatorn möter motsvarande element i XML-dokumentet. De viktigaste metoderna i detta gränssnitt är:

• startDocument()och endDocument()metoder som anropas i början och slutet av ett XML -dokument.
• startElement()och endElement()metoder som anropas i början och slutet av ett dokumentelement.
• characters() metod som kallas med textdatainnehållet mellan start- och sluttaggarna för ett XML -dokumentelement.

Klienter tillhandahåller en underklass av den DefaultHandlersom åsidosätter dessa metoder och behandlar data. Detta kan innebära att data lagras i en databas eller skrivs ut till en ström.

Under analys kan parsern behöva komma åt externa dokument. Det är möjligt att lagra en lokal cache för ofta använda dokument med hjälp av en XML -katalog .

Detta introducerades med Java 1.3 i maj 2000.

StAX -gränssnitt

StAX utformades som en median mellan DOM- och SAX -gränssnittet. I sin metafor är den programmatiska ingångspunkten en markör som representerar en punkt i dokumentet. Programmet flyttar markören framåt - "drar" informationen från parsern efter behov. Detta skiljer sig från ett händelsebaserat API - till exempel SAX - som "skickar" data till applikationen - vilket kräver att programmet behåller tillstånd mellan händelserna som behövs för att hålla reda på platsen i dokumentet.

XSLT -gränssnitt

Den X ML S tylesheet L anguage för T ransformations eller XSLT , möjliggör omvandling av ett XML-dokument till andra former av data. JAXP tillhandahåller gränssnitt i paketet javax.xml.transform så att applikationer kan åberopa en XSLT -transformation. Detta gränssnitt kallades ursprungligen TrAX (Transformation API for XML) och utvecklades genom ett informellt samarbete mellan utvecklarna av ett antal Java XSLT -processorer.

Huvuddragen i gränssnittet är

• en fabriksklass som gör att applikationen dynamiskt kan välja vilken XSLT -processor den vill använda (TransformerFactory, TransformerFactory.NewInstance (), TransformerFactory.newInstance (java.lang.String, _java.lang.ClassLoader)).
• metoder i fabriksklassen för att skapa ett mallobjekt som representerar den kompilerade formen för ett formatmall. Detta är ett trådsäkert objekt som kan användas upprepade gånger, i serie eller parallellt, för att tillämpa samma formatmall för flera källdokument (eller för samma keldokument med olika parametrar) (TransformerFactory.newTemplates (javax.xml.transform. Source), även TransformerFactory.newTransformer (javax.xml.transform.Source), TransformerFactory.newTransformer ()), en metod på mallobjektet för att skapa en transformator, som representerar den körbara formen för ett formatmall (Templates.newTransformer ()) Detta kan inte delas över trådar, även om det är seriellt återanvändbart. Transformatorn tillhandahåller metoder för att ställa in formatmallar och parametrar för serialisering (till exempel om utdata ska vara indragna) och en metod för att faktiskt köra transformationen. (Transformer.transform (javax.xml.transform.Source, _javax.xml.transform.Result)).

Två abstrakta gränssnitt Källa och resultat definieras för att representera input och output av transformationen. Detta är en något okonventionell användning av Java -gränssnitt, eftersom det inte finns någon förväntning att en processor kommer att acceptera någon klass som implementerar gränssnittet - varje processor kan välja vilken typ av källa eller resultat den är beredd att hantera. I praktiken stöder alla JAXP processorer de tre standard typer av Source ( DOMSource, SAXSource, StreamSource) och de tre standard typer av resultat ( DOMResult, SAXResult, StreamResult) och eventuellt andra implementeringar av sina egna.

Exempel

Det mest primitiva men fullständiga exemplet på lansering av XSLT -transformation kan se ut så här:

/* file src/examples/xslt/XsltDemo.java */
package examples.xslt;

import java.io.StringReader;
import java.io.StringWriter;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

public class XsltDemo {
   public static void main(String[] args) throws TransformerFactoryConfigurationError, TransformerException {
      String xsltResource = 
         "<?xml version='1.0' encoding='UTF-8'?>\n"+
         "<xsl:stylesheet version='2.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>\n"+
         "   <xsl:output method='xml' indent='no'/>\n"+
         "   <xsl:template match='/'>\n"+
         "      <reRoot><reNode><xsl:value-of select='/root/node/@val' /> world</reNode></reRoot>\n"+
         "   </xsl:template>\n"+
         "</xsl:stylesheet>";
      String xmlSourceResource =
         "<?xml version='1.0' encoding='UTF-8'?>\n"+
         "<root><node val='hello'/></root>";
      
      StringWriter xmlResultResource = new StringWriter();
      
      Transformer xmlTransformer = TransformerFactory.newInstance().newTransformer(
         new StreamSource(new StringReader(xsltResource))
      );
      
      xmlTransformer.transform(
         new StreamSource(new StringReader(xmlSourceResource)), new StreamResult(xmlResultResource)
      );
      
      System.out.println(xmlResultResource.getBuffer().toString());
   }
}

Den tillämpar följande hårdkodade XSLT -transformation:

<?xml version='1.0' encoding='UTF-8'?>
<xsl:stylesheet version='2.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
	<xsl:output method='xml' indent='no'/>
	<xsl:template match='/'>
		<reRoot><reNode><xsl:value-of select='/root/node/@val' /> world</reNode></reRoot>
	</xsl:template>
</xsl:stylesheet>

Till följande hårdkodade XML -dokument:

<?xml version='1.0' encoding='UTF-8'?>
<root><node val='hello'/></root>

Resultatet av utförandet blir

<?xml version="1.0" encoding="UTF-8"?><reRoot><reNode>hello world</reNode></reRoot>

Referenser

externa länkar

• Hemsida för JAXP -referensimplementeringsprojekt