Inhoud tussen knooppunten uitpakken in een document

Bij het werken met documenten is het belangrijk om inhoud binnen een document gemakkelijk uit een specifiek bereik te halen. De inhoud kan echter bestaan uit complexe elementen zoals paragrafen, tabellen, afbeeldingen, enz.

Ongeacht welke inhoud moet worden gewonnen, de methode om dat gehalte te extraheren zal altijd worden bepaald door welke knooppunten worden geselecteerd om inhoud tussen te extraheren. Dit kunnen hele tekstlichamen zijn of eenvoudige tekstruns.

Er zijn veel mogelijke situaties en daarom veel verschillende knooppunttypes te overwegen bij het extraheren van inhoud. U kunt bijvoorbeeld inhoud uitpakken tussen:

  • Twee specifieke paragrafen
  • Specifieke punten van tekst
  • Velden van verschillende soorten, zoals merge velden
  • Begin en eindbereik van een bladwijzer of commentaar
  • Diverse teksten in afzonderlijke afdelingen

In sommige situaties moet je zelfs verschillende knooppunttypes combineren, zoals inhoud extraheren tussen een alinea en een veld, of tussen een run en een bladwijzer.

Dit artikel geeft de code implementatie voor het extraheren van tekst tussen verschillende knooppunten, evenals voorbeelden van gemeenschappelijke scenario’s.

Waarom inhoud uitpakken

Vaak is het doel van het extraheren van de inhoud om het apart te dupliceren of op te slaan in een nieuw document. U kunt bijvoorbeeld inhoud extraheren en:

  • Kopieer het in een apart document
  • Een bepaald deel van een document omzetten naar PDF of afbeelding
  • Dubbele inhoud in het document vele malen
  • Werk met uitgepakte inhoud gescheiden van de rest van het document

Dit kan gemakkelijk worden bereikt met behulp van Aspose.Words en de implementatie van de code hieronder.

Algoritme voor het extraheren van inhoud

De code in deze sectie behandelt alle hierboven beschreven situaties met één algemene en herbruikbare methode. De algemene opzet van deze techniek omvat:

  1. Het verzamelen van de knooppunten die het gebied van inhoud dicteren dat uit uw document zal worden gehaald. Het ophalen van deze knooppunten wordt behandeld door de gebruiker in hun code, gebaseerd op wat ze willen worden verwijderd.
  2. Deze knooppunten doorgeven aan de ExtractContent onderstaande methode. U moet ook een booleaanse parameter die aangeeft of deze knooppunten, die als markers, moet worden opgenomen in de extractie of niet.
  3. Het ophalen van een lijst van gekloonde inhoud (gekopieerde knooppunten) die moeten worden verwijderd. U kunt deze lijst van knooppunten op elke toepasselijke manier gebruiken, bijvoorbeeld door een nieuw document aan te maken dat alleen de geselecteerde inhoud bevat.

Hoe de inhoud uit te pakken

We werken met het document hieronder in dit artikel. Zoals je kunt zien bevat het een verscheidenheid aan inhoud. Let ook op, het document bevat een tweede sectie beginnend in het midden van de eerste pagina. Een bladwijzer en commentaar zijn ook aanwezig in het document, maar zijn niet zichtbaar in de screenshot hieronder.

extract-content-aspose-words-java

Om de inhoud uit uw document te halen moet u de ExtractContent methode hieronder en geef de juiste parameters door.

De onderliggende basis van deze methode is het vinden van knooppunten op blokniveau (paragrafen en tabellen) en het klonen ervan om identieke kopieën te maken. Als de aangegeven knooppunten blok-niveau zijn dan is de methode in staat om gewoon de inhoud op dat niveau te kopiëren en toe te voegen aan de array.

Echter, als de marker knooppunten zijn inline (een kind van een alinea) dan wordt de situatie complexer, omdat het nodig is om de paragraaf op de inline knooppunt te splitsen, of het nu een run, bladwijzer velden etc. Inhoud in de gekloonde ouderknooppunten die niet aanwezig zijn tussen de markers wordt verwijderd. Dit proces wordt gebruikt om ervoor te zorgen dat de inline-knooppunten de opmaak van de alinea van de moeder blijven behouden.

