JAXP API-Referenz

(Auszug aus "Java und XSLT" von Eric M. Burke)

Diese Seite stellt eine Zusammenfassung von Version 1.1 der Java API for XML Processing (JAXP) dar. (Bevor Transformation unterstützt wurde, stand JAXP für Java API for XML Parsing.) JAXP bietet Java-Programmen eine Standardmöglichkeit, mit XML-Parsern sowie XSLT-Prozessoren zusammenzuarbeiten und beinhaltet Klassen sowie Interfaces für DOM und SAX, die hier jedoch nicht aufgeführt werden.

Die größten Neuerungen in JAXP 1.1 gegenüber JAXP 1.0 sind die Unterstützung von Level 2 von DOM und SAX sowie ein komplett neuer Plugability-Layer zur Durchführung von Transformationen. JAXP 1.1 verbessert außerdem den Algorithmus zum Auffinden von Implementierungsklassen der drei unterstützten Plugability-Layer. Dieser Algorithmus wurde unter Einführung in JAXP 1.1 besprochen.

Paket: javax.xml.parsers
Paket: javax.xml.transform
Paket: javax.xml.transform.dom
Paket: javax.xml.transform.sax
Paket: javax.xml.transform.stream

Paket: javax.xml.parsers

Die Klassen in diesem Paket unterstützen das Parsen über die Simple API for XML (SAX) 2 und Document Object Model (DOM) Level 2. Diese Klassen führen das eigentliche Parsen aber nicht selbst durch, sondern delegieren die Arbeit an auswechselbare Parser-Implementierungen, wie Apaches Crimson oder Xerces.

DocumentBuilder

Instanzen dieser Klasse definieren eine API zum Parsen von XML aus einer Reihe von Eingabequellen und zur Erzeugung eines neuen DOM-Document-Objekts aus dem Stegreif. Die Instanz von DocumentBuilder sollte über eine Instanz von DocumentBuilderFactory geholt werden. Liegt die Instanz einmal vor, kann über die Methode newDocument( ) ohne Implementierung von spezifischem Code ein neues DOM Document-Objekt erzeugt werden.

public abstract class DocumentBuilder {
  protected DocumentBuilder( );
  public abstract DOMImplementation getDOMImplementation( );
  public abstract boolean isNamespaceAware( );
  public abstract boolean isValidating( );
  public abstract Document newDocument( );
  public Document parse(InputStream is, String systemId)
    throws SAXException, IOException;
  public Document parse(String uri)
    throws SAXException, IOException;
  public Document parse(File f)
    throws SAXException, IOException;
  public abstract Document parse(InputSource is)
    throws SAXException, IOException;
  public Document parse(InputStream is)
    throws SAXException, IOException;
  public abstract void setEntityResolver(EntityResolver er);
  public abstract void setErrorHandler(ErrorHandler eh);
}

DocumentBuilderFactory

Diese Klasse dient der Erzeugung von DocumentBuilder-Objekten über ein Factory-Entwurfsmuster und isoliert so Anwendungscode von spezifischen DOM-Implementierungen. Verschiedene Methoden in dieser Klasse gestatten Programmen, anzugeben, welche Funktionalitäten der Parser unterstützen wird. Wenn diese Funktionalitäten nicht verfügbar sind, löst new-DocumentBuilder( ) eine ParserConfigurationException aus. Die verschiedenen Zugriffsmethoden, wie isNamespaceAware( ), geben nicht an, ob der darunterliegende Parser eine bestimmte Funktionalität tatsächlich unterstützt. Stattdessen geben diese Methoden an, ob die Anwendung diese Funktionalitäten für diese Instanz von DocumentBuilderFactory konfiguriert hat. Bevor Sie diese Klasse nutzen können, müssen Sie die Methode newInstance( ) aufrufen, um eine Instanz von ihr zu erzeugen. Dieses Objekt wird dann verwendet, um über die Methode new-DocumentBuilder( ) eine Instanz von DocumentBuilder zu erzeugen.

