Extraindo conteúdo de documentos em Aspose.Words para Java

Introdução à extração de conteúdo de documentos em Aspose.Words for Java

No mundo do processamento de documentos, extrair conteúdo de documentos é um requisito comum. Se você precisa extrair texto, tabelas, imagens ou elementos específicos de documentos, Aspose.Words for Java fornece ferramentas poderosas para tornar essa tarefa muito fácil. Neste guia completo, orientaremos você no processo de extração de conteúdo de documentos usando Aspose.Words for Java.

Pré-requisitos

Antes de mergulharmos no processo de extração, certifique-se de ter os seguintes pré-requisitos em vigor:

  1. Aspose.Words for Java: Você deve ter o Aspose.Words for Java instalado e configurado em seu ambiente de desenvolvimento Java. Você pode baixá-lo emaqui.

  2. Um documento para extrair conteúdo: Para este guia, usaremos um documento de amostra chamado “Extrair conteúdo.docx”. Certifique-se de ter um documento semelhante pronto para extração.

Extraindo conteúdo entre nós em nível de bloco

// Amostra de código Java para extrair conteúdo entre nós em nível de bloco
Document doc = new Document("Your Directory Path" + "Extract content.docx");
Paragraph startPara = (Paragraph) doc.getLastSection().getChild(NodeType.PARAGRAPH, 2, true);
Table endTable = (Table) doc.getLastSection().getChild(NodeType.TABLE, 0, true);
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startPara, endTable, true);
Collections.reverse(extractedNodes);
while (extractedNodes.size() > 0) {
    endTable.getParentNode().insertAfter((Node) extractedNodes.get(0), endTable);
    extractedNodes.remove(0);
}
doc.save("Your Directory Path" + "ExtractContent.ExtractContentBetweenBlockLevelNodes.docx");

Extraindo conteúdo entre marcadores

//Exemplo de código Java para extrair conteúdo entre marcadores
Document doc = new Document("Your Directory Path" + "Extract content.docx");
Bookmark bookmark = doc.getRange().getBookmarks().get("Bookmark1");
BookmarkStart bookmarkStart = bookmark.getBookmarkStart();
BookmarkEnd bookmarkEnd = bookmark.getBookmarkEnd();
ArrayList<Node> extractedNodesInclusive = ExtractContentHelper.extractContent(bookmarkStart, bookmarkEnd, true);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesInclusive);
dstDoc.save("Your Directory Path" + "ExtractContent.ExtractContentBetweenBookmark.IncludingBookmark.docx");
ArrayList<Node> extractedNodesExclusive = ExtractContentHelper.extractContent(bookmarkStart, bookmarkEnd, false);
dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesExclusive);
dstDoc.save("Your Directory Path" + "ExtractContent.ExtractContentBetweenBookmark.WithoutBookmark.docx");

Extraindo conteúdo entre intervalos de comentários

// Exemplo de código Java para extrair conteúdo entre intervalos de comentários
Document doc = new Document("Your Directory Path" + "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);
ArrayList<Node> extractedNodesInclusive = ExtractContentHelper.extractContent(commentStart, commentEnd, true);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesInclusive);
dstDoc.save("Your Directory Path" + "ExtractContent.ExtractContentBetweenCommentRange.IncludingComment.docx");
ArrayList<Node> extractedNodesExclusive = ExtractContentHelper.extractContent(commentStart, commentEnd, false);
dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodesExclusive);
dstDoc.save("Your Directory Path" + "ExtractContent.ExtractContentBetweenCommentRange.WithoutComment.docx");

Extraindo conteúdo entre parágrafos

// Exemplo de código Java para extrair conteúdo entre parágrafos
Document doc = new Document("Your Directory Path" + "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);
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startPara, endPara, true);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodes);
dstDoc.save("Your Directory Path" + "ExtractContent.ExtractContentBetweenParagraphs.docx");

Extraindo conteúdo entre estilos de parágrafo