De methode zal ook controles uitvoeren op de knooppunten doorgegeven als parameters en gooit een uitzondering als beide knooppunten ongeldig is. De parameters die aan deze methode moeten worden doorgegeven zijn:

  1. StartNode en EndNode. De eerste twee parameters zijn de knooppunten die bepalen waar de extractie van de inhoud begint en eindigt op respectievelijk. Deze knooppunten kunnen zowel blokniveau (Paragraph , Table ) of inlineniveau (bv. Run , FieldStart , BookmarkStart enz.):

    1. Om een veld te passeren moet u de overeenkomstige FieldStart object.
    2. Om bladwijzers te passeren, de BookmarkStart en BookmarkEnd Knooppunten moeten worden doorgegeven.
    3. Om opmerkingen door te geven, de CommentRangeStart en CommentRangeEnd gebruik van knooppunten.
  2. IsInclusive. Bepaalt of de markeringen al dan niet in de extractie zijn opgenomen. Als deze optie ingesteld is false en dezelfde knoop of opeenvolgende knooppunten worden doorgegeven, dan zal een lege lijst worden teruggegeven:

    1. FieldStart knooppunt wordt doorgegeven dan deze optie definieert of het hele veld moet worden opgenomen of uitgesloten.
    2. BookmarkStart of BookmarkEnd node is doorgegeven, deze optie definieert of de bladwijzer is opgenomen of alleen de inhoud tussen de bladwijzer range.
    3. CommentRangeStart of CommentRangeEnd node is doorgegeven, deze optie definieert of het commentaar zelf moet worden opgenomen of alleen de inhoud in het commentaarbereik.

De tenuitvoerlegging van het ExtractContent methode kunt u vinden Hier. Deze methode zal in de scenario’s in dit artikel worden genoemd.

We zullen ook een aangepaste methode definiëren om gemakkelijk een document te genereren van uitgepakte knooppunten. Deze methode wordt gebruikt in veel van de onderstaande scenario’s en maakt gewoon een nieuw document en importeert de gewonnen inhoud in het.

Het volgende voorbeeld van code laat zien hoe je een lijst van knooppunten neemt en ze in een nieuw document invoegt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
public static Document generateDocument(Document srcDoc, ArrayList<Node> nodes) throws Exception
{
Document dstDoc = new Document();
// Remove the first paragraph from the empty document.
dstDoc.getFirstSection().getBody().removeAllChildren();
// Import each node from the list into the new document. Keep the original formatting of the node.
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;
}

Inhoud tussen alinea’s uitpakken

Hieruit blijkt hoe de hierboven beschreven methode moet worden gebruikt om het gehalte tussen specifieke paragrafen te extraheren. In dit geval willen we de inhoud van de brief uit de eerste helft van het document halen. We kunnen zien dat dit tussen de 7e en 11e alinea’s ligt.

De onderstaande code vervult deze taak. De desbetreffende alinea’s worden met behulp van de getChild methode op het document en het doorgeven van de gespecificeerde indices. Vervolgens geven we deze knooppunten door aan de ExtractContent methode en vermelden dat deze in de extractie moeten worden opgenomen. Deze methode zal de gekopieerde inhoud tussen deze knooppunten teruggeven die vervolgens in een nieuw document worden ingevoegd.

Het volgende voorbeeld van code laat zien hoe de inhoud tussen specifieke alinea’s met behulp van de ExtractContent methode hierboven:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
Paragraph startPara = (Paragraph) doc.getFirstSection().getBody().getChild(NodeType.PARAGRAPH, 6, true);
Paragraph endPara = (Paragraph) doc.getFirstSection().getBody().getChild(NodeType.PARAGRAPH, 10, true);
// Extract the content between these nodes in the document. Include these markers in the extraction.
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startPara, endPara, true);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodes);
dstDoc.save(getArtifactsDir() + "ExtractContent.ExtractContentBetweenParagraphs.docx");

Het uitvoerdocument bevat de twee alinea’s die eruit zijn gehaald.

extract-content-result-aspose-words-java

Inhoud uitpakken tussen verschillende soorten nodes

