Remplacement rapide de nœud XML valeurs

J'ai un tas de documents XML qui contiennent des informations personnelles que j'ai besoin de le remplacer avec de fausses données. La Personne nœud contient les éléments suivants:

uuid - requis ne doit pas être touché.
prénom - facultatif
nom - option
adresse - facultatif
personID - requis

Une personne peut s'afficher plusieurs fois, dans ce cas le même faux de données doit être utilisée, c'est à dire si deux Personne nœuds ont le même personID, elles doivent recevoir la même fausse carte d'identité.

J'ai mis en œuvre une partie de code Java qui permet de créer une arborescence DOM de la chaîne XML et remplace les nœuds avant de l'écrire à une chaîne. Cela fonctionne bien, mais depuis que j'ai tant de documents, je me demandais si il y a une approche plus rapide. Peut-être grâce à des expressions régulières ou XSLT ou quelque chose?

Voici un exemple de document:

<ADocument>
  <Stuff>
    ...
  </Stuff>
  <OtherStuff>
    ...
  </OtherStuff>
  <Person>
    <uuid>11111111-1111-1111-1111-111111111111</uuid>
    <firstName>Some</firstName>
    <lastName>Person</lastName>
    <personID>111111111111</personID>
  </Person>
  <Person>
    <uuid>22222222-2222-2222-2222-222222222222</uuid>
    <firstName>Another Person</firstName>
    <address>Main St. 2</address>
    <personID>222222222222</personID>
  </Person>
  <Person>
    <uuid>33333333-3333-3333-3333-333333333333</uuid>
    <firstName>Some</firstName>
    <lastName>Person</lastName>
    <personID>111111111111</personID>
  </Person>
  <MoreStuff>
    ...
  </MoreStuff>
</ADocument>

Et c'est mon actuel de mise en œuvre:

public String replaceWithFalseData(String xmlInstance) {
Document dom = toDOM(xmlInstance);
XPathExpression xPathExpression = XPathExpressionFactory.createXPathExpression("//Person");
List<Node> nodeList = xPathExpression.evaluateAsNodeList(dom);
for(Node personNode : nodeList) {
Map<String, Node> childNodes = getChildNodes(personNode);
String personID = childNodes.get("personID").getTextContent();
//Retrieve a cached fake person using the ID, or create a new one if none exists.
Person fakePerson = getFakePerson(personID);
setIfExists(childNodes.get("firstName"), fakePerson.getFirstName());
setIfExists(childNodes.get("lastName"), fakePerson.getLastName());
setIfExists(childNodes.get("address"), fakePerson.getAddress());
setIfExists(childNodes.get("personID"), fakePerson.getPersonID());
}
return toString(dom);
}
public Map<String, Node> getChildNodes(Node parent) {
Map<String, Node> childNodes = new HashMap<String, Node>();
for(Node child = parent.getFirstChild(); child != null; child = child.getNextSibling()) {
if(child.getLocalName() != null) {
childNodes.put(child.getLocalName(), child);
}
}
return childNodes;
}
public void setIfExists(Node node, String value) {
if(node != null) {
node.setTextContent(value);
}
}

Par "rapide" vous entendez plus performant ou le plus élégant?
Quelles sont les règles pour la création de faux prénom, nom, adresse et personId attributs?
plus performant
pour les noms et adresse, juste une chaîne de caractères arbitraire - pour personID, un de 12 caractères longue chaîne de chiffres

InformationsquelleAutor aznan | 2013-09-04

Vous êtes en utilisant DOM API. Plus rapide de remplacement peut être réalisé avec Streaming API for XML (StAX) qui, dans de nombreux cas, peuvent surpasser les DOM-API basée sur:
StAX rapport à DOM

API DOM occupe plus de mémoire que StAX, ce qui peut dégrader les performances, mais est plus facile à utiliser que StAX API.

