Méthodes d'aide pour l'extraction de contenu dans Aspose.Words pour Java
Introduction aux méthodes d’assistance pour l’extraction de contenu dans Aspose.Words pour Java
Aspose.Words pour Java est une bibliothèque puissante qui permet aux développeurs de travailler avec des documents Word par programmation. Une tâche courante lorsque l’on travaille avec des documents Word consiste à en extraire le contenu. Dans cet article, nous allons explorer certaines méthodes d’aide pour extraire efficacement du contenu à l’aide d’Aspose.Words pour Java.
Prérequis
Avant de nous 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 à partir deici.
Méthode d’aide 1 : Extraction de 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 qui correspondent au 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. Cela est utile lorsque vous souhaitez extraire du contenu avec une mise en forme particulière, comme des titres ou des citations en bloc.
Méthode d’aide 2 : Extraction de 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 être utilisés.
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;
//Extraire le contenu en fonction des nœuds au niveau des blocs (paragraphes et tableaux). Parcourez les nœuds parents pour les trouver.
// Nous allons diviser 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 lorsque cela est 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
// en extrayant à 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;
}
//Les conditions doivent être séparées 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) {
// Passer à la section suivante.
Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
currNode = nextSection.getBody().getFirstChild();
} else {
// Passer 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œud.
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. Elle gère divers scénarios, notamment les marqueurs en ligne, les champs et les signets.
Méthode d’aide 3 : Générer 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 la mise en forme 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 à partir du document source. Elle conserve la mise en forme d’origine des nœuds, ce qui la rend utile pour créer de nouveaux documents avec un contenu spécifique.
Conclusion
L’extraction de contenu à partir de documents Word peut être une partie cruciale de nombreuses tâches de traitement de documents. Aspose.Words pour Java fournit des méthodes d’assistance puissantes qui simplifient ce processus. Que vous ayez besoin d’extraire des paragraphes par style, du contenu entre des 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 à partir du site Web d’Aspose. Visitezici 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 à l’aide des 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 pour 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 pour Java fournit des options de mise en forme étendues pour répondre à vos besoins.
Où puis-je trouver plus de documentation et d’exemples pour Aspose.Words pour Java ?
Vous trouverez une documentation complète et des exemples pour Aspose.Words pour Java sur le site Web d’Aspose. Visitezhttps://reference.aspose.com/words/java/ pour une documentation détaillée et des ressources.