public abstract class DocumentBuilderFactory {
  protected DocumentBuilderFactory( );
  public abstract Object getAttribute(String name)
    throws IllegalArgumentException;
  public boolean isCoalescing( );
  public boolean isExpandEntityReferences( );
  public boolean isIgnoringComments( );
  public boolean isIgnoringElementContentWhitespace( );
  public boolean isNamespaceAware( );
  public boolean isValidating( );
  public abstract DocumentBuilder newDocumentBuilder( )
    throws ParserConfigurationException;
  public static DocumentBuilderFactory newInstance( );
  public abstract void setAttribute(String name, Object value)
    throws IllegalArgumentException;
  public void setCoalescing(boolean coalescing);
  public void setExpandEntityReferences(boolean expandEntityRef);
  public void setIgnoringComments(boolean ignoreComments);
  public void setIgnoringElementContentWhitespace(boolean whitespace);
  public void setNamespaceAware(boolean awareness);
  public void setValidating(boolean validating);
}

FactoryConfigurationError

Gibt an, daß die Klasse für eine Parser-Factory nicht gefunden oder instantiiert werden konnte. Wenn dieser Fehler auftritt, ist irgend etwas im System nicht richtig installiert. Für Informationen zum Algorithmus, den JAXP zum Auffinden der Parser-Implementierungen verwendet, schauen Sie bitte unter XSLT-Verarbeitung mit Java.

public class FactoryConfigurationError
    extends Error {
  public FactoryConfigurationError(String msg);
  public FactoryConfigurationError(Exception e);
  public FactoryConfigurationError(Exception e, String msg);
  public FactoryConfigurationError( );
  public Exception getException( );
  public String getMessage( );
}

ParserConfigurationException

Gemäß der API-Spezifikation steht diese Exception für einen »serious configuration error«, also einen schwerwiegenden Konfigurationsfehler. Generell heißt das, daß die Factory keinen Parser mit den angegebenen Funktionalitäten bereitstellen kann. Ein Programmierer könnte beispielsweise einen Parser anfragen, der XML-Namensräume kennt, aber der einzige verfügbare Parser unterstützt genau das nicht. (XSLT-Verarbeitung erfordert einen XML-Parser, der XML-Namensräume unterstützt.)

public class ParserConfigurationException
    extends Exception {
  public ParserConfigurationException(String msg);
  public ParserConfigurationException( );
}

SAXParser

Diese Klasse definiert einen Wrapper für eine darunterliegende Implementierung eines SAX-Parsers. Die Klasse war schon Teil von JAXP 1.0 und unterstützt sowohl SAX 1 als auch SAX 2-Funktionalitäten. Wenn möglich, sollten Programmierer Methoden vermeiden, die HandlerBase verwenden, weil das ein veraltetes SAX 1-Interface ist. Stattdessen sollten die Methoden genutzt werden, die DefaultHandler verwenden.

public abstract class SAXParser {
  protected SAXParser( );
  public abstract Parser getParser( )
    throws SAXException;
  public abstract Object getProperty(String name)
    throws SAXNotRecognizedException, SAXNotSupportedException;
  public abstract XMLReader getXMLReader( )
    throws SAXException;
  public abstract boolean isNamespaceAware( );
  public abstract boolean isValidating( );
  public void parse(InputStream is, DefaultHandler dh, String systemId)
    throws SAXException, IOException;
  public void parse(InputStream is, DefaultHandler p1)
    throws SAXException, IOException;
  public void parse(InputStream is, HandlerBase hb, String systemId)
    throws SAXException, IOException;
  public void parse(File f, HandlerBase hb)
    throws SAXException, IOException;
  public void parse(InputStream is, HandlerBase hb)
    throws SAXException, IOException;
  public void parse(String uri, HandlerBase hb)
    throws SAXException, IOException;
  public void parse(InputSource is, HandlerBase hb)
    throws SAXException, IOException;
  public void parse(InputSource is, DefaultHandler dh)
    throws SAXException, IOException;
  public void parse(String systemId, DefaultHandler dh)
    throws SAXException, IOException;
  public void parse(File f, DefaultHandler dh)
    throws SAXException, IOException;
  public abstract void setProperty(String name, Object value)
    throws SAXNotRecognizedException, SAXNotSupportedException;
}

