Hulpmethoden voor het extraheren van inhoud in Aspose.Words voor Java
Inleiding tot hulpmethoden voor het extraheren van inhoud in Aspose.Words voor Java
Aspose.Words voor Java is een krachtige bibliotheek waarmee ontwikkelaars programmatisch met Word-documenten kunnen werken. Een veelvoorkomende taak bij het werken met Word-documenten is het extraheren van content uit deze documenten. In dit artikel verkennen we enkele hulpmethoden voor het efficiënt extraheren van content met Aspose.Words voor Java.
Vereisten
Voordat we in de codevoorbeelden duiken, moet u ervoor zorgen dat u Aspose.Words voor Java hebt geïnstalleerd en ingesteld in uw Java-project. U kunt het downloaden vanhier.
Hulpmethode 1: alinea’s extraheren op stijl
public static ArrayList<Paragraph> paragraphsByStyleName(Document doc, String styleName) {
// Maak een array om alinea's met de opgegeven stijl te verzamelen.
ArrayList<Paragraph> paragraphsWithStyle = new ArrayList<Paragraph>();
NodeCollection paragraphs = doc.getChildNodes(NodeType.PARAGRAPH, true);
// Kijk door alle alinea's om de alinea's met de opgegeven stijl te vinden.
for (Paragraph paragraph : (Iterable<Paragraph>) paragraphs) {
if (paragraph.getParagraphFormat().getStyle().getName().equals(styleName))
paragraphsWithStyle.add(paragraph);
}
return paragraphsWithStyle;
}
U kunt deze methode gebruiken om alinea’s met een specifieke stijl in uw Word-document te extraheren. Dit is handig als u inhoud met een bepaalde opmaak wilt extraheren, zoals koppen of blokcitaten.
Hulpmethode 2: Inhoud extraheren via knooppunten
public static ArrayList<Node> extractContentBetweenNodes(Node startNode, Node endNode, boolean isInclusive) {
// Controleer eerst of de knooppunten die aan deze methode zijn doorgegeven geldig zijn voor gebruik.
verifyParameterNodes(startNode, endNode);
// Maak een lijst om de geëxtraheerde knooppunten op te slaan.
ArrayList<Node> nodes = new ArrayList<Node>();
// Als een van beide markeringen deel uitmaakt van een opmerking, inclusief de opmerking zelf, moeten we de aanwijzer verplaatsen
// doorsturen naar het Comment Node dat zich na het CommentRangeEnd knooppunt bevindt.
if (endNode.getNodeType() == NodeType.COMMENT_RANGE_END && isInclusive) {
Node node = findNextNode(NodeType.COMMENT, endNode.getNextSibling());
if (node != null)
endNode = node;
}
// Houd een overzicht bij van de oorspronkelijke knooppunten die aan deze methode zijn doorgegeven, zodat u indien nodig markerknooppunten kunt splitsen.
Node originalStartNode = startNode;
Node originalEndNode = endNode;
//Haal inhoud op basis van knooppunten op blokniveau (paragrafen en tabellen) op. Doorzoek bovenliggende knooppunten om ze te vinden.
// We splitsen de inhoud van de eerste en laatste nodes, afhankelijk van of de markernodes inline zijn.
startNode = getAncestorInBody(startNode);
endNode = getAncestorInBody(endNode);
boolean isExtracting = true;
boolean isStartingNode = true;
// Het huidige knooppunt dat we uit het document halen.
Node currNode = startNode;
// Begin met het extraheren van content. Verwerk alle nodes op blokniveau en splits specifiek de eerste
// en laatste knooppunten indien nodig, zodat de alineaopmaak behouden blijft.
// Deze methode is iets ingewikkelder dan een gewone extractor, omdat we rekening moeten houden met
// bij het extraheren met behulp van inline knooppunten, velden, bladwijzers, enz., om het bruikbaar te maken.
while (isExtracting) {
// Kloon het huidige knooppunt en de onderliggende knooppunten om een kopie te verkrijgen.
Node cloneNode = currNode.deepClone(true);
boolean isEndingNode = currNode.equals(endNode);
if (isStartingNode || isEndingNode) {
// We moeten elke marker apart verwerken en moeten deze daarom aan een aparte methode doorgeven.
// End moet eerst worden verwerkt om de knooppuntindexen te behouden.
if (isEndingNode) {
// !isStartingNode: voeg het knooppunt niet twee keer toe als de markeringen hetzelfde knooppunt zijn.
processMarker(cloneNode, nodes, originalEndNode, currNode, isInclusive,
false, !isStartingNode, false);
isExtracting = false;
}
//Voorwaardelijk moet apart zijn, omdat de begin- en eindmarkeringen op blokniveau hetzelfde knooppunt kunnen zijn.
if (isStartingNode) {
processMarker(cloneNode, nodes, originalStartNode, currNode, isInclusive,
true, true, false);
isStartingNode = false;
}
} else
// Node is geen begin- of eindmarkering, voeg gewoon de kopie toe aan de lijst.
nodes.add(cloneNode);
// Ga naar het volgende knooppunt en extraheer het. Als het volgende knooppunt null is,
// De rest van de inhoud vindt u in een ander gedeelte.
if (currNode.getNextSibling() == null && isExtracting) {
// Ga naar het volgende gedeelte.
Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
currNode = nextSection.getBody().getFirstChild();
} else {
// Ga naar het volgende knooppunt in de hoofdtekst.
currNode = currNode.getNextSibling();
}
}
// Voeg de volgende alinea (leeg) toe voor compatibiliteit met de modus met inline bladwijzers.
if (isInclusive && originalEndNode == endNode && !originalEndNode.isComposite())
includeNextParagraph(endNode, nodes);
// Plaats de knooppunten tussen de knooppuntmarkeringen terug.
return nodes;
}
Met deze methode kunt u inhoud tussen twee opgegeven knooppunten extraheren, ongeacht of het alinea’s, tabellen of andere elementen op blokniveau zijn. Het behandelt verschillende scenario’s, waaronder inline markers, velden en bladwijzers.
Hulpmethode 3: Een nieuw document genereren
public static Document generateDocument(Document srcDoc, ArrayList<Node> nodes) throws Exception {
Document dstDoc = new Document();
// Verwijder de eerste alinea uit het lege document.
dstDoc.getFirstSection().getBody().removeAllChildren();
// Importeer elk knooppunt uit de lijst in het nieuwe document. Behoud de originele opmaak van het knooppunt.
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;
}
Met deze methode kunt u een nieuw document genereren door een lijst met knooppunten uit het brondocument te importeren. De oorspronkelijke opmaak van de knooppunten blijft behouden, waardoor het handig is voor het maken van nieuwe documenten met specifieke inhoud.
Conclusie
Het extraheren van inhoud uit Word-documenten kan een cruciaal onderdeel zijn van veel documentverwerkingstaken. Aspose.Words voor Java biedt krachtige hulpmethoden die dit proces vereenvoudigen. Of u nu alinea’s wilt extraheren op stijl, inhoud tussen knooppunten of nieuwe documenten wilt genereren, deze methoden helpen u efficiënt te werken met Word-documenten in uw Java-toepassingen.
Veelgestelde vragen
Hoe kan ik Aspose.Words voor Java installeren?
Om Aspose.Words voor Java te installeren, kunt u het downloaden van de Aspose-website. Bezoekhier om de nieuwste versie te krijgen.
Kan ik inhoud uit specifieke secties van een Word-document halen?
Ja, u kunt inhoud uit specifieke secties van een Word-document extraheren met behulp van de methoden die in dit artikel worden genoemd. Geef eenvoudig de start- en eindknooppunten op die de sectie definiëren die u wilt extraheren.
Is Aspose.Words voor Java compatibel met Java 11?
Ja, Aspose.Words voor Java is compatibel met Java 11 en hogere versies. U kunt het zonder problemen gebruiken in uw Java-applicaties.
Kan ik de opmaak van de geëxtraheerde inhoud aanpassen?
Ja, u kunt de opmaak van de geëxtraheerde inhoud aanpassen door de geïmporteerde knooppunten in het gegenereerde document te wijzigen. Aspose.Words voor Java biedt uitgebreide opmaakopties om aan uw behoeften te voldoen.
Waar kan ik meer documentatie en voorbeelden vinden voor Aspose.Words voor Java?
U kunt uitgebreide documentatie en voorbeelden voor Aspose.Words voor Java vinden op de Aspose-website. Bezoekhttps://reference.aspose.com/words/java/ voor gedetailleerde documentatie en bronnen.
