如何使用 Microsoft xslt 1.0 有效地稍微修改大型 xml 文档答案

【问题标题】：How to effeciently modify a large xml document slightly with Microsoft xslt 1.0如何使用 Microsoft xslt 1.0 有效地稍微修改大型 xml 文档
【发布时间】：2013-10-09 16:17:44
【问题描述】：

我想转换这个xml：

<Root>
  <Result>
    <Message>
      <Header>
        <!-- Hundreds of child nodes -->        
      </Header>
      <Body>
        <Node1>
          <!-- Hundreds of child nodes -->
          <Node2>
            <!-- Hundreds of child nodes -->
            <Node3>
              <!-- Hundreds of child nodes -->
              <NodeX>value 1 to be changed</NodeX>
              <!-- Hundreds of child nodes -->
              <Node4>
                <!-- Hundreds of child nodes -->
                <NodeY>value 2 to be changed</NodeY>
              </Node4>
            </Node3>
          </Node2>          
        </Node1>        
      </Body>
      <RealValuesRoot>
        <!-- These two nodes -->
        <Value ID="1">this value must replace the value of Node X</Value>
        <Value ID="2">this value must replace the value of Node Y</Value>
      </RealValuesRoot>
    </Message>
  </Result>
  <!-- Hundreds to thousands of similar MessageRoot nodes -->
</Root>

进入这个xml：

<Root>
  <Result>
    <Message>
      <Header>
        <!-- Hundreds of child nodes -->
      </Header>
      <Body>
        <Node1>
          <!-- Hundreds of child nodes -->
          <Node2>
            <!-- Hundreds of child nodes -->
            <Node3>
              <!-- Hundreds of child nodes -->
              <NodeX>this value must replace the value of Node X</NodeX>
              <!-- Hundreds of child nodes -->
              <Node4>
                <!-- Hundreds of child nodes -->
                <NodeY>this value must replace the value of Node Y</NodeY>
              </Node4>
            </Node3>
          </Node2>
        </Node1>
      </Body>
    </Message>
  </Result>
  <!-- Hundreds to thousands of similar MessageRoot nodes -->
</Root>

输出几乎与输入相同，除了以下更改：

X 和 Y 节点值必须替换为 /RealValuesRoot/Value 节点的值。
必须从输出中删除 /RealValuesRoot 节点。
xml 的其余部分在输出中必须保持不变。

“值”节点具有唯一 ID，表示消息正文中的唯一 xpath，例如ID 1 引用 xpath /Message/Body/Node1/Node2/Node3/NodeX。

我必须用微软的xslt 1.0版！！

我已经有了一个可以正常工作的 xslt，可以做任何我想做的事情，但我对性能并不满意！

我的 xslt 工作如下：

我创建了一个全局字符串变量，其作用类似于键值对，类似于：1:xpath1_2:xpath2_ … _N:xpathN。此变量将“Value”节点的 ID 与消息正文中需要替换的节点相关联。
xslt 从根节点开始递归迭代输入 xml。
我计算当前节点的 xpath，然后执行以下操作之一：
1. 如果当前 xpath 与全局列表中的 xpath 之一完全匹配，则我将其值替换为相应“Value”节点的值并继续迭代。
2. 如果当前 xpath 引用“RealValuesRoot”节点，那么我会忽略该节点（不要将其复制到输出中）并继续递归迭代。
3. 如果当前 xpath 不存在于全局 ID-xpath 字符串中，则我将完整节点复制到输出并继续迭代。（例如在 /Message/Header 节点中发生这种情况，该节点永远不会包含任何需要替换的节点）
4. 如果当前 xpath 部分匹配全局列表中的 xpath 之一，那么我只需继续递归迭代，直到达到上述 3 种情况之一。

如前所述，我的 xslt 工作正常，但我想尽可能提高性能，请随时提出一个全新的 xslt 逻辑！欢迎您的意见和建议！

【问题讨论】：

他们真的叫<Node1>、<Node2>等吗？
当然不是 :-) 它们只是用来表达层次结构
嗯，这会影响解决方案。它们到底是怎么称呼的？
+1 用于发布完整且语法有效的输入和所需的输出，并准确描述您的问题，顺便说一句。大多数人都不做这两件事。
我的例子中的 X 和 Y 节点可以是 FirstName 和 LastName，其余节点可以是任何东西。

标签： xml xslt-1.0

【解决方案1】：

我计算当前节点的 xpath，然后执行以下操作之一...

这可能是您的效率低下 - 如果您每次可能正在查看 O(N²) 算法时都重新计算返回根的路径。在没有看到您的 XSLT 的情况下，这是相当投机的，但您可以通过使用参数将当前路径向下传递递归来稍微调整一下 - 如果您的主要算法基于标准标识模板

<xsl:template match="@*|node()">
  <xsl:copy><xsl:apply-templates select="@*|node()" /></xsl:copy>
</xsl:template>

然后将其更改为类似