Solution de travail pour votre exemple - testé sur 150 MO fichier xml, remplacé en 10 sec:

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.XMLEvent;
public class ReplaceXmlWithFakeUser
{
public static void main(String[] args) throws XMLStreamException, IOException
{
XMLInputFactory inFactory = XMLInputFactory.newInstance();
XMLEventReader eventReader = inFactory.createXMLEventReader(new BufferedInputStream(new FileInputStream("c:\\temp\\persons.xml")));
XMLOutputFactory factory = XMLOutputFactory.newInstance();
XMLEventWriter writer = factory.createXMLEventWriter(new BufferedOutputStream(new FileOutputStream("c:\\temp\\fakePersons.xml")));
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
while (eventReader.hasNext())
{
XMLEvent event = eventReader.nextEvent();
if (event.getEventType() == XMLEvent.START_ELEMENT &&
event.asStartElement().getName().toString().equals("Person"))
{
//write Person startElement:
writer.add(event);
/*
STEP 1:
personId is at the end of Person element. Cannot overwrite firstName and address element with fake data yet. Must call getFakePerson() first.
Iterate till you read Person END element and just remember all events within person element which we will overwrite with fake data in step 2.
*/
Person fakePerson=null;
List<XMLEvent> eventsWithinPersonElement = new ArrayList<XMLEvent>();
event = eventReader.nextEvent();
while(!(event.getEventType() == XMLEvent.END_ELEMENT && event.asEndElement().getName().toString().equals("Person")))
{
eventsWithinPersonElement.add(event);
if(event.getEventType() == XMLEvent.START_ELEMENT &&
event.asStartElement().getName().toString().equals("personID"))
{
XMLEvent personIDContentEvent = eventReader.nextEvent();
String personId = personIDContentEvent.asCharacters().toString();
fakePerson = getFakePerson(personId);
eventsWithinPersonElement.add(personIDContentEvent);
}
event = eventReader.nextEvent();
}
XMLEvent personEndElement=event;
//STEP 2:
for (Iterator<XMLEvent> eventWithinPersonElementIterator = eventsWithinPersonElement.iterator(); eventWithinPersonElementIterator.hasNext(); )
{
XMLEvent eventWithinPersonElement = eventWithinPersonElementIterator.next();
writer.add(eventWithinPersonElement);
if(eventWithinPersonElement.getEventType() == XMLEvent.START_ELEMENT &&
eventWithinPersonElement.asStartElement().getName().toString().equals("personID"))
{
writer.add(eventFactory.createCharacters(fakePerson.personId));
//skip personId event
eventWithinPersonElementIterator.next();
}
if(eventWithinPersonElement.getEventType() == XMLEvent.START_ELEMENT &&
eventWithinPersonElement.asStartElement().getName().toString().equals("firstName"))
{
writer.add(eventFactory.createCharacters(fakePerson.firstName));
//skip real firstName
eventWithinPersonElementIterator.next();
}
if(eventWithinPersonElement.getEventType() == XMLEvent.START_ELEMENT &&
eventWithinPersonElement.asStartElement().getName().toString().equals("lastName"))
{
writer.add(eventFactory.createCharacters(fakePerson.lastName));
//skip real firstName
eventWithinPersonElementIterator.next();
}
else if(eventWithinPersonElement.getEventType() == XMLEvent.START_ELEMENT &&
eventWithinPersonElement.asStartElement().getName().toString().equals("address"))
{
writer.add(eventFactory.createCharacters(fakePerson.address));
//skip real address
eventWithinPersonElementIterator.next();
}
}
writer.add(personEndElement);
}
else
{
writer.add(event);
}
}
writer.close();
}
private static Person getFakePerson(String personId)
{
//create simple fake user...
Person fakePerson = new Person();
fakePerson.personId = personId;
fakePerson.firstName = "fake first name: " + Math.random();
fakePerson.lastName = "fake last name: " + Math.random();
fakePerson.address = "fake address: " + Math.random();
return fakePerson;
}
static class Person
{
String personId;
String firstName;
String lastName;
String address;
}
}

Utilisation persons.xml comme entrée:

<ADocument>
<Stuff>
<StuffA></StuffA>
</Stuff>
<OtherStuff>
<OtherStuff>
<ABC>yada yada</ABC>
</OtherStuff>
</OtherStuff>
<Person>
<uuid>11111111-1111-1111-1111-111111111111</uuid>
<firstName>Some</firstName>
<lastName>Person</lastName>
<personID>111111111111</personID>
</Person>
<Person>
<uuid>22222222-2222-2222-2222-222222222222</uuid>
<firstName>Another Person</firstName>
<address>Main St. 2</address>
<personID>222222222222</personID>
</Person>
<Person>
<uuid>33333333-3333-3333-3333-333333333333</uuid>
<firstName>Some</firstName>
<lastName>Person</lastName>
<personID>111111111111</personID>
</Person>
<MoreStuff>
<foo></foo>
<foo>fooo</foo>
<foo><bar></bar></foo>
<foo>
<bar></bar>
<bar/>
<bar>bb</bar>
</foo>
<bar/>
</MoreStuff>
</ADocument>