SAXParserFactory

Diese Klasse definiert eine Factory zur Erzeugung von SAX-Parser-Instanzen. Bevor diese Instanzen erzeugt werden, definiert man mit der Methode setFeature( ), welche Parser-Funktionalitäten vom zu erzeugenden Parser unterstützt werden müssen. Siehe auch saxproject.org für eine Liste der Kernfunktionalitäten von SAX 2.

public abstract class SAXParserFactory {
  protected SAXParserFactory( );
  public abstract boolean getFeature(String name)
    throws ParserConfigurationException, SAXNotRecognizedException,
    SAXNotSupportedException;
  public boolean isNamespaceAware( );
  public boolean isValidating( );
  public static SAXParserFactory newInstance( );
  public abstract SAXParser newSAXParser( )
    throws ParserConfigurationException, SAXException;
  public abstract void setFeature(String name, boolean value)
    throws ParserConfigurationException, SAXNotRecognizedException,
    SAXNotSupportedException;
  public void setNamespaceAware(boolean awareness);
  public void setValidating(boolean validating);
}

Paket: javax.xml.transform

Dieses Paket definiert eine API zur Durchführung von Transformationen. Obwohl dies gewöhnliche XSLT-Transformationen sind, ist die API flexibel genug, andere Transformationstechnologien zu unterstützen. Wie beim Paket javax.xml.parsers verbergen die Klassen und Interfaces in diesem Paket den anbieterspezifischen Implementierungscode. JAXP 1.1 wird mit Xalan als ReferenzImplementierung für Transformationen ausgeliefert; Xalan kann aber leicht durch andere Prozessoren ersetzt werden.

ErrorListener

Dieses Interface erlaubt Anwendungen, eine eigene Fehlerbehandlung zu implementieren. Wenn kein ErrorListener registriert ist, werden alle Fehler auf System.err ausgegeben. Näheres zu diesem Interface finden Sie unter Testen und Fehlerbeseitigung.

public interface ErrorListener {
  void error(TransformerException exception)
    throws TransformerException;
  void fatalError(TransformerException exception)
    throws TransformerException;
  void warning(TransformerException exception)
    throws TransformerException;
}

OutputKeys

OutputKeys sind konstante Definitionen für gültige Einstellungen von Ausgabe-Eigenschaften des Transformer-Interface. Sie werden unmittelbar auf die für das <xsl:output>-Element gültigen Attribute abgebildet. Programmgesteuert angegebene Ausgabe-Eigenschaften haben Vorrang vor den in einem XSLT-Stylesheet angegebenen Ausgabe-Eigenschaften.

public class OutputKeys {
  public static final String CDATA_SECTION_ELEMENTS = "cdata-section-elements";
  public static final String DOCTYPE_PUBLIC = "doctype-public";
  public static final String DOCTYPE_SYSTEM = "doctype-system";
  public static final String ENCODING = "encoding";
  public static final String INDENT = "indent";
  public static final String MEDIA_TYPE = "media-type";
  public static final String METHOD = "method";
  public static final String OMIT_XML_DECLARATION = "omit-xml-declaration";
  public static final String STANDALONE = "standalone";
  public static final String VERSION = "version";
}

Result

Dies ist ein allgemeines Interface für Klassen, die ein Transformationsergebnis erzeugen. Implementierende Klassen sind DOMResult, SAXResult und StreamResult. Die zwei Konstanten in diesem Interface werden eingesetzt, um festzulegen, ob in der Ausgabe XML-Metazeichen geschützt werden sollen; näheres hierzu in Abschnitt 16.4 der XSLT-Spezifikation. Die System-ID ist optional, kann aber nützlich sein, wenn Fehlermeldungen oder Warnungen ausgegeben werden.

