Converti frammento XML stringa in nodo documento in Java

Question

In Java, come è possibile convertire una stringa che rappresenta un frammento di XML per l'inserimento in un documento XML?

ad es.

String newNode = "<node>value</node>"; // Convert this to XML 

quindi inserire questo nodo in un org.w3c.dom.Document come il figlio di un dato nodo?

Answer 1

Element node = DocumentBuilderFactory 
    .newInstance() 
    .newDocumentBuilder() 
    .parse(new ByteArrayInputStream("<node>value</node>".getBytes())) 
    .getDocumentElement(); 

Answer 2

È possibile utilizzare il metodo del documento import (o adopt) per aggiungere frammenti XML:

/** 
    * @param docBuilder 
    *   the parser 
    * @param parent 
    *   node to add fragment to 
    * @param fragment 
    *   a well formed XML fragment 
    */ 
    public static void appendXmlFragment(
     DocumentBuilder docBuilder, Node parent, 
     String fragment) throws IOException, SAXException { 
    Document doc = parent.getOwnerDocument(); 
    Node fragmentNode = docBuilder.parse(
     new InputSource(new StringReader(fragment))) 
     .getDocumentElement(); 
    fragmentNode = doc.importNode(fragmentNode, true); 
    parent.appendChild(fragmentNode); 
    } 

Answer 3

Per quello che vale, ecco una soluzione mi è venuta utilizzando la libreria dom4j . (. Ho fatto controllare che funzioni)

Leggi il frammento XML in un org.dom4j.Document (nota: tutte le classi XML utilizzati qui sotto sono da org.dom4j; vedi Appendice):

String newNode = "<node>value</node>"; // Convert this to XML 
    SAXReader reader = new SAXReader(); 
    Document newNodeDocument = reader.read(new StringReader(newNode)); 

quindi ottenere il documento in cui è inserito il nuovo nodo e l'elemento genitore (essere) da esso. (. Il vostro org.w3c.dom.Document avrebbe bisogno di essere convertito in org.dom4j.Document qui) Per scopi di test, ho creato uno come questo:

Document originalDoc = 
     new SAXReader().read(new StringReader("<root><given></given></root>")); 
    Element givenNode = originalDoc.getRootElement().element("given"); 

Aggiungendo il nuovo elemento figlio è molto semplice:

givenNode.add(newNodeDocument.getRootElement()); 

Fatto. Emissione originalDoc ora cede:

<?xml version="1.0" encoding="utf-8"?> 

<root> 
    <given> 
     <node>value</node> 
    </given> 
</root> 

Appendice: Perché la tua domanda parla org.w3c.dom.Document, ecco come convertire tra questo e org.dom4j.Document.

// dom4j -> w3c 
DOMWriter writer = new DOMWriter(); 
org.w3c.dom.Document w3cDoc = writer.write(dom4jDoc); 

// w3c -> dom4j 
DOMReader reader = new DOMReader(); 
Document dom4jDoc = reader.read(w3cDoc); 

(Se avreste bisogno di entrambi i tipi di Document s regolarmente, potrebbe avere senso di mettere questi in metodi di utilità pulito, magari in una classe chiamata XMLUtils o qualcosa di simile.)

Forse c'è sono modi migliori per farlo, anche senza alcuna libreria di terze parti. Ma dalle soluzioni presentate finora, a mio avviso questo è il modo più semplice, anche se è necessario eseguire le conversioni dom4j < -> w3c.

Aggiornamento (2011): prima di aggiungere la dipendenza di dom4j al codice, notare che it is not an actively maintained project, and has some other problems too. La versione 2.0 migliorata è stata utilizzata per anni, ma è disponibile solo una versione alpha. Potresti prendere in considerazione un'alternativa, come XOM, invece; leggi di più nella domanda collegata sopra.

Answer 4

Ecco un'altra soluzione, utilizzando XOM library, che compete con my dom4j answer. (Questo è parte del mio quest to find a good dom4j replacement dove XOM è stato suggerito come una opzione.)

