如何将 XML 文档拆分为三份（或者更好的是，n 份）？

Question

我想使用我熟悉的语言 - Java、C#、Ruby、PHP、C/C++，尽管任何语言或伪代码的示例都非常受欢迎。

将大型 XML 文档拆分为仍然有效的 XML 的较小部分的最佳方法是什么？出于我的目的，我需要将它们分成大约三分之一或四分之一，但为了提供示例，将它们分成 n 个部分会很好。

Answer 1

当然，您始终可以提取顶级元素（这是否是您想要的粒度取决于您）。在 C# 中，您可以使用 XmlDocument 类。例如，如果您的 XML 文件如下所示：

<Document>
  <Piece>
     Some text
  </Piece>
  <Piece>
     Some other text
  </Piece>
</Document>

然后你可以使用这样的代码来提取所有的片段：

XmlDocument doc = new XmlDocument();
doc.Load("<path to xml file>");
XmlNodeList nl = doc.GetElementsByTagName("Piece");
foreach (XmlNode n in nl)
{
    // Do something with each Piece node
}

获得节点后，您可以在代码中对它们执行某些操作，或者可以将节点的整个文本传输到其自己的 XML 文档中，并对其进行操作，就像它是一个独立的 XML 片段一样（包括保存它）返回磁盘等）。

Answer 2

使用 DOM 解析 XML 文档无法扩展。

这 格罗维-script 使用 StAX（XML 流式 API）在顶级元素之间分割 XML 文档（与根文档的第一个子元素共享相同的 QName）。它速度非常快，可以处理任意大型文档，并且当您想要将大型批处理文件拆分为较小的部分时非常有用。

需要 Java 6 上的 Groovy 或 StAX API 和实现，例如 伍德斯托克斯 在类路径中

import javax.xml.stream.*

pieces = 5
input = "input.xml"
output = "output_%04d.xml"
eventFactory = XMLEventFactory.newInstance()
fileNumber = elementCount = 0

def createEventReader() {
    reader = XMLInputFactory.newInstance().createXMLEventReader(new FileInputStream(input))
    start = reader.next()
    root = reader.nextTag()
    firstChild = reader.nextTag()
    return reader
}

def createNextEventWriter () {
    println "Writing to '${filename = String.format(output, ++fileNumber)}'"
    writer = XMLOutputFactory.newInstance().createXMLEventWriter(new FileOutputStream(filename), start.characterEncodingScheme)
    writer.add(start)
    writer.add(root)
    return writer
}

elements = createEventReader().findAll { it.startElement && it.name == firstChild.name }.size()
println "Splitting ${elements} <${firstChild.name.localPart}> elements into ${pieces} pieces"
chunkSize = elements / pieces
writer = createNextEventWriter()
writer.add(firstChild)
createEventReader().each { 
    if (it.startElement && it.name == firstChild.name) {
        if (++elementCount > chunkSize) {
            writer.add(eventFactory.createEndDocument())
            writer.flush()
            writer = createNextEventWriter()
            elementCount = 0
        }
    }
    writer.add(it)
}
writer.flush()

Answer 3

正如 DannySmurf 在这里提到的，这一切都与 xml 文档的结构有关。
如果只有两个巨大的“顶级”标签，则很难以一种既可以将其合并在一起又可以将其作为有效 xml 逐段读取的方式进行拆分。

给定一个包含许多单独部分的文档，例如 DannySmurfs 示例中的部分，它应该相当容易。
伪 C# 中的一些粗略代码：

int nrOfPieces = 5;
XmlDocument xmlOriginal = some input parameter..

// construct the list we need, and fill it with XmlDocuments..
var xmlList = new List<XmlDocument>();
for (int i = 0; i < nrOfPieces ; i++)
{
    var xmlDoc = new XmlDocument();
    xmlDoc.ChildNodes.Add(new XmlNode(xmlOriginal.FistNode.Name));
    xmlList.Add(xmlDoc);
}