We kunnen inhoud extraheren tussen combinaties van blok-niveau of inline knooppunten. In dit scenario hieronder zullen we de inhoud tussen de eerste alinea en de tabel in het tweede deel inclusief extraheren. We krijgen de markers knooppunten door te bellen getFirstParagraph en getChild methode op het tweede deel van het document om de juiste Paragraph en Table knooppunten. Voor een lichte variatie laten we de inhoud dupliceren en onder het origineel plaatsen.

Het volgende voorbeeld van code laat zien hoe de inhoud tussen een alinea en een tabel met behulp van de ExtractContent methode:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
Paragraph startPara = (Paragraph) doc.getLastSection().getChild(NodeType.PARAGRAPH, 2, true);
Table endTable = (Table) doc.getLastSection().getChild(NodeType.TABLE, 0, true);
// Extract the content between these nodes in the document. Include these markers in the extraction.
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startPara, endTable, true);
// Let's reverse the array to make inserting the content back into the document easier.
Collections.reverse(extractedNodes);
for (Node extractedNode : extractedNodes)
// Insert the last node from the reversed list.
endTable.getParentNode().insertAfter(extractedNode, endTable);
doc.save(getArtifactsDir() + "ExtractContent.ExtractContentBetweenBlockLevelNodes.docx");

De inhoud tussen de alinea en de tabel is hieronder gedupliceerd is het resultaat.

extract-content-between-paragraphs-aspose-words-java

Inhoud tussen alinea’s uitpakken Gebaseerd op stijl

Het kan nodig zijn om de inhoud te extraheren tussen paragrafen van dezelfde of andere stijl, zoals tussen paragrafen gemarkeerd met kopstijlen.

De onderstaande code laat zien hoe dit te bereiken. Het is een eenvoudig voorbeeld dat de inhoud zal extraheren tussen de eerste instantie van de “Heading 1” en “Header 3” stijlen zonder ook de rubrieken te extraheren. Om dit te doen zetten we de laatste parameter op false, waarin staat dat de markerknooppunten niet mogen worden opgenomen.

Bij een correcte implementatie moet dit in een lus worden uitgevoerd om inhoud tussen alle paragrafen van deze stijlen uit het document te halen. De gewonnen inhoud wordt gekopieerd naar een nieuw document.

Het volgende voorbeeld van code laat zien hoe inhoud tussen paragrafen met specifieke stijlen met behulp van de ExtractContent methode:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
// Gather a list of the paragraphs using the respective heading styles.
ArrayList<Paragraph> parasStyleHeading1 = paragraphsByStyleName(doc, "Heading 1");
ArrayList<Paragraph> parasStyleHeading3 = paragraphsByStyleName(doc, "Heading 3");
// Use the first instance of the paragraphs with those styles.
Node startPara1 = parasStyleHeading1.get(0);
Node endPara1 = parasStyleHeading3.get(0);
// Extract the content between these nodes in the document. Don't include these markers in the extraction.
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startPara1, endPara1, false);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodes);
dstDoc.save(getArtifactsDir() + "ExtractContent.ExtractContentBetweenParagraphStyles.docx");
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
public static ArrayList<Paragraph> paragraphsByStyleName(Document doc, String styleName)
{
// Create an array to collect paragraphs of the specified style.
ArrayList<Paragraph> paragraphsWithStyle = new ArrayList<Paragraph>();
NodeCollection paragraphs = doc.getChildNodes(NodeType.PARAGRAPH, true);
// Look through all paragraphs to find those with the specified style.
for (Paragraph paragraph : (Iterable<Paragraph>) paragraphs)
{
if (paragraph.getParagraphFormat().getStyle().getName().equals(styleName))
paragraphsWithStyle.add(paragraph);
}
return paragraphsWithStyle;
}

Hieronder is het resultaat van de vorige bewerking.

extract-content-between-paragraph-style-aspose-words-java

Inhoud uitpakken tussen specifieke runs

U kunt inhoud extraheren tussen inline knooppunten zoals een Run Ook. Runs van verschillende paragrafen kan worden doorgegeven als markers. De onderstaande code laat zien hoe je een specifieke tekst tussen dezelfde Paragraph Node.