public interface Result {
  public static final String PI_DISABLE_OUTPUT_ESCAPING =
    "javax.xml.transform.disable-output-escaping";
  public static final String PI_ENABLE_OUTPUT_ESCAPING =
    "javax.xml.transform.enable-output-escaping";
  String getSystemId( );
  void setSystemId(String systemId);
}

Source

Source ist ein generisches Interface, das von DOMSource, SAXSource und StreamSource implementiert wird. Die System-ID ist besonders wichtig für Source, weil sie es dem Prozessor ermöglicht, die relativen URI-Referenzen innerhalb der XML- und XSLT-Eingabedaten aufzulösen. (URI-Referenzen tauchen in Elementen wie <xsl:import> und <xsl:include> auf.)

public interface Source {
  String getSystemId( );
  void setSystemId(String systemId);
}

SourceLocator

Instanzen dieses Interface sind nützlich, wenn die Orte angegeben werden sollen, an denen eine Fehlermeldung oder Warnung aufgetreten ist. Anwendungsprogrammierer erhalten Instanzen von SourceLocator über die Methode getLocator( ) des TransformerException-Objekts.

public interface SourceLocator {
  int getColumnNumber( );
  int getLineNumber( );
  String getPublicId( );
  String getSystemId( );
}

Templates

Diese Instanzen repräsentieren »kompilierte« Transformationsanweisungen. Ob ein bestimmter XSLT-Prozessor das Stylesheet tatsächlich kompiliert, ist implementierungsabhängig. Templates-Objekte sind für die Verwendung mit Threads geeignet. Das macht sie ideal für Servlet-Umgebungen, wo ein Stylesheet idealerweise nur einmal geparst und dann im Speicher als Templates-Objekt zwischengespeichert wird. Die Ausgabe-Eigenschaften sind eine schreibgeschützte Repräsentation des <xsl:output>-Eements des Stylesheets.

public interface Templates {
  Properties getOutputProperties( );
  Transformer newTransformer( )
    throws TransformerConfigurationException;
}

Transformer

Instanzen dieser Klasse führen eine oder mehrere Transformationen durch. Obwohl Transformer-Objekte wiederverwendet werden können, sind sie nicht für die Verwendung mit Threads geeignet und können daher nicht gleichzeitig genutzt werden. Namen von Ausgabe-Eigenschaften werden von der Klasse OutputKeys festgelegt und lassen sich auf das <xsl:output>-Element des Stylesheets abbilden. Die Parameter andererseits sind Stylesheet-Parameter und werden auf Top-Level-<xsl:param>-Elemente abgebildet. Die Methode getParameter() liefert nur Parameter zurück, die programmgesteuert gesetzt wurden.

public abstract class Transformer {
  protected Transformer( );
  public abstract void clearParameters( );
  public abstract ErrorListener getErrorListener( );
  public abstract Properties getOutputProperties( );
  public abstract String getOutputProperty(String name)
    throws IllegalArgumentException;
  public abstract Object getParameter(String name);
  public abstract URIResolver getURIResolver( );
  public abstract void setErrorListener(ErrorListener listener)
    throws IllegalArgumentException;
  public abstract void setOutputProperties(Properties oformat)
    throws IllegalArgumentException;
  public abstract void setOutputProperty(String name, String value)
    throws IllegalArgumentException;
  public abstract void setParameter(String name, Object value);
  public abstract void setURIResolver(URIResolver resolver);
  public abstract void transform(Source xmlSource, Result outputTarget)
    throws TransformerException;
}

TransformerConfigurationException

Diese Exception deutet auf ein ernstes Problem hin und kann auftreten, wenn ein XSLT-Stylesheet Syntaxfehler aufweist, die die Instantiierung einer Transformer-Instanz verhindern. Diese Klasse kann andere Exceptions kapseln. Eine darunterliegende Parser-Exception kann beispielsweise von einer Instanz dieser Klasse gekapselt werden.

