XMLWriter (Red Hat JBoss Enterprise Application Platform 7.4.21.GA public API)

java.lang.Object
- org.xml.sax.helpers.XMLFilterImpl
- - com.sun.xml.txw2.output.XMLWriter

All Implemented Interfaces:

ContentHandler, DTDHandler, EntityResolver, ErrorHandler, LexicalHandler, XMLFilter, XMLReader

Direct Known Subclasses:

DataWriter
```
public class XMLWriter
extends XMLFilterImpl
implements LexicalHandler
```
Filter to write an XML document from a SAX event stream.
This class can be used by itself or as part of a SAX event stream: it takes as input a series of SAX2 ContentHandler events and uses the information in those events to write an XML document. Since this class is a filter, it can also pass the events on down a filter chain for further processing (you can use the XMLWriter to take a snapshot of the current state at any point in a filter chain), and it can be used directly as a ContentHandler for a SAX2 XMLReader.

The client creates a document by invoking the methods for standard SAX2 events, always beginning with the startDocument method and ending with the endDocument method. There are convenience methods provided so that clients to not have to create empty attribute lists or provide empty strings as parameters; for example, the method invocation
```
 w.startElement("foo");
 
```
is equivalent to the regular SAX2 ContentHandler method
```
 w.startElement("", "foo", "", new AttributesImpl());
 
```
Except that it is more efficient because it does not allocate a new empty attribute list each time. The following code will send a simple XML document to standard output:
```
 XMLWriter w = new XMLWriter();

 w.startDocument();
 w.startElement("greeting");
 w.characters("Hello, world!");
 w.endElement("greeting");
 w.endDocument();
 
```
The resulting document will look like this:
```
  <?xml version="1.0" standalone="yes"?>
 
 <greeting>Hello, world!</greeting>
 
```
In fact, there is an even simpler convenience method, dataElement, designed for writing elements that contain only character data, so the code to generate the document could be shortened to
```
 XMLWriter w = new XMLWriter();

 w.startDocument();
 w.dataElement("greeting", "Hello, world!");
 w.endDocument();
 
```
Whitespace

According to the XML Recommendation, all whitespace in an XML document is potentially significant to an application, so this class never adds newlines or indentation. If you insert three elements in a row, as in
```
 w.dataElement("item", "1");
 w.dataElement("item", "2");
 w.dataElement("item", "3");
 
```
you will end up with
```
 <item>1</item><item>3</item><item>3</item>
 
```
You need to invoke one of the characters methods explicitly to add newlines or indentation. Alternatively, you can use DataWriter, which is derived from this class -- it is optimized for writing purely data-oriented (or field-oriented) XML, and does automatic linebreaks and indentation (but does not support mixed content properly).

Namespace Support

The writer contains extensive support for XML Namespaces, so that a client application does not have to keep track of prefixes and supply xmlns attributes. By default, the XML writer will generate Namespace declarations in the form _NS1, _NS2, etc., wherever they are needed, as in the following example:
```
 w.startDocument();
 w.emptyElement("http://www.foo.com/ns/", "foo");
 w.endDocument();
 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?>

 <_NS1:foo xmlns:_NS1="http://www.foo.com/ns/"/>
 
```
In many cases, document authors will prefer to choose their own prefixes rather than using the (ugly) default names. The XML writer allows two methods for selecting prefixes:
1. the qualified name
2. the startPrefixMapping(String, String) method.
Whenever the XML writer finds a new Namespace URI, it checks to see if a qualified (prefixed) name is also available; if so it attempts to use the name's prefix (as long as the prefix is not already in use for another Namespace URI).