Het volgende voorbeeld van code laat zien hoe je inhoud tussen specifieke runs van dezelfde paragraaf met behulp van de ExtractContent methode:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
Paragraph para = (Paragraph) doc.getChild(NodeType.PARAGRAPH, 7, true);
Run startRun = para.getRuns().get(1);
Run endRun = para.getRuns().get(4);
// Extract the content between these nodes in the document. Include these markers in the extraction.
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startRun, endRun, true);
for (Node extractedNode : extractedNodes)
System.out.println(extractedNode.toString(SaveFormat.TEXT));

De opgehaalde tekst wordt op de console weergegeven

extract-content-between-runs-aspose-words-java

Inhoud met een veld uitpakken

Om een veld als marker te gebruiken, de FieldStart knooppunt moet worden doorgegeven. De laatste parameter voor de ExtractContent methode zal bepalen of het gehele veld moet worden opgenomen of niet. Laten we de inhoud uitpakken tussen het veld “FullName” en een paragraaf in het document. Wij gebruiken de moveToMergeField DocumentBuilder Klasse. Dit zal de FieldStart knooppunt van de naam van het merge veld doorgegeven aan het.

In ons geval laten we de laatste parameter die aan de ExtractContent methode om false om het veld van de extractie uit te sluiten. We zullen de gewonnen inhoud naar PDF teruggeven.

Het volgende voorbeeld van code laat zien hoe inhoud tussen een specifiek veld en paragraaf in het document te extraheren met behulp van de ExtractContent methode:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
DocumentBuilder builder = new DocumentBuilder(doc);
// Pass the first boolean parameter to get the DocumentBuilder to move to the FieldStart of the field.
// We could also get FieldStarts of a field using GetChildNode method as in the other examples.
builder.moveToMergeField("Fullname", false, false);
// The builder cursor should be positioned at the start of the field.
FieldStart startField = (FieldStart) builder.getCurrentNode();
Paragraph endPara = (Paragraph) doc.getFirstSection().getChild(NodeType.PARAGRAPH, 5, true);
// Extract the content between these nodes in the document. Don't include these markers in the extraction.
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startField, endPara, false);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodes);
dstDoc.save(getArtifactsDir() + "ExtractContent.ExtractContentUsingField.docx");

De verzamelde inhoud tussen het veld en de alinea, zonder het veld en de puntmarkeringsknooppunten die aan PDF zijn weergegeven.

extract-content-using-field-aspose-words-java

Inhoud uit een bladwijzer halen

In een document wordt de inhoud die wordt gedefinieerd binnen een bladwijzer ingekapseld door de BookmarkStart en BookmarkEnd knooppunten. De inhoud tussen deze twee knooppunten vormt de bladwijzer. Je kunt een van deze knooppunten doorgeven als een markeerder, zelfs die van verschillende bladwijzers, zolang de beginmarkering verschijnt voor de eindmarkering in het document.

In ons voorbeeld document, hebben we een bladwijzer, genaamd Bookmark1. De inhoud van deze bladwijzer is gemarkeerd in ons document:

extract-content-from-bookmark-aspose-words-java-1

We zullen deze inhoud uitpakken in een nieuw document met de onderstaande code. De IsInclusive parameteroptie laat zien hoe u de bladwijzer kunt behouden of weggooien.

Het volgende voorbeeld van code toont hoe u de inhoud waarnaar een bladwijzer verwijst kunt uitpakken met behulp van de ExtractContent methode:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
Bookmark bookmark = doc.getRange().getBookmarks().get("Bookmark1");
BookmarkStart bookmarkStart = bookmark.getBookmarkStart();
BookmarkEnd bookmarkEnd = bookmark.getBookmarkEnd();
// Firstly, extract the content between these nodes, including the bookmark.
ArrayList<Node> extractedNodesInclusive = ExtractContentHelper.extractContent(bookmarkStart, bookmarkEnd, true);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesInclusive);
dstDoc.save(getArtifactsDir() + "ExtractContent.ExtractContentBetweenBookmark.IncludingBookmark.docx");
// Secondly, extract the content between these nodes this time without including the bookmark.
ArrayList<Node> extractedNodesExclusive = ExtractContentHelper.extractContent(bookmarkStart, bookmarkEnd, false);
dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesExclusive);
dstDoc.save(getArtifactsDir() + "ExtractContent.ExtractContentBetweenBookmark.WithoutBookmark.docx");