public class TransformerConfigurationException
    extends TransformerException {
  public TransformerConfigurationException(String msg);
  public TransformerConfigurationException(Throwable e);
  public TransformerConfigurationException(String msg, Throwable e);
  public TransformerConfigurationException(String msg, SourceLocator locator);
      
  public TransformerConfigurationException(String msg, SourceLocator locator,
    Throwable e);
  public TransformerConfigurationException( );
}

TransformerException

Dies ist eine Allzweck-Exception, die während der Transformation auftritt. Wenn ein ErrorListener registriert ist, sollte der Prozessor versuchen, Exceptions dort zuerst zu melden. Ansonsten werden Exceptions auf System.err ausgegeben. Die Qualität der Fehlermeldungen variiert stark zwischen verschiedenen XSLT-Prozessoren. Diese Klasse kann andere Exceptions kapseln.

public class TransformerException
    extends Exception {
  public TransformerException(String msg, Throwable e);
  public TransformerException(String msg, SourceLocator locator);
  public TransformerException(Throwable e);
  public TransformerException(String msg);
  public TransformerException(String msg, SourceLocator locator, Throwable e);
  public Throwable getCause( );
  public Throwable getException( );
  public String getLocationAsString( );
  public SourceLocator getLocator( );
  public String getMessageAndLocation( );
  public synchronized Throwable initCause(Throwable cause);
  public void printStackTrace(PrintStream ps);
  public void printStackTrace(PrintWriter pw);
  public void printStackTrace( );
  public void setLocator(SourceLocator locator);
}

TransformerFactory

Diese Klasse definert eine portable Möglichkeit, auf verschiedene Instanzen von TransformerFactory zuzugreifen, und ist die Hauptabstraktion, die die Unterschiede zwischen XSLT-Prozessoren unterschiedlicher Anbieter versteckt.

public abstract class TransformerFactory {
  protected TransformerFactory( );
  public abstract Source getAssociatedStylesheet(Source source, String media,
    String title, String charset) throws TransformerConfigurationException;
  public abstract Object getAttribute(String name)
    throws IllegalArgumentException;
  public abstract ErrorListener getErrorListener( );
  public abstract boolean getFeature(String name);
  public abstract URIResolver getURIResolver( );
  public static TransformerFactory newInstance( )
    throws TransformerFactoryConfigurationError;
  public abstract Templates newTemplates(Source source)
    throws TransformerConfigurationException;
  public abstract Transformer newTransformer(Source source)
    throws TransformerConfigurationException;
  public abstract Transformer newTransformer( )
    throws TransformerConfigurationException;
  public abstract void setAttribute(String name, Object value)
    throws IllegalArgumentException;
  public abstract void setErrorListener(ErrorListener listener)
    throws IllegalArgumentException;
  public abstract void setURIResolver(URIResolver resolver);
}

TransformerFactoryConfigurationError

Dieser Fehler tritt normalerweise dann auf, wenn eine TransformerFactory-Klasse nicht instanziiert werden kann, und ist ein guter Indikator für CLASSPATH-Probleme.

public class TransformerFactoryConfigurationError
    extends Error {
  public TransformerFactoryConfigurationError(String msg);
  public TransformerFactoryConfigurationError(Exception e);
  public TransformerFactoryConfigurationError(Exception e, String msg);
  public TransformerFactoryConfigurationError( );
  public Exception getException( );
  public String getMessage( );
}

URIResolver

In den meisten Fällen bietet JAXP eine Instanz von URIResolver. Durch die Erzeugung einer eigenen Implementierung können die Anwendungen aber definieren, wie relative URI-Referenzen in XSLT-Stylesheets aufgelöst werden sollen. URIResolver definiert beispielsweise, wie <xsl:include href="kopfzeilen.xslt"/> die Datei kopfzeilen.xslt findet.

public interface URIResolver {
  Source resolve(String href, String base)
    throws TransformerException;
}

Paket: javax.xml.transform.dom

Dieses Paket definiert, wie man mit DOM Transformationen durchführt.