Before writing a document, the client can also pre-map a prefix to a Namespace URI with the setPrefix method:
```
 w.setPrefix("http://www.foo.com/ns/", "foo");
 w.startDocument();
 w.emptyElement("http://www.foo.com/ns/", "foo");
 w.endDocument();
 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?>

 <foo:foo xmlns:foo="http://www.foo.com/ns/"/>
 
```
The default Namespace simply uses an empty string as the prefix:
```
 w.setPrefix("http://www.foo.com/ns/", "");
 w.startDocument();
 w.emptyElement("http://www.foo.com/ns/", "foo");
 w.endDocument();
 
```
The resulting document will look like this:
```
 <?xml version="1.0" standalone="yes"?>

 <foo xmlns="http://www.foo.com/ns/"/>
 
```
By default, the XML writer will not declare a Namespace until it is actually used. Sometimes, this approach will create a large number of Namespace declarations, as in the following example:
```
 <xml version="1.0" standalone="yes"?>

 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <rdf:Description about="http://www.foo.com/ids/books/12345">
   <dc:title xmlns:dc="http://www.purl.org/dc/">A Dark Night</dc:title>
   <dc:creator xmlns:dc="http://www.purl.org/dc/">Jane Smith</dc:title>
   <dc:date xmlns:dc="http://www.purl.org/dc/">2000-09-09</dc:title>
  </rdf:Description>
 </rdf:RDF>
 
```
The "rdf" prefix is declared only once, because the RDF Namespace is used by the root element and can be inherited by all of its descendants; the "dc" prefix, on the other hand, is declared three times, because no higher element uses the Namespace. To solve this problem, you can instruct the XML writer to predeclare Namespaces on the root element even if they are not used there:
```
 w.forceNSDecl("http://www.purl.org/dc/");
 
```
Now, the "dc" prefix will be declared on the root element even though it's not needed there, and can be inherited by its descendants:
```
 <xml version="1.0" standalone="yes"?>

 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             xmlns:dc="http://www.purl.org/dc/">
  <rdf:Description about="http://www.foo.com/ids/books/12345">
   <dc:title>A Dark Night</dc:title>
   <dc:creator>Jane Smith</dc:title>
   <dc:date>2000-09-09</dc:title>
  </rdf:Description>
 </rdf:RDF>
 
```
This approach is also useful for declaring Namespace prefixes that be used by qualified names appearing in attribute values or character data.
Since:

JAXB 1.0

Version:

0.2

Author:

David Megginson, david@megginson.com

See Also:

XMLFilter, ContentHandler

Constructor Summary