Prima leggi il frammento XML in un nu.xom.Document:

String newNode = "<node>value</node>"; // Convert this to XML 
Document newNodeDocument = new Builder().build(newNode, ""); 

Quindi, ottenere il documento e il Nodo in base al quale si aggiunge il frammento. Anche in questo caso, a scopo di test creerò il documento da una stringa:

Document originalDoc = new Builder().build("<root><given></given></root>", ""); 
Element givenNode = originalDoc.getRootElement().getFirstChildElement("given"); 

Ora, aggiunge il nodo figlio è semplice, e simile a quello con dom4j (tranne che XOM non consente di aggiungere l'elemento radice originale che appartiene già alla newNodeDocument):

givenNode.appendChild(newNodeDocument.getRootElement().copy()); 

Emissione del documento produce il risultato corretto XML (ed è estremamente semplice con XOM: basta stampare la stringa restituita da originalDoc.toXML()):

<?xml version="1.0"?> 
<root><given><node>value</node></given></root> 

(Se si desidera formattare l'XML correttamente (con indentazioni e linefeed), utilizzare uno Serializer; grazie a Peter Štibraný per averlo indicato.)

Quindi, ammettiamolo, non è molto diverso dalla soluzione dom4j. :) Tuttavia, XOM potrebbe essere un po 'più bello con cui lavorare, perché l'API è meglio documentata e, grazie alla sua filosofia di progettazione, esiste un modo canonico per fare ogni cosa.

Appendice: Anche in questo caso, ecco come convertire tra org.w3c.dom.Document e nu.xom.Document. Utilizzare i metodi di supporto nella classe di XOM DOMConverter:

// w3c -> xom 
Document xomDoc = DOMConverter.convert(w3cDoc); 

// xom -> w3c 
org.w3c.dom.Document w3cDoc = DOMConverter.convert(xomDoc, domImplementation); 
// You can get a DOMImplementation instance e.g. from DOMImplementationRegistry 

Answer 5

Se stai usando dom4j, basta che si può fare:

documento Document = DocumentHelper.parseText (testo);

(dom4j ora si trova qui: https://github.com/dom4j/dom4j)

Answer 6

... e se si sta utilizzando puramente XOM, qualcosa di simile:

String xml = "<fakeRoot>" + xml + "</fakeRoot>"; 
    Document doc = new Builder(false).build(xml, null); 
    Nodes children = doc.getRootElement().removeChildren(); 
    for(int ix = 0; ix < children.size(); ix++) { 
     otherDocumentElement.appendChild(children.get(ix)); 
    } 

XOM utilizza fakeroot internamente per fare più o meno lo stesso, quindi dovrebbe essere sicuro, se non proprio elegante.

Answer 7

/** 
* 
* Convert a string to a Document Object 
* 
* @param xml The xml to convert 
* @return A document Object 
* @throws IOException 
* @throws SAXException 
* @throws ParserConfigurationException 
*/ 
public static Document string2Document(String xml) throws IOException, SAXException, ParserConfigurationException { 

    if (xml == null) 
    return null; 

    return inputStream2Document(new ByteArrayInputStream(xml.getBytes())); 

} 


/** 
* Convert an inputStream to a Document Object 
* @param inputStream The inputstream to convert 
* @return a Document Object 
* @throws IOException 
* @throws SAXException 
* @throws ParserConfigurationException 
*/ 
public static Document inputStream2Document(InputStream inputStream) throws IOException, SAXException, ParserConfigurationException { 
    DocumentBuilderFactory newInstance = DocumentBuilderFactory.newInstance(); 
    newInstance.setNamespaceAware(true); 
    Document parse = newInstance.newDocumentBuilder().parse(inputStream); 
    return parse; 
} 

Answer 8

Prova jcabi-xml, con un uno di linea:

Node node = new XMLDocument("<node>value</node>").node();