DOMLocator

Dieses Interface gestattet Anwendungen, den DOM-Knoten zu lokalisieren, auf dem ein Fehler aufgetreten ist. Da TransformerException Instanzen von SourceLocator erzeugt, müssen Anwendungen eine Typumwandlung vornehmen, um an DOMLocator-Objekte zu gelangen.

public interface DOMLocator
    extends SourceLocator {
  Node getOriginatingNode( );
}

DOMResult

Diese Klasse erlaubt die Speicherung von Transformationsergebnissen in einem DOM-Baum. Wenn der Standard-Konstruktor verwendet wird, erzeugt der XSLT-Prozessor einen DOM-Document-Knoten. Ansonsten können Anwendungen einen DOM-Document-, DocumentFragment- oder Element-Knoten als Konstruktor-Parameter übergeben.

Die Konstante FEATURE wird mit TransformerFactory.getFeature( ) genutzt, um zu ermitteln, ob die Factory DOMResult unterstützt.

public class DOMResult
    implements Result {
  public static final String FEATURE =
    "http://javax.xml.transform.dom.DOMResult/feature";
  public DOMResult(Node node);
  public DOMResult(Node node, String systemId);
  public DOMResult( );
  public Node getNode( );
  public String getSystemId( );
  public void setNode(Node node);
  public void setSystemId(String systemId);
}

DOMSource

Diese Klasse erlaubt einem DOM-Baum, als Eingabequelle zu fungieren. In der Praxis ist der node-Parameter gewöhnlich ein DOM-Document. XSLT-Prozessoren könnten auch andere Typen von DOM-Node unterstützen. Die System-ID ist immer noch wichtig zur Auflösung der relativen URI-Referenzen.

public class DOMSource
    implements Source {
  public static final String FEATURE =
    "http://javax.xml.transform.dom.DOMSource/feature";
  public DOMSource(Node node);
  public DOMSource(Node node, String systemId);
  public DOMSource( );
  public Node getNode( );
  public String getSystemId( );
  public void setNode(Node node);
  public void setSystemId(String systemId);
}

Paket: javax.xml.transform.sax

Dieses Paket definiert, wie man mit SAX Transformationen durchführt. Einsatzbeispiele können unter XSLT-Verarbeitung mit Java nachgelesen werden.

SAXResult

Diese Klasse ermöglicht es, SAX-Events als Ergebnis einer Transformation auszusenden. Der ContentHandler-Parameter empfängt diese Events.

public class SAXResult
    implements Result {
  public static final String FEATURE =
    "http://javax.xml.transform.sax.SAXResult/feature";
  public SAXResult(ContentHandler handler);
  public SAXResult( );
  public ContentHandler getHandler( );
  public LexicalHandler getLexicalHandler( );
  public String getSystemId( );
  public void setHandler(ContentHandler handler);
  public void setLexicalHandler(LexicalHandler handler);
  public void setSystemId(String systemId);
}

SAXSource

Diese Klasse erlaubt die Weiterleitung der Ausgabe eines SAX-Parsers an einen XSLT-Prozessor zwecks Transformation. Sie wird auch verwendet, um mit TransformerFactory Templates- oder Transformer-Objekte zu erzeugen.

public class SAXSource
    implements Source {
  public static final String FEATURE =
    "http://javax.xml.transform.sax.SAXSource/feature";
  public SAXSource(XMLReader reader, InputSource inputSource);
  public SAXSource(InputSource inputSource);
  public SAXSource( );
  public InputSource getInputSource( );
  public String getSystemId( );
  public XMLReader getXMLReader( );
  public void setInputSource(InputSource inputSource);
  public void setSystemId(String systemId);
  public void setXMLReader(XMLReader reader);
  public static InputSource sourceToInputSource(Source source);
}

SAXTransformerFactory