<xsl:template match="@*|node()">
  <xsl:param name="curPath" />
  <xsl:copy>
    <xsl:apply-templates select="@*|node()">
      <xsl:with-param name="curPath" select="concat($curPath, '/', name())" />
    </xsl:apply-templates>
  </xsl:copy>
</xsl:template>

或任何您的逻辑用于构建您需要的路径。现在，在您要按摩的节点的特定模板中，您已经有了到其父节点的路径，您不必每次都一直走到根节点。

您可能需要添加一个

<xsl:template match="/">
  <xsl:apply-templates />
</xsl:template>

所以$curPath 前面不会出现双斜线

xpath 在 xslt 中被硬编码为全局变量中的字符串

如果您在 XML 结构中表示此映射而不是字符串，那么您可以使用 key 机制来加快查找速度：

<xsl:variable name="rtfLookupTable">
  <lookuptable>
    <val xpath="/first/xpath/expression" id="1" />
    <val xpath="/second/xpath/expression" id="2" />
    <!-- ... -->
  </lookuptable>
</xsl:variable>

<xsl:variable name="lookupTable" select="msxsl:node-set($rtfLookupTable)" />

<xsl:key name="valByXpath" match="val" use="@xpath" />

（将xmlns:msxsl="urn:schemas-microsoft-com:xslt" 添加到您的xsl:stylesheet）。或者，如果您想避免使用 node-set 扩展函数，则可以使用替代定义

<xsl:variable name="lookupTable" select="document('')//xsl:variable[name='rtfLookupTable']" />

通过将样式表本身视为纯 XML 文档来工作。

跨多个文档的键在 XSLT 1.0 中有点繁琐，但可以做到，本质上您必须在调用键函数之前切换当前上下文以指向 $lookupTable，因此您需要将当前上下文保存在变量让您稍后参考：

<xsl:template match="text()">
  <xsl:param name="curPath" />

  <xsl:variable name="dot" select="." />
  <xsl:variable name="slash" select="/" />

  <xsl:for-each select="$lookupTable">
    <xsl:variable name="valId" select="key('valByXpath', $curPath)/@id" />
    <xsl:choose>
      <xsl:when test="$valId">
        <xsl:value-of select="$slash//Value[@id = $valId]" />
        <!-- or however you extract the right Value -->
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="$dot" />
      </xsl:otherwise>
    </xsl:choose>
  </xsl:for-each>
</xsl:template>

实际上，为什么不让 XSLT 引擎为您完成繁重的工作。而不是将您的映射表示为字符串

/path/to/node1_1:/path/to/node2_2

直接将其表示为模板

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <!-- copy everything as-is apart from exceptions below -->
  <xsl:template match="@*|node()">
    <xsl:copy><xsl:apply-templates select="@*|node()" /></xsl:copy>
  </xsl:template>

  <!-- delete the RealValuesRoot -->
  <xsl:template match="RealValuesRoot" />

  <xsl:template match="/path/to/node1">
    <xsl:copy><xsl:value-of select="//Value[id='1']" /></xsl:copy>
  </xsl:template>
  <xsl:template match="/path/to/node2">
    <xsl:copy><xsl:value-of select="//Value[id='2']" /></xsl:copy>
  </xsl:template>
</xsl:stylesheet>

我相信您可以看到如何使用某种模板机制（甚至可以是另一个 XSLT）从现有映射轻松地自动生成特定模板。

【讨论】：

您构建 xpath 的想法很棒！ JFYI，在我的情况下，性能杀手不是 xpath 构建，而是 concat() 函数需要在一个巨大的字符串中查找 xpath 字符串>
@Siraf XPath 是从哪里来的？首先，您如何构建“全局字符串变量”？文档中真正的Value 元素是否将XPath 作为属性，或者ID->XPath 映射是否保存在外部文件中？我正在尝试确定是否有任何方法可以利用 key 机制来加速这些查找。
我喜欢使用模板构建 xpath 的想法。 JFYI：我的性能瓶颈不是 xpath 连接。
xpath 在 xslt 中被硬编码为全局变量中的字符串。 “”节点的 ID 与全局 id-xpath 字符串中的 xpath 相关> 目前 33% 的性能浪费在包含字符串函数中，该函数在全局中查找当前节点的 xpath大（查看 KB）xpath 字符串
@Siraf 我已经概述了一种可以使用密钥攻击它的方法。

【解决方案2】：

最有效的方法是使用 XSL 密钥。

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <!-- a key that indexes real values by their IDs -->
  <xsl:key name="kRealVal" match="RealValuesRoot/Value" use="@ID" />

  <!-- the identity template to copy everything -->    
  <xsl:template match="node() | @*">
    <xsl:copy>
      <xsl:apply-templates select="node() | @*" />
    </xsl:copy>
  </xsl:template>

  <!-- ...except elements named <NodeX> -->
  <xsl:template match="*[starts-with(name(), 'Node')]">
    <xsl:variable name="myID" select="substring-after(name(), 'Node')" />
    <xsl:variable name="myRealVal" select="key('kRealVal', $myID)" />

    <xsl:copy>
      <xsl:copy-of select="@*" />
      <xsl:choose>
        <xsl:when test="$myRealVal">
          <xsl:value-of select="$myRealVal" />
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="node()" />
        </xsl:otherwise>
      </xsl:choose>
    </xsl:copy>
  </xsl:template>

  <!-- the <RealValuesRoot> element can be trashed -->
  <xsl:template match="RealValuesRoot" />