// Exemplo de código Java para extrair conteúdo entre estilos de parágrafo
Document doc = new Document("Your Directory Path" + "Extract content.docx");
ArrayList<Paragraph> parasStyleHeading1 = ExtractContentHelper.paragraphsByStyleName(doc, "Heading 1");
ArrayList<Paragraph> parasStyleHeading3 = ExtractContentHelper.paragraphsByStyleName(doc, "Heading 3");
Node startPara1 = parasStyleHeading1.get(0);
Node endPara1 = parasStyleHeading3.get(0);
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startPara1, endPara1, false);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodes);
dstDoc.save("Your Directory Path" + "ExtractContent.ExtractContentBetweenParagraphStyles.docx");

Extraindo conteúdo entre execuções

// Amostra de código Java para extrair conteúdo entre execuções
Document doc = new Document("Your Directory Path" + "Extract content.docx");
Paragraph para = (Paragraph) doc.getChild(NodeType.PARAGRAPH, 7, true);
Run startRun = para.getRuns().get(1);
Run endRun = para.getRuns().get(4);
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startRun, endRun, true);
Node node = (Node) extractedNodes.get(0);
System.out.println(node.toString(SaveFormat.TEXT));

Extraindo conteúdo usando DocumentVisitor

// Amostra de código Java para extrair conteúdo usando DocumentVisitor
Document doc = new Document("Your Directory Path" + "Absolute position tab.docx");
MyDocToTxtWriter myConverter = new MyDocToTxtWriter();
doc.accept(myConverter);
System.out.println(myConverter.getText());

Extraindo conteúdo usando campo

// Exemplo de código Java para extrair conteúdo usando Field
Document doc = new Document("Your Directory Path" + "Extract content.docx");
DocumentBuilder builder = new DocumentBuilder(doc);
builder.moveToMergeField("Fullname", false, false);
FieldStart startField = (FieldStart) builder.getCurrentNode();
Paragraph endPara = (Paragraph) doc.getFirstSection().getChild(NodeType.PARAGRAPH, 5, true);
ArrayList<Node> extractedNodes = ExtractContentHelper.extractContent(startField, endPara, false);
Document dstDoc = ExtractContentHelper.generateDocument(doc, extractedNodes);
dstDoc.save("Your Directory Path" + "ExtractContent.ExtractContentUsingField.docx");

Extraindo Índice

// Amostra de código Java para extrair índice analítico
Document doc = new Document("Your Directory Path" + "Table of contents.docx");
for (Field field : doc.getRange().getFields()) {
    if (field.getType() == FieldType.FIELD_HYPERLINK) {
        FieldHyperlink hyperlink = (FieldHyperlink) field;
        if (hyperlink.getSubAddress() != null && hyperlink.getSubAddress().startsWith("_Toc")) {
            Paragraph tocItem = (Paragraph) field.getStart().getAncestor(NodeType.PARAGRAPH);
            System.out.println(tocItem.toString(SaveFormat.TEXT).trim());
            System.out.println("------------------");
            Bookmark bm = doc.getRange().getBookmarks().get(hyperlink.getSubAddress());
            Paragraph pointer = (Paragraph) bm.getBookmarkStart().getAncestor(NodeType.PARAGRAPH);
            System.out.println(pointer.toString(SaveFormat.TEXT));
        }
    }
}

Extraindo apenas texto

// Exemplo de código Java para extrair apenas texto
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.insertField("MERGEFIELD Field");
System.out.println("GetText() Result: " + doc.getText());
System.out.println("ToString() Result: " + doc.toString(SaveFormat.TEXT));

Extraindo conteúdo com base em estilos

// Exemplo de código Java para extrair conteúdo com base em estilos
Document doc = new Document("Your Directory Path" + "Styles.docx");
final String PARA_STYLE = "Heading 1";
final String RUN_STYLE = "Intense Emphasis";
ArrayList<Paragraph> paragraphs = paragraphsByStyleName(doc, PARA_STYLE);
System.out.println("Paragraphs with \"{paraStyle}\" styles ({paragraphs.Count}):");
for (Paragraph paragraph : paragraphs)
    System.out.println(paragraph.toString(SaveFormat.TEXT));