La production de ce fakePersons.xml résultat:

<?xml version="1.0" encoding="UTF-8"?><ADocument>
<Stuff>
<StuffA></StuffA>
</Stuff>
<OtherStuff>
<OtherStuff>
<ABC>yada yada</ABC>
</OtherStuff>
</OtherStuff>
<Person>
<uuid>11111111-1111-1111-1111-111111111111</uuid>
<firstName>fake first name: 0.9518514637129984</firstName>
<lastName>fake last name: 0.3495378044884426</lastName>
<personID>111111111111</personID>
</Person>
<Person>
<uuid>22222222-2222-2222-2222-222222222222</uuid>
<firstName>fake first name: 0.8945739434355868</firstName>
<address>fake address: 0.40784763231471777</address>
<personID>222222222222</personID>
</Person>
<Person>
<uuid>33333333-3333-3333-3333-333333333333</uuid>
<firstName>fake first name: 0.7863207851479257</firstName>
<lastName>fake last name: 0.09918620445731652</lastName>
<personID>111111111111</personID>
</Person>
<MoreStuff>
<foo></foo>
<foo>fooo</foo>
<foo><bar></bar></foo>
<foo>
<bar></bar>
<bar></bar>
<bar>bb</bar>
</foo>
<bar></bar>
</MoreStuff>
</ADocument>

InformationsquelleAutor Sergej Panic

0

Je ne suis pas sûr si une transformation XSLT peut aider ici. Peut-être que mes connaissances sur XSLT n'est pas assez profonde, mais d'une transformation XSLT permet de créer une nouvelle structure XML sur la base des données d'un document XML. Il semble que vous voulez faire le contraire: en conservant la même structure, mais updateing les données sont basées sur des valeurs dynamiques. Vous pourriez avoir un moment difficile la création d'une telle XSLT.
L'optimalisation peut dépendre de beaucoup de paramètres: le nombre d'éléments par XML, la quantité de l'égalité des PersonIds dans le XML, le nombre de XMLs à traiter, ... Si vous êtes de nouveau affaire avec de gros fichiers, vous pourriez passer à un SAX mise en œuvre pour optimiser votre consommation de mémoire. Si vous re dealign avec un grand nombre de l'égalité des PersonIDs dans le même fichier XML, vous pouvez construire une partie de la mise en cache de la structure derrière votre faux de données que vous utilisez pour remplacer afin de réduire la quantité de hits sur votre DOM (vous pouvez remplacer directement le nœud avec la mise en cache nœud et écraser l'uuid avec l'original).
Si vous avez beaucoup de petits fichiers contenant des PersonIDs vous pouvez utiliser de la croix XML de mise en cache s'il est acceptable que le même faux de données peut être utilisée sur plusieurs fichiers XML.

Aussi, je crois que vous pouvez déposer l' 'setIfExists" sur le PersonID comme il est indiqué comme un champ obligatoire.

InformationsquelleAutor Filip

Je ne peux pas commenter sur la performance relative mais ici, c'est une transformation XSLT solution à votre problème.

