Hjälpmetoder för att extrahera innehåll i Aspose.Words för Java
Introduktion till hjälpmetoder för att extrahera innehåll i Aspose.Words för Java
Aspose.Words för Java är ett kraftfullt bibliotek som låter utvecklare arbeta med Word-dokument programmatiskt. En vanlig uppgift när man arbetar med Word-dokument är att extrahera innehåll från dem. I den här artikeln kommer vi att utforska några hjälpmetoder för att extrahera innehåll effektivt med Aspose.Words för Java.
Förutsättningar
Innan vi dyker in i kodexemplen, se till att du har Aspose.Words för Java installerat och konfigurerat i ditt Java-projekt. Du kan ladda ner den frånhär.
Hjälpmetod 1: Extrahera stycken efter stil
public static ArrayList<Paragraph> paragraphsByStyleName(Document doc, String styleName) {
// Skapa en array för att samla stycken av den angivna stilen.
ArrayList<Paragraph> paragraphsWithStyle = new ArrayList<Paragraph>();
NodeCollection paragraphs = doc.getChildNodes(NodeType.PARAGRAPH, true);
// Titta igenom alla stycken för att hitta de med den angivna stilen.
for (Paragraph paragraph : (Iterable<Paragraph>) paragraphs) {
if (paragraph.getParagraphFormat().getStyle().getName().equals(styleName))
paragraphsWithStyle.add(paragraph);
}
return paragraphsWithStyle;
}
Du kan använda den här metoden för att extrahera stycken som har en specifik stil i ditt Word-dokument. Detta är användbart när du vill extrahera innehåll med en viss formatering, till exempel rubriker eller blockcitattecken.
Hjälpmetod 2: Extrahera innehåll efter noder
public static ArrayList<Node> extractContentBetweenNodes(Node startNode, Node endNode, boolean isInclusive) {
// Kontrollera först att noderna som skickas till denna metod är giltiga för användning.
verifyParameterNodes(startNode, endNode);
// Skapa en lista för att lagra de extraherade noderna.
ArrayList<Node> nodes = new ArrayList<Node>();
// Om någon av markörerna är en del av en kommentar, inklusive själva kommentaren, måste vi flytta pekaren
// vidarebefordra till kommentarnoden som hittas efter noden CommentRangeEnd.
if (endNode.getNodeType() == NodeType.COMMENT_RANGE_END && isInclusive) {
Node node = findNextNode(NodeType.COMMENT, endNode.getNextSibling());
if (node != null)
endNode = node;
}
// Håll ett register över de ursprungliga noderna som skickats till denna metod för att dela markörnoder om det behövs.
Node originalStartNode = startNode;
Node originalEndNode = endNode;
//Extrahera innehåll baserat på noder på blocknivå (stycken och tabeller). Gå igenom föräldranoder för att hitta dem.
// Vi kommer att dela upp den första och sista nodens innehåll, beroende på om markörnoderna är inline.
startNode = getAncestorInBody(startNode);
endNode = getAncestorInBody(endNode);
boolean isExtracting = true;
boolean isStartingNode = true;
// Den aktuella noden vi extraherar från dokumentet.
Node currNode = startNode;
// Börja extrahera innehåll. Bearbeta alla noder på blocknivå och dela specifikt den första
// och sista noder vid behov så att styckeformateringen behålls.
// Denna metod är lite mer komplicerad än en vanlig extraktor eftersom vi måste ta hänsyn till
// att extrahera med hjälp av inline-noder, fält, bokmärken, etc., för att göra det användbart.
while (isExtracting) {
// Klona den aktuella noden och dess underordnade för att få en kopia.
Node cloneNode = currNode.deepClone(true);
boolean isEndingNode = currNode.equals(endNode);
if (isStartingNode || isEndingNode) {
// Vi måste bearbeta varje markör separat, så skicka den vidare till en separat metod istället.
// Slutet bör bearbetas först för att behålla nodindex.
if (isEndingNode) {
// !isStartingNode: lägg inte till noden två gånger om markörerna är samma nod.
processMarker(cloneNode, nodes, originalEndNode, currNode, isInclusive,
false, !isStartingNode, false);
isExtracting = false;
}
//Villkorliga måste vara separata eftersom start- och slutmarkörerna på blocknivå kan vara samma nod.
if (isStartingNode) {
processMarker(cloneNode, nodes, originalStartNode, currNode, isInclusive,
true, true, false);
isStartingNode = false;
}
} else
// Noden är inte en start- eller slutmarkör, lägg bara till kopian i listan.
nodes.add(cloneNode);
// Flytta till nästa nod och extrahera den. Om nästa nod är null,
// resten av innehållet finns i ett annat avsnitt.
if (currNode.getNextSibling() == null && isExtracting) {
// Flytta till nästa avsnitt.
Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
currNode = nextSection.getBody().getFirstChild();
} else {
// Flytta till nästa nod i kroppen.
currNode = currNode.getNextSibling();
}
}
// För kompatibilitet med läge med inline-bokmärken, lägg till nästa stycke (tomt).
if (isInclusive && originalEndNode == endNode && !originalEndNode.isComposite())
includeNextParagraph(endNode, nodes);
// Returnera noderna mellan nodmarkörerna.
return nodes;
}
Den här metoden låter dig extrahera innehåll mellan två specificerade noder, oavsett om de är stycken, tabeller eller andra element på blocknivå. Den hanterar olika scenarier, inklusive inline-markörer, fält och bokmärken.
Hjälpmetod 3: Skapa ett nytt dokument
public static Document generateDocument(Document srcDoc, ArrayList<Node> nodes) throws Exception {
Document dstDoc = new Document();
// Ta bort första stycket från det tomma dokumentet.
dstDoc.getFirstSection().getBody().removeAllChildren();
// Importera varje nod från listan till det nya dokumentet. Behåll nodens ursprungliga formatering.
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;
}
Den här metoden låter dig skapa ett nytt dokument genom att importera en lista med noder från källdokumentet. Den behåller nodernas ursprungliga formatering, vilket gör den användbar för att skapa nya dokument med specifikt innehåll.
Slutsats
Att extrahera innehåll från Word-dokument kan vara en avgörande del av många dokumentbearbetningsuppgifter. Aspose.Words för Java tillhandahåller kraftfulla hjälpmetoder som förenklar denna process. Oavsett om du behöver extrahera stycken efter stil, innehåll mellan noder eller generera nya dokument, kommer dessa metoder att hjälpa dig att effektivt arbeta med Word-dokument i dina Java-applikationer.
FAQ’s
Hur kan jag installera Aspose.Words för Java?
För att installera Aspose.Words för Java kan du ladda ner det från Asposes webbplats. Besökhär för att få den senaste versionen.
Kan jag extrahera innehåll från specifika delar av ett Word-dokument?
Ja, du kan extrahera innehåll från specifika delar av ett Word-dokument med de metoder som nämns i den här artikeln. Ange helt enkelt start- och slutnoderna som definierar avsnittet du vill extrahera.
Är Aspose.Words for Java kompatibelt med Java 11?
Ja, Aspose.Words för Java är kompatibel med Java 11 och högre versioner. Du kan använda den i dina Java-applikationer utan problem.
Kan jag anpassa formateringen av det extraherade innehållet?
Ja, du kan anpassa formateringen av det extraherade innehållet genom att ändra de importerade noderna i det genererade dokumentet. Aspose.Words för Java tillhandahåller omfattande formateringsalternativ för att möta dina behov.
Var kan jag hitta mer dokumentation och exempel för Aspose.Words för Java?
Du kan hitta omfattande dokumentation och exempel för Aspose.Words för Java på Asposes webbplats. Besökhttps://reference.aspose.com/words/java/ för detaljerad dokumentation och resurser.