De gewonnen output met de IsInclusive parameter ingesteld op true. De kopie zal ook de bladwijzer behouden.

extract-content-from-bookmark-aspose-words-java-2

De gewonnen output met de IsInclusive parameter ingesteld op false. De kopie bevat de inhoud maar zonder de bladwijzer.

extract-content-from-bookmark-aspose-words-java-3

Inhoud uit een commentaar halen

Een commentaar bestaat uit de reactieRangeStart, reactieRangeEnd en commentaar knooppunten. Al deze knopen zijn inline. De eerste twee nodes inkapselen de inhoud in het document die wordt verwezen door het commentaar, zoals te zien in de screenshot hieronder.

De Comment knooppunt zelf is een InlineStory die alinea’s en runs kunnen bevatten. Het vertegenwoordigt de boodschap van het commentaar als een commentaarbel in het herzieningspaneel. Aangezien dit knooppunt inline is en een afstammeling van een lichaam kun je ook de inhoud uit deze boodschap halen.

In ons document hebben we één opmerking. Laat het weergeven door markup te tonen in het tabblad Beoordeling:

extract-content-from-comment-aspose-words-java-1

Het commentaar omvat de titel, eerste alinea en de tabel in het tweede deel. Laten we deze opmerking uitpakken in een nieuw document. De IsInclusive optie dicteert als het commentaar zelf wordt gehouden of weggegooid.

Het volgende voorbeeld van code laat zien hoe dit te doen is hieronder:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
CommentRangeStart commentStart = (CommentRangeStart) doc.getChild(NodeType.COMMENT_RANGE_START, 0, true);
CommentRangeEnd commentEnd = (CommentRangeEnd) doc.getChild(NodeType.COMMENT_RANGE_END, 0, true);
// Firstly, extract the content between these nodes including the comment as well.
ArrayList<Node> extractedNodesInclusive = ExtractContentHelper.extractContent(commentStart, commentEnd, true);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesInclusive);
dstDoc.save(getArtifactsDir() + "ExtractContent.ExtractContentBetweenCommentRange.IncludingComment.docx");
// Secondly, extract the content between these nodes without the comment.
ArrayList<Node> extractedNodesExclusive = ExtractContentHelper.extractContent(commentStart, commentEnd, false);
dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesExclusive);
dstDoc.save(getArtifactsDir() + "ExtractContent.ExtractContentBetweenCommentRange.WithoutComment.docx");

In de eerste plaats de gewonnen output met de IsInclusive parameter ingesteld op true. De kopie zal ook het commentaar bevatten.

extract-content-from-comment-aspose-words-java-2

In de tweede plaats is de gewonnen output met isInclusief ingesteld op false. De kopie bevat de inhoud maar zonder commentaar.

extract-content-from-comment-aspose-words-java-12

Inhoud met DocumentBezoeker uitpakken

Aspose.Words kan niet alleen worden gebruikt voor het aanmaken Microsoft Word documenten door ze dynamisch te bouwen of templates te samenvoegen met gegevens, maar ook voor het ontleden van documenten om afzonderlijke documentelementen zoals headers, voetteksten, paragrafen, tabellen, afbeeldingen en andere te extraheren. Een andere mogelijke taak is het vinden van alle tekst van specifieke opmaak of stijl.

Gebruik de DocumentVisitor klasse om dit gebruiksscenario te implementeren. Deze klasse komt overeen met het bekende bezoekersontwerppatroon. Met DocumentVisitorU kunt aangepaste bewerkingen definiëren en uitvoeren die een opsomming over de documentboom vereisen.

DocumentVisitor levert een reeks van VisitXXX methoden die worden gebruikt wanneer een bepaald documentelement (knooppunt) wordt aangetroffen. Bijvoorbeeld, VisitParagraphStart wordt aangeroepen wanneer het begin van een tekst paragraaf wordt gevonden en VisitParagraphEnd wordt aangeroepen wanneer het einde van een tekst paragraaf wordt gevonden. Elk DocumentVisitor.VisitXXX methode accepteert het bijbehorende object dat het tegenkomt, zodat u het kunt gebruiken als nodig (zeg het ophalen van de opmaak), bijvoorbeeld beide VisitParagraphStart en VisitParagraphEnd a Paragraph object.

