Content deleted Content added
m robot Adding: nl:Java API for XML Processing |
|||
| (125 intermediate revisions by 83 users not shown) | |||
Line 1:
{{Short description|Java application programming interface}}
{{Multiple issues|
{{more footnotes|date=June 2013}}
{{primary sources|date=June 2013}}
}}
In [[computing]], the '''Java API for XML Processing''' ('''JAXP''') ({{IPAc-en|ˈ|dʒ|æ|k|s|p|iː}} {{respell|JAKS|pee}}), one of the [[Java XML]] [[application programming interface]]s (APIs), provides the capability of validating and parsing [[XML]] documents. It has three basic parsing interfaces:
* the [[Document Object Model]] parsing interface or '''DOM''' interface
* the [[Simple API for XML]] parsing interface or '''SAX''' interface
* the [[StAX|Streaming API for XML]] or '''StAX''' interface (part of JDK 6; separate jar available for JDK 5)
In addition to the parsing interfaces, the API provides an [[XSLT]] interface to provide data and structural transformations on an XML document.
{| class="wikitable"
|-
! [[Java Platform, Standard Edition|Java SE]] version !! JAXP version bundled
|-
| 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<ref>{{Cite web|url=https://www.jcp.org/en/jsr/detail?id=206|title = The Java Community Process(SM) Program - JSRS: Java Specification Requests - detail JSR# 206}}</ref>
|}
JAXP version 1.4.4 was released on September 3, 2010. JAXP 1.3 was declared [https://web.archive.org/web/20110807094938/http://jaxp.java.net/1.3/EndofLife.html end-of-life] on February 12, 2008.
== DOM interface ==
{{main article|Document Object Model}}
The DOM interface
The DOM parser is called a
* element nodes that may have attributes
* text nodes representing the text found between the start and end tags of a document element.
== SAX interface ==
{{main article|Simple API for XML}}
The
The <code>DefaultHandler</code> class implements the {{Javadoc
* {{Javadoc|module=java.xml|package=org.xml.sax.helpers|class=DefaultHandler|member=startDocument()|text=startDocument()|monotype=y}} and {{Javadoc|module=java.xml|package=org.xml.sax.helpers|class=DefaultHandler|member=endDocument()|text=endDocument()|monotype=y}} methods that are called at the start and end of a XML document.
* <code>startElement()</code> and <code>endElement()</code> methods that are called at the start and end of a document element.
* <code>characters()</code> method that is called with the text data contents contained between the start and end tags of an XML document element.
Clients provide a subclass of the <code>DefaultHandler</code> that overrides these methods and processes the data. This may involve storing the data into a database or writing it out to a stream.
During parsing, the parser may need to access external documents. It is possible to store a local cache for frequently used documents using an [[XML Catalog]].
This was introduced with Java 1.3 in May 2000.<ref>Compare the [http://java.sun.com/j2ee/sdk_1.2.1/techdocs/api/index-all.html#_S_ Java 1.2.1 API index] with the [http://java.sun.com/j2ee/sdk_1.3/techdocs/api/index-all.html#_S_ 1.3 index]. The Java Specification Request (JSR) 5, ''XML Parsing Specification'', was finalised on [http://jcp.org/en/jsr/detail?id=5 21 March, 2000].</ref>
== StAX interface ==
{{main article|StAX}}
[[StAX]] was designed as a median between the DOM and SAX interface. In its metaphor, the programmatic entry point is a cursor that represents a point within the document. The application moves the cursor forward - 'pulling' the information from the parser as it needs. This is different from an event based API - such as SAX - which 'pushes' data to the application - requiring the application to maintain state between events as necessary to keep track of ___location within the document.
== XSLT interface ==
{{main article|XSLT}}
The '''X'''ML '''S'''tylesheet '''L'''anguage for '''T'''ransformations, or '''[[XSL Transformations|XSLT]]''', allows for conversion of an XML document into other forms of data. JAXP provides interfaces in package {{Javadoc|module=java.xml|package=javax.xml.transform|monotype=y}} allowing applications to invoke an XSLT transformation. This interface was originally called TrAX (Transformation API for XML), and was developed by an informal collaboration between the developers of a number of Java XSLT processors.
Main features of the interface are
* a factory class allowing the application to select dynamically which XSLT processor it wishes to use ({{Javadoc|module=java.xml|package=javax.xml.transformer|class=TransformerFactory|text=TransformerFactory|monotype=y}}, {{Javadoc|module=java.xml|package=javax.xml.transform|class=TransformerFactory|member=newInstance()|text=TransformerFactory.newInstance()|monotype=y}}, {{Javadoc|module=java.xml|package=javax.xml.transformer|class=TransformerFactory|member=newInstance(java.lang.String,java.lang.ClassLoader)|text=TransformerFactory.newInstance(String factoryClassName, ClassLoader classLoader)|monotype=y}}.
* methods on the factory class to create a {{Javadoc|module=java.xml|package=javax.xml.transform|class=Templates|text=Templates|monotype=y}} object, representing the compiled form of a stylesheet. This is a thread-safe object that can be used repeatedly, in series or in parallel, to apply the same stylesheet to multiple source documents (or to the same source document with different parameters) ({{Javadoc|module=java.xml|package=javax.xml.transform|class=TransformerFactory|member=newTemplates(javax.xml.transform.Source)|text=TransformerFactory.newTemplates(Source source)|monotype=y}}), also {{Javadoc|module=java.xml|package=javax.xml.transformer|class=TransformerFactory|member=newTransformer(javax.xml.transform.Source)|text=TransformerFactory.newTransformer(Source source)|monotype=y}}, {{Javadoc|module=java.xml|package=javax.xml.transform|class=TransformerFactory|member=newTransformer()|text=TransformerFactory.newTransformer()|monotype=y}}), a method on the {{java|Templates}} object to create a {{Javadoc|module=java.xml|package=javax.xml.transform|class=Transformer|monotype=y}}, representing the executable form of a stylesheet ({{Javadoc|module=java.xml|package=javax.xml.transform|class=Templates|member=newTransformer()|text=Templates.newTransformer()|monotype=y}}) This cannot be shared across threads, though it is serially reusable. The {{java|Transformer}} provides methods to set stylesheet parameters and serialization options (for example, whether output should be indented), and a method to actually run the transformation. ({{Javadoc|module=java.xml|package=javax.xml.transform|class=Transformer|member=transform(javax.xml.transform.Source,javax.xml.transform.Result)|text=TransformerFactory.transformer(Source xmlSource, Result outputTarget)|monotype=y}}).
Two abstract interfaces {{Javadoc|module=java.xml|package=javax.xml.transform|class=Source|text=Source|monotype=y}} and {{Javadoc|module=java.xml|package=javax.xml.transform|class=Result|text=Result|monotype=y}} are defined to represent the input and output of the transformation. This is a somewhat unconventional use of Java interfaces, since there is no expectation that a processor will accept any class that implements the interface - each processor can choose which kinds of {{java|Source}} or {{java|Result}} it is prepared to handle. In practice all JAXP processors supports several standard kinds of Source ({{Javadoc|module=java.xml|package=javax.xml.transform|class=DOMSource|text=DOMSource|monotype=y}}, {{Javadoc|module=java.xml|package=javax.xml.transform|class=SAXSource|text=SAXSource|monotype=y}} {{Javadoc|module=java.xml|package=javax.xml.transform|class=StreamSource|text=StreamSource|monotype=y}}) and several standard kinds of Result ({{Javadoc|module=java.xml|package=javax.xml.transform|class=DOMResult|text=DOMResult|monotype=y}}, {{Javadoc|module=java.xml|package=javax.xml.transform|class=SAXResult|text=SAXResult|monotype=y}} {{Javadoc|module=java.xml|package=javax.xml.transform|class=StreamResult|text=StreamResult|monotype=y}}) and possibly other implementations of their own.
=== Example ===
The most primitive but complete example of XSLT transformation launching may look like this:<syntaxhighlight lang="java">
/* 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 {
//language=xslt
String xsltResource = """
<?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>
""";
// language=XML
String xmlSourceResource = """
<?xml version='1.0' encoding='UTF-8'?>
<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());
}
}
</syntaxhighlight>
It applies the following hardcoded <!-- literal --> XSLT transformation:<syntaxhighlight lang="xml">
<?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>
</syntaxhighlight>
To the following hardcoded <!-- literal --> XML document:<syntaxhighlight lang="xml">
<?xml version='1.0' encoding='UTF-8'?>
<root><node val='hello'/></root>
</syntaxhighlight>
The result of execution will be<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?><reRoot><reNode>hello world</reNode></reRoot>
</syntaxhighlight>
== Citations ==
{{Reflist}}
== References ==
* {{cite book | last=Horstmann | first=Cay | title=Core Java | publisher=Oracle Press Java | date=April 15, 2022 | isbn=978-0-13-787107-0}}
== External links ==
*[http://jaxp.java.net JAXP Reference Implementation Project Home Page] {{Webarchive|url=https://web.archive.org/web/20110812151256/http://jaxp.java.net/ |date=2011-08-12 }}
{{Jakarta EE}}
[[Category:Java API for XML]]
[[Category:Java specification requests|XML Processing]]
[[Category:XML parsers]]
| |||