</xsl:stylesheet>

这是此解决方案的实时预览：http://www.xmlplayground.com/R78v0n

这是一个概念验证解决方案，它使用 Microsoft 脚本扩展来完成繁重的工作：

<xsl:stylesheet
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:msxsl="urn:schemas-microsoft-com:xslt"
  xmlns:script="http://tempuri.org/script"
>  
  <msxsl:script language="JScript" implements-prefix="script">
    var index = {};

    function getNode(context, xpath) {
      var theContext = context[0],
          theXpath = xpath[0].text,
          result;

      try {
        result = theContext.selectSingleNode(theXpath)
      } catch (ex) {
        // xpath is invalid. we could also just throw here
        // but lets return the empty node set.
        result = theContext.selectSingleNode("*[false()]");
      }
      return result;
    }
    function buildIndex(id, node) {
      var theNode = node[0];

      if (id) index[id] = theNode;
      return "";
    }
    function getValue(id) {
      return (id in index) ? index[id] : '';
    }
  </msxsl:script>


  <!-- this is the boilerplate to evaluate all the XPaths -->
  <xsl:variable name="temp">
    <xsl:for-each select="/root/source/map">
      <xsl:value-of select="script:buildIndex(generate-id(script:getNode(/, @xpath)), .)" />
    </xsl:for-each>
  </xsl:variable>

  <!-- the identity template to get things rolling -->
  <xsl:template match="node() | @*">
    <xsl:copy>
      <xsl:apply-templates select="node() | @*" />
    </xsl:copy>
  </xsl:template>

  <xsl:template match="/">
    <!-- actually evaluate $temp once, so the variable is being calculated -->
    <xsl:value-of select="$temp" />
    <xsl:apply-templates select="node() | @*" />
  </xsl:template> 

  <!-- all <value> nodes do either have a related "actual value" or they are copied as they are -->
  <xsl:template match="value">
    <xsl:copy>
      <xsl:copy-of select="@*" />

      <xsl:variable name="newValue" select="script:getValue(generate-id())" />
      <xsl:choose>
        <xsl:when test="$newValue">
          <xsl:value-of select="$newValue" />
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="node() | @*" />
        </xsl:otherwise>
      </xsl:choose>
    </xsl:copy>
  </xsl:template>

  <!-- the <source> element can be dropped -->
  <xsl:template match="source" />

</xsl:stylesheet>

它会变形

<root>
  <value id="foo">this is to be replaced</value>

  <source>
    <map xpath="/root/value[@id = 'foo']">this is the new value</map>
  </source>
</root>

到

<root>
  <value id="foo">this is the new value</value>
</root>

也许你可以在你的设置中走这条路。

思路是这样的：

迭代您拥有的所有 XPath，使用 .selectSingleNode() 评估它们。
将每个评估结果（理想情况下是一个节点）连同其唯一 ID 作为键值对存储在对象中。这使用 XSLT 的 generate-id() 从节点获取 ID。
现在正常转换输入。对于每个有问题的节点，获取其 ID 并检查该节点是否确实存在“新值”。
如果是，则插入该新值，如果不是，则继续转换。

使用 msxsl.exe 测试成功。

当然，这假设输入具有那些<map xpath="..."> 元素，但那部分并不是真正必要的，并且很容易适应您的实际情况。例如，您可以在 JavaScript 中使用 split() 的一长串 XPath 构建 index 对象。

【讨论】：

感谢您花时间开发解决方案！恐怕您在解决方案中遗漏了一些东西，就我而言，我必须确定其值需要被其 xpath 替换的节点！这是给我的东西，我无法改变！这意味着我必须为每个节点构造 xpath，然后在一个巨大的 xpath-id 查找字符串中查找该 xpath，该字符串被硬编码为 xslt 本身中的全局变量。
天哪。 :D 是的，那么我误解了要求。对我来说，它看起来像是一个简单的映射工作（从这里映射 ID X 到从那里到节点 X）。我会再考虑一下这个问题。如果您 pasted 精简（但活着！）示例供我使用，您会让我的生活更轻松。
感谢您花时间开发解决方案！您的解决方案缺少一些东西，需要替换的节点必须由它们的 xpath 标识，这就是为什么我有一个包含所有 xpath 和 id 对的全局变量，对于每个节点，我必须检查它的 xpath 是否存在于列出与否。使用这个全局 xpath 列表，当列表中不存在其 xpath 时，我通过简单地复制当前节点（带有子节点）将性能提高了一倍。我想知道我的转换是否可以在没有递归迭代的情况下实现？
很抱歉我不能这样做，你知道这是公司数据，希望你能理解。
我明白了。但是你可以用伪造的数据建立一个例子，只是按照相同的原则工作，不是吗？