Java API för XML-bearbetning

Inom datorer ger Java API for XML Processing , eller JAXP ( / ˈ dʒ æ k s p iː / JAKS -pee ), ett av programmeringsgränssnitten för Java XML Application , möjligheten att validera och analysera XML -dokument. Den har tre grundläggande analysgränssnitt:

Förutom analysgränssnitten tillhandahåller API:et ett XSLT- gränssnitt för att tillhandahålla data och strukturella transformationer på 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).

Java SE- version JAXP-version medföljer
1.4 1.1
1.5 1.3
1.6 1.4
1.7.0 1.4.5
1.7.40 1.5
1.8 1.6

JAXP version 1.4.4 släpptes den 3 september 2010. JAXP 1.3 förklarades uttjänt den 12 februari 2008.

DOM-gränssnitt

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

DOM-parsern kallas en DocumentBuilder eftersom den bygger en dokumentrepresentation i minnet . javax.xml.parsers.DocumentBuilder skapas av javax.xml.parsers.DocumentBuilderFactory. DocumentBuilder skapar en org.w3c.dom.Document- instans - en trädstruktur som innehåller noder i XML-dokumentet . Varje trädnod i strukturen implementerar org.w3c.dom.Node- gränssnittet. Bland de många olika typerna av trädnoder, som var och en representerar den typ av data som finns i ett XML-dokument, inkluderar de viktigaste:

  • elementnoder som kan ha attribut
  • textnoder som representerar texten som hittas mellan start- och sluttaggar 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 inte en representation i minnet av XML-dokumentet och körs därför snabbare och använder mindre minne. Istället informerar SAX-parsern klienter om XML-dokumentstrukturen genom att anropa callbacks, det vill säga genom att anropa metoder på en org.xml.sax.helpers.DefaultHandler-instans som tillhandahålls till parsern. Detta sätt att komma åt dokument kallas Streaming XML .

Klassen DefaultHandler implementerar gränssnitten ContentHandler, ErrorHandler, DTDHandler och EntityResolver. De flesta klienter kommer att vara intresserade av metoder definierade i ContentHandler- gränssnittet som anropas när SAX-parsern stöter på motsvarande element i XML-dokumentet. De viktigaste metoderna i detta gränssnitt är:

  • startDocument() och endDocument() 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 anropas med textdatainnehållet mellan start- och sluttaggar för ett XML-dokumentelement.

Klienter tillhandahåller en underklass av DefaultHandler som åsidosätter dessa metoder och bearbetar data. Detta kan innebära att data lagras i en databas eller skrivas ut till en ström.

Under analysen kan tolken 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. Applikationen flyttar markören framåt - "drar" informationen från parsern som den behöver. Detta skiljer sig från ett händelsebaserat API - såsom SAX - som "pushar" data till applikationen - som kräver att applikationen upprätthåller tillstånd mellan händelser efter behov för att hålla reda på platsen i dokumentet.

XSLT-gränssnitt

X ML S - typbladsspråket för transformationer , eller XSLT , tillåter konvertering av ett XML-dokument till andra former av data . JAXP tillhandahåller gränssnitt i paketet javax.xml.transform som tillåter applikationer att anropa en XSLT-transformation. Detta gränssnitt kallades ursprungligen TrAX (Transformation API for XML), och utvecklades av ett informellt samarbete mellan utvecklarna av ett antal Java XSLT-processorer.

Huvuddragen i gränssnittet är

  • en fabriksklass som tillåter applikationen att dynamiskt välja vilken XSLT-processor den vill använda (TransformerFactory, TransformerFactory.NewInstance(), TransformerFactory.newInstance(java.lang.String,_java.lang.ClassLoader)).
  • metoder på fabriksklassen för att skapa ett Templates-objekt, som representerar den kompilerade formen av en stilmall. Detta är ett trådsäkert objekt som kan användas upprepade gånger, i serie eller parallellt, för att tillämpa samma stilmall på flera källdokument (eller på samma källdokument med olika parametrar) (TransformerFactory.newTemplates(javax.xml.transform. Source), även TransformerFactory.newTransformer(javax.xml.transform.Source), TransformerFactory.newTransformer()), en metod på Templates-objektet för att skapa en Transformer, som representerar den körbara formen av en stilmall (Templates.newTransformer()) kan inte delas över trådar, även om det är seriellt återanvändbart. Transformatorn tillhandahåller metoder för att ställa in stilmallsparametrar och serialiseringsalternativ (till exempel om utdata ska indragas) 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 indata och utdata från transformationen. Detta är en något okonventionell användning av Java-gränssnitt, eftersom det inte finns några förväntningar på att en processor ska 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 standardtyperna av Source ( DOMSource , SAXSource , StreamSource ) och de tre standardtyperna av Result ( DOMResult , SAXResult , StreamResult ) och möjligen andra egna implementeringar.

Exempel

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


 

 
 

 
 
 
 
 
 

   
           
         
         
         
         
         
         
         
         
        
         
         
      
          
      
         
           
      
      
      
             
      
      
      
   
 /* file src/examples/xslt/XsltDemo.java */  package  examples.xslt  ;  importera  java.io.StringReader  ;  importera  java.io.StringWriter  ;  importera  javax.xml.transform.Transformer  ;  import  javax.xml.transform.TransformerException  ;  importera  javax.xml.transform.TransformerFactory  ;  import  javax.xml.transform.TransformerFactoryConfigurationError  ;  importera  javax.xml.transform.stream.StreamResult  ;  importera  javax.xml.transform.stream.StreamSource  ;  public  class  XsltDemo  {  public  static  void  main  (  String  []  args  )  kastar  TransformerFactoryConfigurationError  ,  TransformerException  {  String  xsltResource  =  "<?xml version='1.0' encoding='UTF-8'?>\n"  +  "<xsl:formatmallsversion ='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' /> värld</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  (  ny  StreamSource  (  ny  StringReader  (  xsltResource  ))  );  xmlTransformer  .  transform  (  ny  StreamSource  (  ny  StringReader  (  xmlSourceResource  )),  ny  StreamResult  (  xmlResultResource  )  );  System  .  ut  .  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'  />  värld  </reNode></reRoot>  </xsl:template>  </xsl:stylesheet>

Till följande hårdkodade XML-dokument:


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

Resultatet av utförandet blir

 <?xml version="1.0" encoding="UTF-8"?>  <reRoot><reNode>  hej värld  </reNode></reRoot>

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=Java_API_for_XML_Processing&oldid=1121584272 "