Méthodes d'assistance pour extraire du contenu dans Aspose.Words pour Java
Introduction aux méthodes d’assistance pour extraire du contenu dans Aspose.Words pour Java
Aspose.Words for Java est une bibliothèque puissante qui permet aux développeurs de travailler avec des documents Word par programme. Une tâche courante lorsque l’on travaille avec des documents Word consiste à en extraire le contenu. Dans cet article, nous explorerons quelques méthodes d’assistance pour extraire efficacement du contenu à l’aide d’Aspose.Words pour Java.
Conditions préalables
Avant de plonger dans les exemples de code, assurez-vous que Aspose.Words for Java est installé et configuré dans votre projet Java. Vous pouvez le télécharger depuisici.
Méthode d’assistance 1 : extraire des paragraphes par style
public static ArrayList<Paragraph> paragraphsByStyleName(Document doc, String styleName) {
// Créez un tableau pour collecter les paragraphes du style spécifié.
ArrayList<Paragraph> paragraphsWithStyle = new ArrayList<Paragraph>();
NodeCollection paragraphs = doc.getChildNodes(NodeType.PARAGRAPH, true);
// Parcourez tous les paragraphes pour trouver ceux avec le style spécifié.
for (Paragraph paragraph : (Iterable<Paragraph>) paragraphs) {
if (paragraph.getParagraphFormat().getStyle().getName().equals(styleName))
paragraphsWithStyle.add(paragraph);
}
return paragraphsWithStyle;
}
Vous pouvez utiliser cette méthode pour extraire des paragraphes ayant un style spécifique dans votre document Word. Ceci est utile lorsque vous souhaitez extraire du contenu avec un formatage particulier, tel que des titres ou des guillemets.
Méthode d’assistance 2 : extraire du contenu par nœuds
public static ArrayList<Node> extractContentBetweenNodes(Node startNode, Node endNode, boolean isInclusive) {
// Tout d’abord, vérifiez que les nœuds passés à cette méthode sont valides pour l’utilisation.
verifyParameterNodes(startNode, endNode);
// Créez une liste pour stocker les nœuds extraits.
ArrayList<Node> nodes = new ArrayList<Node>();
// Si l'un des marqueurs fait partie d'un commentaire, y compris le commentaire lui-même, nous devons déplacer le pointeur
// transmettre au nœud de commentaire trouvé après le nœud CommentRangeEnd.
if (endNode.getNodeType() == NodeType.COMMENT_RANGE_END && isInclusive) {
Node node = findNextNode(NodeType.COMMENT, endNode.getNextSibling());
if (node != null)
endNode = node;
}
// Conservez un enregistrement des nœuds d'origine transmis à cette méthode pour diviser les nœuds marqueurs si nécessaire.
Node originalStartNode = startNode;
Node originalEndNode = endNode;
//Extrayez le contenu en fonction des nœuds au niveau du bloc (paragraphes et tableaux). Parcourez les nœuds parents pour les trouver.
// Nous diviserons le contenu du premier et du dernier nœud, selon que les nœuds marqueurs sont en ligne ou non.
startNode = getAncestorInBody(startNode);
endNode = getAncestorInBody(endNode);
boolean isExtracting = true;
boolean isStartingNode = true;
// Le nœud actuel que nous extrayons du document.
Node currNode = startNode;
// Commencez à extraire le contenu. Traitez tous les nœuds au niveau du bloc et divisez spécifiquement le premier
// et les derniers nœuds si nécessaire afin que le formatage des paragraphes soit conservé.
// Cette méthode est un peu plus compliquée qu'un extracteur classique car nous devons prendre en compte
// dans l'extraction à l'aide de nœuds en ligne, de champs, de signets, etc., pour le rendre utile.
while (isExtracting) {
// Clonez le nœud actuel et ses enfants pour obtenir une copie.
Node cloneNode = currNode.deepClone(true);
boolean isEndingNode = currNode.equals(endNode);
if (isStartingNode || isEndingNode) {
// Nous devons traiter chaque marqueur séparément, alors transmettez-le plutôt à une méthode distincte.
// La fin doit être traitée en premier pour conserver les index des nœuds.
if (isEndingNode) {
// !isStartingNode : n'ajoutez pas le nœud deux fois si les marqueurs sont le même nœud.
processMarker(cloneNode, nodes, originalEndNode, currNode, isInclusive,
false, !isStartingNode, false);
isExtracting = false;
}
//Le conditionnel doit être séparé car les marqueurs de début et de fin au niveau du bloc peuvent être le même nœud.
if (isStartingNode) {
processMarker(cloneNode, nodes, originalStartNode, currNode, isInclusive,
true, true, false);
isStartingNode = false;
}
} else
// Le nœud n'est pas un marqueur de début ou de fin, ajoutez simplement la copie à la liste.
nodes.add(cloneNode);
// Passez au nœud suivant et extrayez-le. Si le nœud suivant est nul,
// le reste du contenu se trouve dans une section différente.
if (currNode.getNextSibling() == null && isExtracting) {
// Passez à la section suivante.
Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
currNode = nextSection.getBody().getFirstChild();
} else {
// Passez au nœud suivant dans le corps.
currNode = currNode.getNextSibling();
}
}
// Pour la compatibilité avec le mode avec signets en ligne, ajoutez le paragraphe suivant (vide).
if (isInclusive && originalEndNode == endNode && !originalEndNode.isComposite())
includeNextParagraph(endNode, nodes);
// Renvoie les nœuds entre les marqueurs de nœuds.
return nodes;
}
Cette méthode vous permet d’extraire du contenu entre deux nœuds spécifiés, qu’il s’agisse de paragraphes, de tableaux ou de tout autre élément de niveau bloc. Il gère divers scénarios, notamment les marqueurs en ligne, les champs et les signets.
Méthode d’assistance 3 : génération d’un nouveau document
public static Document generateDocument(Document srcDoc, ArrayList<Node> nodes) throws Exception {
Document dstDoc = new Document();
// Supprimez le premier paragraphe du document vide.
dstDoc.getFirstSection().getBody().removeAllChildren();
// Importez chaque nœud de la liste dans le nouveau document. Conservez le formatage d'origine du nœud.
NodeImporter importer = new NodeImporter(srcDoc, dstDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING);
for (Node node : nodes) {
Node importNode = importer.importNode(node, true);
dstDoc.getFirstSection().getBody().appendChild(importNode);
}
return dstDoc;
}
Cette méthode permet de générer un nouveau document en important une liste de nœuds depuis le document source. Il conserve le formatage d’origine des nœuds, ce qui le rend utile pour créer de nouveaux documents avec un contenu spécifique.
Conclusion
L’extraction de contenu à partir de documents Word peut constituer une partie cruciale de nombreuses tâches de traitement de documents. Aspose.Words for Java fournit de puissantes méthodes d’assistance qui simplifient ce processus. Que vous ayez besoin d’extraire des paragraphes par style, du contenu entre nœuds ou de générer de nouveaux documents, ces méthodes vous aideront à travailler efficacement avec des documents Word dans vos applications Java.
FAQ
Comment puis-je installer Aspose.Words pour Java ?
Pour installer Aspose.Words pour Java, vous pouvez le télécharger depuis le site Web d’Aspose. Visiteici pour obtenir la dernière version.
Puis-je extraire le contenu de sections spécifiques d’un document Word ?
Oui, vous pouvez extraire le contenu de sections spécifiques d’un document Word en utilisant les méthodes mentionnées dans cet article. Spécifiez simplement les nœuds de début et de fin qui définissent la section que vous souhaitez extraire.
Aspose.Words pour Java est-il compatible avec Java 11 ?
Oui, Aspose.Words for Java est compatible avec Java 11 et les versions supérieures. Vous pouvez l’utiliser dans vos applications Java sans aucun problème.
Puis-je personnaliser le formatage du contenu extrait ?
Oui, vous pouvez personnaliser la mise en forme du contenu extrait en modifiant les nœuds importés dans le document généré. Aspose.Words for Java fournit des options de formatage étendues pour répondre à vos besoins.
Où puis-je trouver plus de documentation et d’exemples pour Aspose.Words pour Java ?
Vous pouvez trouver une documentation complète et des exemples pour Aspose.Words pour Java sur le site Web Aspose. Visitehttps://reference.aspose.com/words/java/ pour une documentation et des ressources détaillées.