Dies ist eine Unterklasse von TransformerFactory, die SAX-spezifische Methoden hinzufügt. Um eine Instanz dieser Klasse zu erzeugen, muß eine Instanz von TransformerFactory erzeugt und dann eine Typumwandlung durchgeführt werden, falls transFact.getFeature(SAXTransformerFactory.FEATURE) den Wahrheitswert true zurückliefert.

public abstract class SAXTransformerFactory
    extends TransformerFactory {
  public static final String FEATURE =
    "http://javax.xml.transform.sax.SAXTransformerFactory/feature";
  public static final String FEATURE_XMLFILTER =
    "http://javax.xml.transform.sax.SAXTransformerFactory/feature/xmlfilter";
  protected SAXTransformerFactory( );
  public abstract TemplatesHandler newTemplatesHandler( )
    throws TransformerConfigurationException;
  public abstract TransformerHandler newTransformerHandler(Templates templates)
    throws TransformerConfigurationException;
  public abstract TransformerHandler newTransformerHandler( )
    throws TransformerConfigurationException;
  public abstract TransformerHandler newTransformerHandler(Source src)
    throws TransformerConfigurationException;
  public abstract XMLFilter newXMLFilter(Templates templates)
    throws TransformerConfigurationException;
  public abstract XMLFilter newXMLFilter(Source src)
    throws TransformerConfigurationException;
}

TemplatesHandler

Dieses Interface agiert als ein SAX 2 ContentHandler, der SAX-Events empfängt, wenn ein Dokument geparst wird. Ist das Parsen fertig, liefert es ein Templates-Objekt zurück. Instanzen werden über SAXTransformerFactory erzeugt.

public interface TemplatesHandler
    extends ContentHandler {
  String getSystemId( );
  Templates getTemplates( );
  void setSystemId(String systemId);
}

TransformerHandler

Instanzen dieses Interface empfangen SAX-Events und erzeugen Transformer-Objekte, wenn das Parsen fertig ist. Instanzen werden über SAXTransformerFactory erzeugt.

public interface TransformerHandler
    extends ContentHandler, LexicalHandler, DTDHandler {
  String getSystemId( );
  Transformer getTransformer( );
  void setResult(Result result)
    throws IllegalArgumentException;
  void setSystemId(String systemId);
}

Paket: javax.xml.transform.stream

Dieses Paket definiert, wie Transformationen mit Java I/O-Streams durchgeführt werden können.

StreamResult

Diese Klasse erlaubt das Senden von Transformationsergebnissen an ein File-, Writer- oder OutputStream-Objekt.

public class StreamResult
    implements Result {
  public static final String FEATURE =
    "http://javax.xml.transform.stream.StreamResult/feature";
  public StreamResult(OutputStream outputStream);
  public StreamResult(Writer writer);
  public StreamResult(String systemId);
  public StreamResult(File f);
  public StreamResult( );
  public OutputStream getOutputStream( );
  public String getSystemId( );
  public Writer getWriter( );
  public void setOutputStream(OutputStream outputStream);
  public void setSystemId(File f);
  public void setSystemId(String systemId);
  public void setWriter(Writer writer);
}

StreamSource

Diese Klasse unterstützt Eingabedaten aus einem URL-, File-, Reader- oder InputStream-Objekt. Die System-ID wird genutzt, um relative URLs in den XML- und XSLT-Daten aufzulösen.

public class StreamSource
    implements Source {
  public static final String FEATURE =
    "http://javax.xml.transform.stream.StreamSource/feature";
  public StreamSource(InputStream inputStream);
  public StreamSource(InputStream inputStream, String systemId);
  public StreamSource(Reader reader);
  public StreamSource(Reader reader, String systemId);
  public StreamSource(String systemId);
  public StreamSource(File f);
  public StreamSource( );
  public InputStream getInputStream( );
  public String getPublicId( );
  public Reader getReader( );
  public String getSystemId( );
  public void setInputStream(InputStream inputStream);
  public void setPublicId(String systemId);
  public void setReader(Reader reader);
  public void setSystemId(File f);
  public void setSystemId(String systemId);
}

zum Seitenanfang

<< zurück

vor >>