Suivantes feuille de style XSLT:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" indent="yes" omit-xml-declaration="yes"/>
<!-- Find the position of the first Person with the same personID as this Person. 
This will be used to provide a unique identifier for that person. -->
<xsl:template name="get-position-id">
<xsl:value-of select="count(../../Person[personID=current()/../personID][1]/preceding-sibling::Person)"/>
</xsl:template>
<!-- For personID elements, we will replace the number with a number based on the position of 
the first Person with the same personId. -->
<xsl:template match="personID">
<xsl:copy>
<xsl:variable name="position-id">
<xsl:call-template name="get-position-id"/>
</xsl:variable>
<xsl:call-template name="create-person-id">
<xsl:with-param name="input" select="$position-id"/>
</xsl:call-template>
</xsl:copy>
</xsl:template>
<!-- For elements that match this template, we will replace the text with an arbitrary string
appended with a number linking them to a particular personID. -->
<xsl:template match="firstName|lastName|address">
<xsl:copy>
<xsl:variable name="position-id">
<xsl:call-template name="get-position-id"/>
</xsl:variable>
<xsl:call-template name="create-fake-string">
<xsl:with-param name="input" select="$position-id"/>
</xsl:call-template>
</xsl:copy>    
</xsl:template>
<!-- The identity transform. -->
<xsl:template match="@*|node()">
<xsl:copy>
<xsl:apply-templates select="@*|node()"/>
</xsl:copy>
</xsl:template>
<!-- This template generates a number that can be used to replace personID. -->
<xsl:template name="create-person-id">
<xsl:param name="input"/>
<!-- Turn the input into a 12-digit number padded by zeroes. -->
<xsl:value-of select="format-number($input, '000000000000') "/>
</xsl:template>
<!-- This template generates a string that can be used to replace data. -->
<xsl:template name="create-fake-string">
<xsl:param name="input"/>
<!-- Create a string to replace data with, appending the input parameter. -->
<xsl:text>FAKEDATA</xsl:text>
<xsl:value-of select="$input"/>
</xsl:template>
</xsl:stylesheet>

génère le code XML suivant lorsqu'il est appliqué à votre exemple de document:

<ADocument>
<Stuff>
...
</Stuff>
<OtherStuff>
...
</OtherStuff>
<Person>
<uuid>11111111-1111-1111-1111-111111111111</uuid>
<firstName>FAKEDATA0</firstName>
<lastName>FAKEDATA0</lastName>
<personID>000000000000</personID>
</Person>
<Person>
<uuid>22222222-2222-2222-2222-222222222222</uuid>
<firstName>FAKEDATA1</firstName>
<address>FAKEDATA1</address>
<personID>000000000001</personID>
</Person>
<Person>
<uuid>33333333-3333-3333-3333-333333333333</uuid>
<firstName>FAKEDATA0</firstName>
<lastName>FAKEDATA0</lastName>
<personID>000000000000</personID>
</Person>
<MoreStuff>
...
</MoreStuff>
</ADocument>

InformationsquelleAutor Ben L

Merci à tous ceux qui ont contribué! J'ai couru un test de performance sur un ensemble de 2000 documents XML à l'aide de mon DOM mise en œuvre, Sergej du StAX mise en œuvre de Ben et XSLT mise en œuvre ainsi que de l'autre la mise en œuvre de la mienne, à l'aide d'expressions régulières. Les résultats sont comme suit:

DOM: 23,93 s
StAX: 20,37 s
XSLT: 83,52 s
Regex: 7,83 s

Et voici le gagnant:

public String replaceWithFalseData(String xmlInstance) {
Pattern personPattern = Pattern.compile("<Person>.*?</Person>", Pattern.DOTALL);
Matcher personMatcher = personPattern.matcher(xmlInstance);
StringBuffer xmlBuffer = new StringBuffer();
while(personMatcher.find()) {
String personXml = personMatcher.group();
Pattern idPattern = Pattern.compile("<personID>(.*)</personID>");
Matcher idMatcher = idPattern.matcher(personXml);
idMatcher.find();
String id = idMatcher.group(1);
Person fakePerson = getFakePerson(id);
personXml = personXml.replaceFirst("<firstName>.*</firstName>",
"<firstName>" + fakePerson.getFirstName() + "</firstName>");
personXml = personXml.replaceFirst("<lastName>.*</lastName>",
"<lastName>" + fakePerson.getLastName() + "</lastName>");
personXml = personXml.replaceFirst("<address>.*</address>",
"<address>" + fakePerson.getAddress() + "</address>");
personXml = personXml.replaceFirst("<personID>.*</personID>",
"<personID>" + fakePerson.getPersonID() + "</personID>");
personMatcher.appendReplacement(xmlBuffer, personXml);
}
personMatcher.appendTail(xmlBuffer);
return xmlBuffer.toString();
}

Cela peut être rapide, mais l'expression rationnelle basée sur les solutions ne sont pas fiables. Jeff Atwood explique pourquoi: blog.codinghorror.com/parsing-html-the-cthulhu-way (HTML ou XML, n'a pas d'importance)

InformationsquelleAutor aznan

Vous devez vous connecter pour publier un commentaire.