0

给定以下 XML 实例：

<entities>
    <person><name>Jack</name></person>
    <person><name></name></person>
    <person></person>
</entities>

我正在使用以下代码：（a）遍历人员并（b）获取每个人的姓名：

XPathExpression expr = xpath.compile("/entities/person");
NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
for (int i = 0 ; i < nodes.getLength() ; i++) {
    Node node = nodes.item(i);
    String innerXPath = "name/text()";
    String name  = xpath.compile(innerXPath).evaluate(node);
    System.out.printf("%2d -> name is %s.\n", i, name);
}

上面的代码无法区分第 2 人称（名称为空字符串）和第 3 人称（根本没有 name 元素），只打印：

0 -> name is Jack.
1 -> name is .
2 -> name is .

innerXPath有没有办法使用不同的表达式来区分这两种情况？在这个 SO question中，XPath 方法似乎是返回一个空列表，但我也尝试过：

String innerXPath = "if (name) then name/text() else ()";

...并且输出仍然相同。

innerXPath那么，有没有办法用不同的表达方式来区分这两种情况呢？我的类路径中有 Saxon HE，因此我也可以使用 XPath 2.0 功能。

更新

因此，根据接受的答案，我能做的最好的事情如下：

XPathExpression expr = xpath.compile("/entities/person");                                                                                                                                                                                 
NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);                                                                                                                                                                   
for (int i = 0 ; i < nodes.getLength() ; i++) {                                                                                                                                                                                           
    Node node = nodes.item(i);                                                                                                                                                                                                            
    String innerXPath = "name";                                                                                                                                                                                                           
    NodeList names = (NodeList) xpath.compile(innerXPath).evaluate(node, XPathConstants.NODESET);                                                                                                                                         
    String nameValue = null;                                                                                                                                                                                                              
    if (names.getLength()>1) throw new RuntimeException("impossible");                                                                                                                                                                    
    if (names.getLength()==1)                                                                                                                                                                                                             
        nameValue = names.item(0).getFirstChild()==null?"":names.item(0).getFirstChild().getNodeValue();                                                                                                                                  
    System.out.printf("%2d -> name is [%s]\n", i, nameValue);                                                                                                                                                                             
}

上面的代码打印：

0 -> name is [Jack]
1 -> name is []
2 -> name is [null]

在我看来，这不是很令人满意，因为逻辑在XPath和Java代码中都分布，并且限制了XPath作为宿主语言和 API 不可知符号的有用性。我的特定用例是将 XPath 集合保存在属性文件中并在运行时评估它们，以便获得我需要的信息，而无需任何特别的额外处理。显然这是不可能的。

4

2 回答 2

3

基于 XPath 1.0 的 JAXP API 在这里非常有限。我的直觉是返回 Name 元素（作为 NodeList）。所以所需的 XPath 表达式只是“名称”。那么案例 1 和案例 2 将返回一个长度为 1 的节点列表，而案例 3 将返回一个长度为 0 的节点列表。案例 1 和案例 2 可以在应用程序中通过获取节点的值并测试它是否为零来轻松区分 -长度。

无论如何，最好避免使用 /text()，因为它会导致您的查询对 XML 中存在的注释敏感。

于 2013-06-30T14:03:37.233 回答
0

作为 Saxon XSLT 的长期用户，我很高兴再次发现我喜欢 Michael Kay 的推荐。一般来说，我喜欢为查询返回一个集合的模式，即使对于那些预计最多只返回一个实例的查询也是如此。

我不喜欢做的是必须打开一个捆绑的界面来尝试解决特定需求，然后发现必须重新实现原始界面处理的大部分内容。

因此，这是一种使用 Michael 建议的方法，同时避免了必须重新实现该线程其他评论中推荐的节点到字符串转换的成本。

@Nonnull
public Optional<String> findString( @Nonnull final String expression )
{
    try
    {
        // for XpathConstants.STRING XPath returns an empty string for both values of no length
        // and for elements that are not present.

        // therefore, ask for a NODESET and then retrieve the first Node if any

        final FluentIterable<Node> matches = 
                IterableNodeList.from( (NodeList) xpath.evaluate( expression, node, XPathConstants.NODESET ) );

        if ( matches.isEmpty() )
        {
            return Optional.absent();
        }

        final Node firstNode = matches.first().get();

        // now let XPath process a known-to-exist Node to retrieve its String value         
        return Optional.fromNullable( (String) xpath.evaluate( ".", firstNode, XPathConstants.STRING ) );
    }
    catch ( XPathExpressionException xee )
    {
        return Optional.absent();
    }
}

在这里，第二次调用 XPath.evaluate 以执行通常将第一个找到的 Node 转换为请求的 String 值的任何操作。如果没有这个，重新实现可能会产生与在相同源节点和相同表达式上直接调用 XPathConstant.STRING 不同的结果。

当然，这段代码使用 Guava Optional 和 FluentIterable 使意图更加明确。如果您不想要 Guava，请使用 Java 8 或使用 null 和 NodeList 自己的集合方法重构实现。

于 2016-10-14T19:10:02.070 回答