A API de streaming para XML adicionada ao Java 6 fornece uma interface útil XMLStreamWriter que é usada para escrever documentos XML. esta API não requer a construção de nenhuma estrutura de objeto específica, como no DOM, e a execução de qualquer tarefa intermediária. Ele também oferece suporte a namespaces por padrão, o que é muito útil em situações mais avançadas.

Os métodos incorporados para criar o objeto XMLStreamWriter e gravar dados nele estão listados a seguir:

• writeStartDocument()
• writeStartElement()
• writeCharacters()
• writeEndElement()
• writeEndDocument()

Existem certas limitações anexadas com XMLStreamWriter em java StAX, as quais são principalmente as seguintes:

1. Ainda é possível criar documentos XML não bem formados que, por exemplo, contêm mais de um elemento raiz ou definição de namespace ausente.
2. XMLStreamWriter não recua sua saída, então pode ser um pouco difícil de ler usando um editor de texto simples. Portanto, para a leitura, sugere-se abri-lo em um navegador da Web, a maioria dos quais possui uma interface amigável para visualizar a estrutura dos documentos XML.

Procedimento:

1. Crie uma instância de XMLStreamWriter usando XMLOutputFactory
2. Escreva o cabeçalho do XML e prossiga para escrever os elementos.
3. Depois de adicionar elementos, podemos adicionar atributos, dados de caracteres ou CDATA
4. Fechar elementos abertos
5. Esvaziar elementos ou escrever comentários
6. Fechar e terminar o documento XML

Agora vamos discutir mais como eles são escritos mais tarde, na implementação dos mesmos em nosso programa java.

Etapa 1: Crie uma instância de XMLStreamWriter usando XMLOutputFactory.

XMLOutputFactory outputFactory = XMLOutputFactory.newFactory();
XMLStreamWriter xmlStreamWriter = outputFactory.createXMLStreamWriter(outputStream);

Etapa 2: Grave o cabeçalho do XML e prossiga para gravar os elementos.

xmlStreamWriter.writeStartElement("gfg");

Etapa 3: Depois de adicionar elementos, podemos adicionar atributos, dados de caracteres ou CDATA.

xmlStreamWriter.writeAttribute("id", "10");
xmlStreamWriter.writeCharacters("hello world!");
xmlStreamWriter.writeCData("more text data");

Etapa 4: Fechamento de elementos abertos

xmlStreamWriter.writeEndElement();

Etapa 5: esvaziar elementos ou escrever comentários, mas observe que é uma etapa opcional

xmlStreamWriter.writeEmptyElement("used & new");
xmlStreamWriter.writeComment("Thank you!");

Etapa 6: Fechar e finalizar o documento XML.

xmlStreamWriter.writeEndDocument();
xmlStreamWriter.close();

Exemplo

// Java Program to Illustrate XMLStreamWriter in Java StAX
  
// Importing required classes
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
  
// Main class
public class StaxXMLStreamWriter {
  
    // Main driver method
    public static void main(String[] args)
        throws FileNotFoundException, XMLStreamException,
               UnsupportedEncodingException
    {
  
        // Try block to check for exceptions
        try {
  
            // File Path
            String filePath = "D:\\gfg_file.xml";
  
            // Creating FileWriter object
            Writer fileWriter = new FileWriter(filePath);
  
            // Getting the XMLOutputFactory instance
            XMLOutputFactory xmlOutputFactory
                = XMLOutputFactory.newInstance();
  
            // Creating XMLStreamWriter object from
            // xmlOutputFactory.
            XMLStreamWriter xmlStreamWriter
                = xmlOutputFactory.createXMLStreamWriter(
                    fileWriter);
  
            // Addoing elements to xmlStreamWriter
            // Custom input element addition
            xmlStreamWriter.writeStartElement("gfg");
            xmlStreamWriter.writeAttribute("id", "10");
            xmlStreamWriter.writeCharacters("hello world!");
            xmlStreamWriter.writeCData("more text data");
            xmlStreamWriter.writeEndElement();
            xmlStreamWriter.writeEmptyElement("used & new");
            xmlStreamWriter.writeComment("Thank you!");
            xmlStreamWriter.writeEndDocument();
  
            // Writing the content on XML file and
            // close xmlStreamWriter using close() method
            xmlStreamWriter.flush();
            xmlStreamWriter.close();
  
            // Display message for successful execution of
            // program
            System.out.println(
                "XML file created successfully.");
        }
  
        // Catch block to handle exceptions
        catch (Exception e) {
  
            // Print the line number where exception occurs
            e.printStackTrace();
        }
    }
}

Saída:

<gfg id="10">hello world!
<![CDATA[more text data]]>
</gfg>
<used & new/>
<!--Thank you!-->

Conclusão: 

Streaming API for XML fornece uma maneira muito conveniente, rápida e com uso eficiente de memória para escrever documentos XML sem se preocupar com detalhes e caracteres especiais de escape. É uma ótima alternativa ao DOM, especialmente quando você não precisa manter e gerenciar a árvore DOM na memória por qualquer motivo.