Fusionnez deux fichiers XML en Java

Pas très élégant, mais vous pouvez le faire avec le DOM et l'analyseur de XPath:

public class MergeXmlDemo {
public static void main(String[] args) throws Exception {
//proper error/exception handling omitted for brevity
File file1 = new File("merge1.xml");
File file2 = new File("merge2.xml");
Document doc = merge("/run/host/results", file1, file2);
print(doc);
}
private static Document merge(String expression,
File... files) throws Exception {
XPathFactory xPathFactory = XPathFactory.newInstance();
XPath xpath = xPathFactory.newXPath();
XPathExpression compiledExpression = xpath
.compile(expression);
return merge(compiledExpression, files);
}
private static Document merge(XPathExpression expression,
File... files) throws Exception {
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory
.newInstance();
docBuilderFactory
.setIgnoringElementContentWhitespace(true);
DocumentBuilder docBuilder = docBuilderFactory
.newDocumentBuilder();
Document base = docBuilder.parse(files[0]);
Node results = (Node) expression.evaluate(base,
XPathConstants.NODE);
if (results == null) {
throw new IOException(files[0]
+ ": expression does not evaluate to node");
}
for (int i = 1; i < files.length; i++) {
Document merge = docBuilder.parse(files[i]);
Node nextResults = (Node) expression.evaluate(merge,
XPathConstants.NODE);
while (nextResults.hasChildNodes()) {
Node kid = nextResults.getFirstChild();
nextResults.removeChild(kid);
kid = base.importNode(kid, true);
results.appendChild(kid);
}
}
return base;
}
private static void print(Document doc) throws Exception {
TransformerFactory transformerFactory = TransformerFactory
.newInstance();
Transformer transformer = transformerFactory
.newTransformer();
DOMSource source = new DOMSource(doc);
Result result = new StreamResult(System.out);
transformer.transform(source, result);
}
}

Cela suppose que vous pouvez vous tenir au moins deux des documents en mémoire simultanément.

Merci à tous pour leurs suggestions, malheureusement, aucune des méthodes proposées s'est avéré être adapté à la fin, comme j'avais besoin d'avoir des règles pour la façon dont les différents nœuds de la structure où mereged.

Donc ce que j'ai fait est de prendre le DTD concernant les fichiers XML, j'ai été de fusionner et de créer un certain nombre de classes qui reflètent la structure.
À partir de cela, j'ai utilisé XStream à unserialize le fichier XML de retour dans les classes.

De cette façon, je annoté mes classes en faire un processus d'utilisation d'une combinaison de règles affectées avec des annotations et un peu de réflexion en vue de la fusion des Objets, par opposition à la fusion de l'effectif de la structure XML.

Si quelqu'un est intéressé, dans le code que dans ce cas fusionne Nmap fichiers XML veuillez voir http://fluxnetworks.co.uk/NmapXMLMerge.tar.gz les codes qui ne sont pas parfait et je vous avoue ne pas massivement souple, mais cela fonctionne bien. J'ai l'intention de remettre sur pied le système avec l'analyse de la DTD automatiquement quand j'ai du temps libre.

Il pourrait aider si vous avez été explicite sur le résultat que vous êtes intéressé par la réalisation. Est-ce que vous me demandez?

Doc A:

<root>
<a/>
<b>
<c/>
</b>
</root>

Doc B:

<root>
<d/>
</root>

Résultat Fusionné:

<root>
<a/>
<b>
<c/>
</b>
<d/>
</root>

Êtes-vous inquiet au sujet de mise à l'échelle pour les documents de grande taille?

La façon la plus simple à mettre en Java est d'utiliser un flux XML parser (google pour "java StAX'). Si vous utilisez le javax.xml.flux de bibliothèque, vous trouverez que la XMLEventWriter a une méthode pratique XMLEventWriter#ajouter(XMLEvent). Tout ce que vous avez à faire est de la boucle sur les éléments de niveau supérieur dans chaque document et de les ajouter à votre écrivain à l'aide de cette méthode pour générer votre résultat fusionné. La seule funky partie est mise en œuvre, le lecteur logique qui considère uniquement (seuls les appels 'ajouter') sur les nœuds de niveau supérieur.

J'ai récemment mis en œuvre cette méthode si vous avez besoin de conseils.

Vous pourriez être en mesure d'écrire une application java qui deserilizes les documents XML en objets, puis "fusionner" les objets individuels par programmation dans une collection. Ensuite, vous pouvez sérialiser l'objet de collection, de les renvoyer à un fichier XML avec tout "de la fusion."

La JAXB API a certains outils permettent de convertir un document XML et le schéma dans les classes java. Le "xjc" outil pourrait être en mesure de le faire, bien que je ne me souviens pas si vous pouvez créer des classes directement à partir du document XML, ou si vous devez générer un schéma d'abord. Il existe des outils que peut générer un schéma à partir d'un document XML.

Espère que cela aide... ne sais pas si c'est ce que vous cherchez.

Donc, vous êtes uniquement intéressé par la fusion de la "résultats" éléments? Tout le reste est ignoré? Le fait que input0 a un <info type=""/> et input1 a un <info type="b"/> et le résultat attendu a un <info type=""/> semble le suggérer.

Si vous n'êtes pas inquiet au sujet de mise à l'échelle et vous voulez résoudre ce problème rapidement, alors je suggère la rédaction d'un problème spécifique à la partie du code qui utilise une simple bibliothèque comme JDOM à considérer les entrées et écrire le résultat de sortie.

Tentative d'écriture d'un outil générique qui a été "intelligent" de la assez pour gérer l'ensemble de la possible fusion des cas, il serait assez de temps que vous avez à exposer une possibilité de configuration pour définir les règles de combinaison. Si vous savez exactement ce que vos données vont ressembler et vous savez exactement comment la fusion doit être exécutée alors j'imagine que votre algorithme à pied chaque entrée XML et d'écrire sur une seule sortie XML.

Avez-vous considéré comme juste, pas la peine avec l'analyse du XML "correctement" et traiter les fichiers que les grandes chaînes longues et à l'aide ennuyeux vieux trucs tels que des cartes de hachage et des expressions régulières...? Cela pourrait être l'un de ces cas où la fantaisie des acronymes avec X dans leur juste faire le travail fiddlier qu'il doit être.

Évidemment, cela ne dépendre un peu de la quantité de données que vous avez réellement besoin d'analyser tout en faisant de la fusion. Mais par le son des choses, la réponse n'est pas beaucoup.