L'accélération de xpath

j'ai une inscription de 1000 document dont le format est quelque chose comme

<Example>
     <Entry>
          <n1></n1>
          <n2></n2>
      </Entry>
      <Entry>
          <n1></n1>
          <n2></n2>
      </Entry>
      <!--and so on-->

Il y a plus de 1000 Entrée nœuds ici. Je suis en train d'écrire un programme Java qui, fondamentalement, obtient tout le nœud, un par un et faire un peu d'analyse sur chaque nœud. Mais le problème est que le temps de récupération des nœuds augmente avec son pas de. Par exemple, il prend 78 milliseconde pour récupérer le premier nœud de 100 ms pour récupérer la deuxième, et c'est en constante augmentation. Et pour récupérer les 999 nœud, il prend plus de 5 secondes. C'est extrêmement lent. Nous serait de brancher le présent code, aux fichiers XML, qui ont même plus de 1000 entrées. Certains, comme des millions de personnes. Le temps total pour analyser l'ensemble du document est supérieure à 5 minutes.

Je suis en utilisant ce code simple de la traverser. Ici nxp est ma propre classe, qui a toutes les méthodes pour obtenir des nœuds de xpath.

nxp.fromXpathToNode("/Example/Entry" + "[" + i  + "]", doc);    

et doc est le document pour le fichier. i est le pas de nœud à récupérer.

Aussi, quand j'ai essayer quelque chose comme cela

List<Node> nl = nxp.fromXpathToNodes("/Example/Entry",doc);  
      content = nl.get(i);    

Je suis face au même problème.

Quelqu'un a des solution sur la façon d'accélérer le tretirival des nœuds, donc il faut la même quantité de temps pour obtenir le 1er noeud ainsi que les 1000 nœud dans le fichier XML.

Merci


voici le code pour xpathtonode.

public Node fromXpathToNode(String expression, Node context)  
{  
    try  
    {  
        return (Node)this.getCachedExpression(expression).evaluate(context, XPathConstants.NODE);  
    }  
    catch (Exception cause)  
    {  
        throw new RuntimeException(cause);  
    }  
}  

et voici le code pour fromxpathtonodes.

public List<Node> fromXpathToNodes(String expression, Node context)  
{  
    List<Node> nodes = new ArrayList<Node>();  
    NodeList results = null;  

    try  
    {  
        results = (NodeList)this.getCachedExpression(expression).evaluate(context, XPathConstants.NODESET);  

        for (int index = 0; index < results.getLength(); index++)  
        {  
            nodes.add(results.item(index));  
        }  
    }  
    catch (Exception cause)  
    {  
        throw new RuntimeException(cause);  
    }  

    return nodes;  
}  

et voici le départ

public class NativeXpathEngine implémente XpathEngine

{

finale privée XPathFactory usine;

private final XPath engine;  

/**
 * Cache for previously compiled XPath expressions. {@link XPathExpression#hashCode()}
 * is not reliable or consistent so use the textual representation instead.
 */  
private final Map<String, XPathExpression> cachedExpressions;  

public NativeXpathEngine()  
{
    super();  

    this.factory = XPathFactory.newInstance();  
    this.engine = factory.newXPath();  
    this.cachedExpressions = new HashMap<String, XPathExpression>();  
}  
  • Le code de la fromXpathToNode et fromXpathToNodes semble tout à fait pertinente ici. Pouvez-vous fournir ce code?
  • besoin de consulter votre code de chargement de la doc.
  • Si vous allez frapper à chaque entrée, pourquoi utiliser XPath?
  • que voulez-vous dire? À quoi alors?
  • Je pense qu'il veut dire que, dans ce cas, pourquoi ne pas simplement itérer directement sur le nœud DOM enfant listes.
InformationsquelleAutor jon | 2010-03-02