Elk DocumentVisitor.VisitXXX methode geeft a VisitorAction waarde die de opsomming van knooppunten regelt. U kunt verzoeken de opsomming voort te zetten, het huidige knooppunt over te slaan (maar door te gaan met de opsomming), of de opsomming van knooppunten te stoppen.

Dit zijn de stappen die u moet volgen om programmatisch verschillende delen van een document te bepalen en uit te pakken:

  • Maak een klasse afgeleid van DocumentVisitor.
  • Overschrijven en implementaties voor sommige of alle van de DocumentVisitor.VisitXXX methoden om bepaalde aangepaste operaties uit te voeren.
  • Bel me. Node.accept op het knooppunt waar u de opsomming wilt beginnen. Als u bijvoorbeeld het hele document wilt opsommen, gebruik dan accept(DocumentVisitor).

DocumentVisitor biedt standaard implementaties voor alle van de DocumentVisitor.VisitXXX methoden. Dit maakt het makkelijker om nieuwe documentbezoekers te creëren, aangezien alleen de methoden die voor de specifieke bezoeker nodig zijn, overschreven moeten worden. Het is niet nodig om alle bezoekersmethoden te omzeilen.

Het volgende voorbeeld laat zien hoe u het Bezoekerspatroon gebruikt om nieuwe bewerkingen toe te voegen aan de Aspose.Words objectmodel. In dit geval maken we een eenvoudige documentconverter in een tekstformaat:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Extract content.docx");
ConvertDocToTxt convertToPlainText = new ConvertDocToTxt();
// Note that every node in the object model has the accept method so the visiting
// can be executed not only for the whole document, but for any node in the document.
doc.accept(convertToPlainText);
// Once the visiting is complete, we can retrieve the result of the operation,
// That in this example, has accumulated in the visitor.
System.out.println(convertToPlainText.getText());
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Simple implementation of saving a document in the plain text format. Implemented as a Visitor.
/// </summary>
static class ConvertDocToTxt extends DocumentVisitor {
public ConvertDocToTxt() {
mIsSkipText = false;
mBuilder = new StringBuilder();
}
/// <summary>
/// Gets the plain text of the document that was accumulated by the visitor.
/// </summary>
public String getText() {
return mBuilder.toString();
}
/// <summary>
/// Called when a Run node is encountered in the document.
/// </summary>
public int visitRun(Run run) {
appendText(run.getText());
// Let the visitor continue visiting other nodes.
return VisitorAction.CONTINUE;
}
/// <summary>
/// Called when a FieldStart node is encountered in the document.
/// </summary>
public int visitFieldStart(FieldStart fieldStart) {
// In Microsoft Word, a field code (such as "MERGEFIELD FieldName") follows
// after a field start character. We want to skip field codes and output field.
// Result only, therefore we use a flag to suspend the output while inside a field code.
// Note this is a very simplistic implementation and will not work very well.
// If you have nested fields in a document.
mIsSkipText = true;
return VisitorAction.CONTINUE;
}
/// <summary>
/// Called when a FieldSeparator node is encountered in the document.
/// </summary>
public int visitFieldSeparator(FieldSeparator fieldSeparator) {
// Once reached a field separator node, we enable the output because we are
// now entering the field result nodes.
mIsSkipText = false;
return VisitorAction.CONTINUE;
}
/// <summary>
/// Called when a FieldEnd node is encountered in the document.
/// </summary>
public int visitFieldEnd(FieldEnd fieldEnd) {
// Make sure we enable the output when reached a field end because some fields
// do not have field separator and do not have field result.
mIsSkipText = false;
return VisitorAction.CONTINUE;
}
/// <summary>
/// Called when visiting of a Paragraph node is ended in the document.
/// </summary>
public int visitParagraphEnd(Paragraph paragraph) {
// When outputting to plain text we output Cr+Lf characters.
appendText(ControlChar.CR_LF);
return VisitorAction.CONTINUE;
}
public int visitBodyStart(Body body) {
// We can detect beginning and end of all composite nodes such as Section, Body,
// Table, Paragraph etc and provide custom handling for them.
mBuilder.append("*** Body Started ***\r\n");
return VisitorAction.CONTINUE;
}
public int visitBodyEnd(Body body) {
mBuilder.append("*** Body Ended ***\r\n");
return VisitorAction.CONTINUE;
}
/// <summary>
/// Called when a HeaderFooter node is encountered in the document.
/// </summary>
public int visitHeaderFooterStart(HeaderFooter headerFooter) {
// Returning this value from a visitor method causes visiting of this
// Node to stop and move on to visiting the next sibling node
// The net effect in this example is that the text of headers and footers
// Is not included in the resulting output
return VisitorAction.SKIP_THIS_NODE;
}
/// <summary>
/// Adds text to the current output. Honors the enabled/disabled output flag.
/// </summary>
private void appendText(String text) {
if (!mIsSkipText)
mBuilder.append(text);
}
private StringBuilder mBuilder;
private boolean mIsSkipText;
}