ArrayList<Run> runs = runsByStyleName(doc, RUN_STYLE);
System.out.println("\nRuns with \"{runStyle}\" styles ({runs.Count}):");
for (Run run : runs)
    System.out.println(run.getRange().getText());
}

public ArrayList<Paragraph> paragraphsByStyleName(Document doc, String styleName) {
    ArrayList<Paragraph> paragraphsWithStyle = new ArrayList<Paragraph>();
    NodeCollection paragraphs = doc.getChildNodes(NodeType.PARAGRAPH, true);
    for (Paragraph paragraph : (Iterable<Paragraph>) paragraphs) {
        if (paragraph.getParagraphFormat().getStyle().getName().equals(styleName))
            paragraphsWithStyle.add(paragraph);
    }
    return paragraphsWithStyle;
}

public ArrayList<Run> runsByStyleName(Document doc, String styleName) {
    ArrayList<Run> runsWithStyle = new ArrayList<Run>();
    NodeCollection runs = doc.getChildNodes(NodeType.RUN, true);
    for (Run run : (Iterable<Run>) runs) {
        if (run.getFont().getStyle().getName().equals(styleName))
            runsWithStyle.add(run);
    }
    return runsWithStyle;
}

Extraindo e imprimindo texto

// Exemplo de código Java para extrair e imprimir texto
Document doc = new Document("Your Directory Path" + "Tables.docx");
Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);
System.out.println("Contents of the table: ");
System.out.println(table.getRange().getText());
System.out.println("\nContents of the row: ");
System.out.println(table.getRows().get(1).getRange().getText());
System.out.println("\nContents of the cell: ");
System.out.println(table.getLastRow().getLastCell().getRange().getText());

Extraindo imagens para arquivos

// Exemplo de código Java para extrair imagens para arquivos
Document doc = new Document("Your Directory Path" + "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()));
        shape.getImageData().save("Your Directory Path" + imageFileName);
        imageIndex++;
    }
}

Conclusão

Parabéns! Você aprendeu como extrair conteúdo de documentos usando Aspose.Words for Java. Este guia abordou várias técnicas de extração, incluindo conteúdo entre nós de nível de bloco, marcadores, intervalos de comentários, parágrafos e muito mais. Agora você está equipado para lidar com a extração de conteúdo de documentos de maneira eficiente em seus aplicativos Java.

Perguntas frequentes

Como extraio conteúdo de seções específicas do documento?

Para extrair o conteúdo de seções específicas do documento, você pode identificar os pontos inicial e final das seções e usar os métodos Aspose.Words for Java apropriados para extrair o conteúdo entre eles.

Posso extrair conteúdo de documentos protegidos por senha?

Sim, Aspose.Words for Java fornece funcionalidade para extrair conteúdo de documentos protegidos por senha. Você pode fornecer a senha ao abrir o documento usando oDocument construtor de classe.

Como posso extrair conteúdo e salvá-lo em diferentes formatos, como texto simples ou HTML?

Você pode extrair o conteúdo de um documento e salvá-lo em diferentes formatos usando Aspose.Words for Java. Depois de extrair o conteúdo, você pode usar oDocument métodos de classe para salvá-lo em formatos como texto simples, HTML ou outros.

Existe uma maneira de extrair conteúdo de elementos específicos do documento, como tabelas ou imagens?

Sim, você pode extrair conteúdo de elementos específicos do documento, como tabelas ou imagens, usando Aspose.Words for Java. Identifique os elementos que deseja extrair e use os métodos apropriados para extrair seu conteúdo.

Como posso automatizar o processo de extração de conteúdo em meu aplicativo Java?

Para automatizar o processo de extração de conteúdo em seu aplicativo Java, você pode criar código customizado com base nas técnicas descritas neste guia. Você também pode implementar lógica para iterar vários documentos e extrair conteúdo conforme necessário.

Usando dados XML em Aspose.Words para Java Métodos auxiliares para extrair conteúdo em Aspose.Words para Java