var nodeList = xmlOriginal.GetElementsByTagName("Piece")M
// Copy the nodes from the original into the pieces..
for (int i = 0; i < nodeList .Count; i++)
{
    var xmlDoc = xmlList[i % nrOfPieces];
    var nodeToCopy = nodeList[i].Clone();
    xmlDoc.FirstNode.ChildNodes.Add(nodeToCopy);
}

这应该为您提供 n 个具有正确 xml 的文档，并可以将它们合并在一起。
但同样，这取决于 xml 文件。

Answer 4

这更多的是评论而不是答案，但不会：

XmlDocument doc = new XmlDocument();
doc.Load("path");

一次读取整个文件？只是觉得我应该提出这一点，因为从托马斯的问题来看，他担心读取大文件并希望分解该过程。

Answer 5

它会立即读取整个文件。不过，根据我的经验，如果您只是读取文件，进行一些处理（即分解它），然后继续您的工作，则 XmlDocument 将很快经历它的创建/读取/收集周期，以至于这可能并不重要。

当然，这取决于“大”文件是什么。如果它是一个 30 MB 的 XML 文件（我认为对于 XML 文件来说很大），那么它可能不会有任何区别。如果它是 500 MB XML 文件，则在没有大量 RAM 的系统上使用 XmlDocument 将变得极其成问题（但是，在这种情况下，我认为使用 XmlReader 手动选取文件的时间会更重要）障碍）。

Answer 6

不确定您正在执行什么类型的处理，但对于非常大的 XML，我一直喜欢基于事件的处理。也许是我的 Java 背景，但我真的很喜欢 SAX。您需要进行自己的状态管理，但是一旦您克服了这一点，它就是一种非常有效的解析 XML 的方法。

http://saxdotnet.sourceforge.net/

Answer 7

在这一点上我将同意 youphoric。对于非常大的文件，SAX（或任何其他流解析器）将对处理有很大帮助。使用 DOM，您可以只收集顶级节点，但您仍然必须解析整个文档才能做到这一点...使用流式解析器和基于事件的处理可以让您“跳过”您不感兴趣的节点；使处理速度更快。

Answer 8

如果你对 Perl 不完全过敏，那么 XML::树枝 附带一个名为 xml_split 它可以分割文档，生成格式良好的 XML 部分。您可以按大小或 XPath 表达式在树的级别上进行拆分。

Answer 9

您似乎正在使用 C# 和 .NET 3.5。我遇到过一些帖子，建议使用 XmlReader 在文件流上使用产量类型的算法。

这里有几篇博客文章可以帮助您开始这条道路：

• 使用 Linq to SQL 进行流式处理第 1 部分
• 使用 Linq To SQL 进行流式处理第 2 部分

Answer 10

我做了一个 YouTube 视频展示 如何分割XML文件 和 福克斯 （免费的 XML 编辑器来自 第一个对象）无论输入和输出文件的大小如何，仅使用少量内存。

此 CMarkup XML 读取器（拉式解析器）和 XML 写入器解决方案的内存使用量取决于从输入文件单独传输到输出文件的子文档的大小，或 16 KB 的最小块大小。

split()
{
  CMarkup xmlInput, xmlOutput;
  xmlInput.Open( "50MB.xml", MDF_READFILE );
  int nObjectCount = 0, nFileCount = 0;
  while ( xmlInput.FindElem("//ACT") )
  {
    if ( nObjectCount == 0 )
    {
      ++nFileCount;
      xmlOutput.Open( "piece" + nFileCount + ".xml", MDF_WRITEFILE );
      xmlOutput.AddElem( "root" );
      xmlOutput.IntoElem();
    }
    xmlOutput.AddSubDoc( xmlInput.GetSubDoc() );
    ++nObjectCount;
    if ( nObjectCount == 5 )
    {
      xmlOutput.Close();
      nObjectCount = 0;
    }
  }
  if ( nObjectCount )
    xmlOutput.Close();
  xmlInput.Close();
  return nFileCount;
}