Tekst uitpakken Alleen

De manieren om tekst uit het document op te halen zijn:

  • Gebruik Document.save met SaveFormat om als platte tekst op te slaan in een bestand of stream
  • Gebruik Node.toString en de SaveFormat.Text parameter. Intern, dit aanroepen opslaan als tekst in een geheugenstroom en geeft de resulterende string
  • Gebruik Node.getText tekst met alles ophalen Microsoft Word controle karakters inclusief veldcodes
  • Implementeer een aangepaste DocumentVisitor om aangepaste extractie uit te voeren

Gebruik Node.GetText en Node.ToString

A Word-document kan controle karakters die speciale elementen zoals veld, einde van de cel, einde van sectie, enz. aan te duiden bevatten. De volledige lijst van mogelijke Word control tekens wordt gedefinieerd in de ControlChar Klasse. De GetText methode geeft tekst terug met alle controle karakter tekens aanwezig in het knooppunt.

Aanroepen ToString geeft de platte tekstweergave van het document alleen terug zonder controletekens. Voor meer informatie over export als platte tekst zie Using SaveFormat.Text.

Het volgende voorbeeld toont het verschil tussen het aanroepen van de GetText en ToString methoden op een knooppunt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.insertField("MERGEFIELD Field");
// When converted to text it will not retrieve fields code or special characters,
// but will still contain some natural formatting characters such as paragraph markers etc.
// This is the same as "viewing" the document as if it was opened in a text editor.
System.out.println("ToString() Result: " + doc.toString(SaveFormat.TEXT));

Gebruik SaveFormat.Text

Dit voorbeeld slaat het document als volgt op:

  • Filtreert veldtekens en veldcodes, vorm, voetnoot, endnote en commentaarverwijzingen
  • Vervangt het einde van paragraaf ControlChar.Cr tekens met ControlChar.CrLf combinaties
  • Gebruikt UTF8 codering

Het volgende voorbeeld van code laat zien hoe een document in TXT-formaat kan worden opgeslagen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Document.docx");
doc.save(getArtifactsDir() + "BaseConversions.DocxToTxt.txt");

Afbeeldingen uit vormen halen

Het kan nodig zijn om documentafbeeldingen uit te pakken om enkele taken uit te voeren. Aspose.Words laat je dit ook doen.

Het volgende voorbeeld van code laat zien hoe je afbeeldingen uit een document haalt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Images.docx");
NodeCollection shapes = doc.getChildNodes(NodeType.SHAPE, true);
int imageIndex = 0;
for (Shape shape : (Iterable<Shape>) shapes) {
if (shape.hasImage()) {
String imageFileName =
MessageFormat.format("Image.ExportImages.{0}_{1}", imageIndex, FileFormatUtil.imageTypeToExtension(shape.getImageData().getImageType()));
// Note, if you have only an image (not a shape with a text and the image),
// you can use shape.getShapeRenderer().save(...) method to save the image.
shape.getImageData().save(getArtifactsDir() + imageFileName);
imageIndex++;
}
}