Constructors
Constructor and Description
`XMLWriter(Writer writer, String encoding)`
`XMLWriter(Writer writer, String encoding, CharacterEscapeHandler _escapeHandler)` Create a new XML writer.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`characters(char[] ch, int start, int len)` Write character data.
`void`	`characters(String data)` Write a string of character data, with XML escaping.
`void`	`comment(char[] ch, int start, int length)`
`void`	`dataElement(String localName, String content)` Write an element with character data content but no attributes or Namespace URI.
`void`	`dataElement(String uri, String localName, String content)` Write an element with character data content but no attributes.
`void`	`dataElement(String uri, String localName, String qName, Attributes atts, String content)` Write an element with character data content.
`void`	`endCDATA()`
`void`	`endDocument()` Write a newline at the end of the document.
`void`	`endDTD()`
`void`	`endElement(String localName)` End an element without a Namespace URI or qname.
`void`	`endElement(String uri, String localName)` End an element without a qname.
`void`	`endElement(String uri, String localName, String qName)` Write an end tag.
`void`	`endEntity(String name)`
`void`	`flush()` Flush the output.
`void`	`ignorableWhitespace(char[] ch, int start, int length)` Write ignorable whitespace.
`void`	`processingInstruction(String target, String data)` Write a processing instruction.
`void`	`reset()` Reset the writer.
`void`	`setEncoding(String encoding)`
`void`	`setHeader(String _header)` Sets the header string.
`void`	`setOutput(Writer writer, String _encoding)` Set a new output destination for the document.
`void`	`setXmlDecl(boolean _writeXmlDecl)` Set whether the writer should print out the XML declaration ({@code
`void`	`startCDATA()`
`void`	`startDocument()` Write the XML declaration at the beginning of the document.
`void`	`startDTD(String name, String publicId, String systemId)`
`void`	`startElement(String localName)` Start a new element without a qname, attributes or a Namespace URI.
`void`	`startElement(String uri, String localName)` Start a new element without a qname or attributes.
`void`	`startElement(String uri, String localName, String qName, Attributes atts)` Write a start tag.
`void`	`startEntity(String name)`
`void`	`startPrefixMapping(String prefix, String uri)`

Methods inherited from class org.xml.sax.helpers.XMLFilterImpl
endPrefixMapping, error, fatalError, getContentHandler, getDTDHandler, getEntityResolver, getErrorHandler, getFeature, getParent, getProperty, notationDecl, parse, parse, resolveEntity, setContentHandler, setDocumentLocator, setDTDHandler, setEntityResolver, setErrorHandler, setFeature, setParent, setProperty, skippedEntity, unparsedEntityDecl, warning

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - XMLWriter
```
public XMLWriter(Writer writer,
                 String encoding,
                 CharacterEscapeHandler _escapeHandler)
```
    Create a new XML writer.
    Write to the writer provided.
    
    Parameters:
    
    writer - The output destination, or null to use standard output.
    
    encoding - If non-null string is specified, it is written as a part of the XML declaration.
  - XMLWriter
```
public XMLWriter(Writer writer,
                 String encoding)
```
- Method Detail
  - reset
```
public void reset()
```
    Reset the writer.
    This method is especially useful if the writer throws an exception before it is finished, and you want to reuse the writer for a new document. It is usually a good idea to invoke flush before resetting the writer, to make sure that no output is lost.
    
    This method is invoked automatically by the startDocument method before writing a new document.
    
    Note: this method will not clear the prefix or URI information in the writer or the selected output writer.
    
    See Also:
    
    flush()
  - flush
```
public void flush()
           throws IOException
```
    Flush the output.
    This method flushes the output stream. It is especially useful when you need to make certain that the entire document has been written to output but do not want to _commit the output stream.
    
    This method is invoked automatically by the endDocument method after writing a document.
    
    Throws:
    
    IOException
    
    See Also:
    
    reset()
  - setOutput
```
public void setOutput(Writer writer,
                      String _encoding)
```
    Set a new output destination for the document.
    
    Parameters:
    
    writer - The output destination, or null to use standard output.
    
    See Also:
    
    flush()
  - setEncoding
```
public void setEncoding(String encoding)
```
  - setXmlDecl
```
public void setXmlDecl(boolean _writeXmlDecl)
```
    Set whether the writer should print out the XML declaration (<?xml version='1.0' ... ?>).
    This option is set to true by default.
  - setHeader
```
public void setHeader(String _header)
```
    Sets the header string. This string will be written right after the xml declaration without any escaping. Useful for generating a boiler-plate DOCTYPE decl, PIs, and comments.
    
    Parameters:
    
    _header - passing null will work as if the empty string is passed.
  - startPrefixMapping
```
public void startPrefixMapping(String prefix,
                               String uri)
                        throws SAXException
```
    Specified by:
    
    startPrefixMapping in interface ContentHandler
    
    Overrides:
    
    startPrefixMapping in class XMLFilterImpl
    
    Throws:
    
    SAXException
  - startDocument
```
public void startDocument()
                   throws SAXException
```
    Write the XML declaration at the beginning of the document. Pass the event on down the filter chain for further processing.
    
    Specified by:
    
    startDocument in interface ContentHandler
    
    Overrides:
    
    startDocument in class XMLFilterImpl
    
    Throws:
    
    SAXException - If there is an error writing the XML declaration, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    ContentHandler.startDocument()
  - endDocument
```
public void endDocument()
                 throws SAXException
```
    Write a newline at the end of the document. Pass the event on down the filter chain for further processing.
    
    Specified by:
    
    endDocument in interface ContentHandler
    
    Overrides:
    
    endDocument in class XMLFilterImpl
    
    Throws:
    
    SAXException - If there is an error writing the newline, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    ContentHandler.endDocument()
  - startElement
```
public void startElement(String uri,
                         String localName,
                         String qName,
                         Attributes atts)
                  throws SAXException
```
    Write a start tag. Pass the event on down the filter chain for further processing.
    
    Specified by:
    
    startElement in interface ContentHandler
    
    Overrides:
    
    startElement in class XMLFilterImpl
    
    Parameters:
    
    uri - The Namespace URI, or the empty string if none is available.
    
    localName - The element's local (unprefixed) name (required).
    
    qName - The element's qualified (prefixed) name, or the empty string is none is available. This method will use the qName as a template for generating a prefix if necessary, but it is not guaranteed to use the same qName.
    
    atts - The element's attribute list (must not be null).
    
    Throws:
    
    SAXException - If there is an error writing the start tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    ContentHandler.startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
  - endElement
```
public void endElement(String uri,
                       String localName,
                       String qName)
                throws SAXException
```
    Write an end tag. Pass the event on down the filter chain for further processing.
    
    Specified by:
    
    endElement in interface ContentHandler
    
    Overrides:
    
    endElement in class XMLFilterImpl
    
    Parameters:
    
    uri - The Namespace URI, or the empty string if none is available.
    
    localName - The element's local (unprefixed) name (required).
    
    qName - The element's qualified (prefixed) name, or the empty string is none is available. This method will use the qName as a template for generating a prefix if necessary, but it is not guaranteed to use the same qName.
    
    Throws:
    
    SAXException - If there is an error writing the end tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    ContentHandler.endElement(java.lang.String, java.lang.String, java.lang.String)
  - characters
```
public void characters(char[] ch,
                       int start,
                       int len)
                throws SAXException
```
    Write character data. Pass the event on down the filter chain for further processing.
    
    Specified by:
    
    characters in interface ContentHandler
    
    Overrides:
    
    characters in class XMLFilterImpl
    
    Parameters:
    
    ch - The array of characters to write.
    
    start - The starting position in the array.
    
    len - The number of characters to write.
    
    Throws:
    
    SAXException - If there is an error writing the characters, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    ContentHandler.characters(char[], int, int)
  - ignorableWhitespace
```
public void ignorableWhitespace(char[] ch,
                                int start,
                                int length)
                         throws SAXException
```
    Write ignorable whitespace. Pass the event on down the filter chain for further processing.
    
    Specified by:
    
    ignorableWhitespace in interface ContentHandler
    
    Overrides:
    
    ignorableWhitespace in class XMLFilterImpl
    
    Parameters:
    
    ch - The array of characters to write.
    
    start - The starting position in the array.
    
    length - The number of characters to write.
    
    Throws:
    
    SAXException - If there is an error writing the whitespace, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    ContentHandler.ignorableWhitespace(char[], int, int)
  - processingInstruction
```
public void processingInstruction(String target,
                                  String data)
                           throws SAXException
```
    Write a processing instruction. Pass the event on down the filter chain for further processing.
    
    Specified by:
    
    processingInstruction in interface ContentHandler
    
    Overrides:
    
    processingInstruction in class XMLFilterImpl
    
    Parameters:
    
    target - The PI target.
    
    data - The PI data.
    
    Throws:
    
    SAXException - If there is an error writing the PI, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    ContentHandler.processingInstruction(java.lang.String, java.lang.String)
  - startElement
```
public void startElement(String uri,
                         String localName)
                  throws SAXException
```
    Start a new element without a qname or attributes.
    This method will provide a default empty attribute list and an empty string for the qualified name. It invokes startElement(String, String, String, Attributes) directly.
    
    Parameters:
    
    uri - The element's Namespace URI.
    
    localName - The element's local name.
    
    Throws:
    
    SAXException - If there is an error writing the start tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    startElement(String, String, String, Attributes)
  - startElement
```
public void startElement(String localName)
                  throws SAXException
```
    Start a new element without a qname, attributes or a Namespace URI.
    This method will provide an empty string for the Namespace URI, and empty string for the qualified name, and a default empty attribute list. It invokes #startElement(String, String, String, Attributes)} directly.
    
    Parameters:
    
    localName - The element's local name.
    
    Throws:
    
    SAXException - If there is an error writing the start tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    startElement(String, String, String, Attributes)
  - endElement
```
public void endElement(String uri,
                       String localName)
                throws SAXException
```
    End an element without a qname.
    This method will supply an empty string for the qName. It invokes endElement(String, String, String) directly.
    
    Parameters:
    
    uri - The element's Namespace URI.
    
    localName - The element's local name.
    
    Throws:
    
    SAXException - If there is an error writing the end tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    endElement(String, String, String)
  - endElement
```
public void endElement(String localName)
                throws SAXException
```
    End an element without a Namespace URI or qname.
    This method will supply an empty string for the qName and an empty string for the Namespace URI. It invokes endElement(String, String, String) directly.
    
    Parameters:
    
    localName - The element's local name.
    
    Throws:
    
    SAXException - If there is an error writing the end tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    endElement(String, String, String)
  - dataElement
```
public void dataElement(String uri,
                        String localName,
                        String qName,
                        Attributes atts,
                        String content)
                 throws SAXException
```
    Write an element with character data content.
    This is a convenience method to write a complete element with character data content, including the start tag and end tag.
    
    This method invokes startElement(String, String, String, Attributes), followed by characters(String), followed by endElement(String, String, String).
    
    Parameters:
    
    uri - The element's Namespace URI.
    
    localName - The element's local name.
    
    qName - The element's default qualified name.
    
    atts - The element's attributes.
    
    content - The character data content.
    
    Throws:
    
    SAXException - If there is an error writing the empty tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    startElement(String, String, String, Attributes), characters(String), endElement(String, String, String)
  - dataElement
```
public void dataElement(String uri,
                        String localName,
                        String content)
                 throws SAXException
```
    Write an element with character data content but no attributes.
    This is a convenience method to write a complete element with character data content, including the start tag and end tag. This method provides an empty string for the qname and an empty attribute list.
    
    This method invokes startElement(String, String, String, Attributes), followed by characters(String), followed by endElement(String, String, String).
    
    Parameters:
    
    uri - The element's Namespace URI.
    
    localName - The element's local name.
    
    content - The character data content.
    
    Throws:
    
    SAXException - If there is an error writing the empty tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    startElement(String, String, String, Attributes), characters(String), endElement(String, String, String)
  - dataElement
```
public void dataElement(String localName,
                        String content)
                 throws SAXException
```
    Write an element with character data content but no attributes or Namespace URI.
    This is a convenience method to write a complete element with character data content, including the start tag and end tag. The method provides an empty string for the Namespace URI, and empty string for the qualified name, and an empty attribute list.
    
    This method invokes startElement(String, String, String, Attributes), followed by characters(String), followed by endElement(String, String, String).
    
    Parameters:
    
    localName - The element's local name.
    
    content - The character data content.
    
    Throws:
    
    SAXException - If there is an error writing the empty tag, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    startElement(String, String, String, Attributes), characters(String), endElement(String, String, String)
  - characters
```
public void characters(String data)
                throws SAXException
```
    Write a string of character data, with XML escaping.
    This is a convenience method that takes an XML String, converts it to a character array, then invokes characters(char[], int, int).
    
    Parameters:
    
    data - The character data.
    
    Throws:
    
    SAXException - If there is an error writing the string, or if a handler further down the filter chain raises an exception.
    
    See Also:
    
    characters(char[], int, int)
  - startDTD
```
public void startDTD(String name,
                     String publicId,
                     String systemId)
              throws SAXException
```
    Specified by:
    
    startDTD in interface LexicalHandler
    
    Throws:
    
    SAXException
  - endDTD
```
public void endDTD()
            throws SAXException
```
    Specified by:
    
    endDTD in interface LexicalHandler
    
    Throws:
    
    SAXException
  - startEntity
```
public void startEntity(String name)
                 throws SAXException
```
    Specified by:
    
    startEntity in interface LexicalHandler
    
    Throws:
    
    SAXException
  - endEntity
```
public void endEntity(String name)
               throws SAXException
```
    Specified by:
    
    endEntity in interface LexicalHandler
    
    Throws:
    
    SAXException
  - startCDATA
```
public void startCDATA()
                throws SAXException
```
    Specified by:
    
    startCDATA in interface LexicalHandler
    
    Throws:
    
    SAXException
  - endCDATA
```
public void endCDATA()
              throws SAXException
```
    Specified by:
    
    endCDATA in interface LexicalHandler
    
    Throws:
    
    SAXException
  - comment
```
public void comment(char[] ch,
                    int start,
                    int length)
             throws SAXException
```
    Specified by:
    
    comment in interface LexicalHandler
    
    Throws:
    
    SAXException

Class XMLWriter

Whitespace

Namespace Support

Constructor Summary

Method Summary

Methods inherited from class org.xml.sax.helpers.XMLFilterImpl

Methods inherited from class java.lang.Object

Constructor Detail

XMLWriter

XMLWriter

Method Detail

reset

flush

setOutput

setEncoding

setXmlDecl

setHeader

startPrefixMapping

startDocument

endDocument

startElement

endElement

characters

ignorableWhitespace

processingInstruction

startElement

startElement

endElement

endElement

dataElement

dataElement

dataElement

characters

startDTD

endDTD

startEntity

endEntity

startCDATA

endCDATA

comment