Extrair conteúdo entre nós num documento

Ao trabalhar com documentos, é importante poder extrair facilmente o conteúdo de um intervalo específico dentro de um documento. No entanto, o conteúdo pode consistir em elementos complexos, como parágrafos, tabelas, imagens, etc.

Independentemente de qual conteúdo precisa ser extraído, o método para extrair esse conteúdo será sempre determinado por quais nós são selecionados para extrair conteúdo entre. Estes podem ser corpos de texto inteiros ou execuções de texto simples.

Existem muitas situações possíveis e, portanto, muitos tipos de nós diferentes a serem considerados ao extrair conteúdo. Por exemplo, você pode querer extrair conteúdo entre:

  • Dois parágrafos específicos
  • Textos específicos
  • Campos de vários tipos, como campos de fusão
  • Intervalos de início e fim de um marcador ou comentário
  • Vários corpos de texto contidos em secções separadas

Em algumas situações, pode até ser necessário combinar diferentes tipos de nós, como extrair conteúdo entre um parágrafo e um campo, ou entre uma execução e um marcador.

Este artigo fornece a implementação de código para extrair texto entre diferentes nós, bem como exemplos de cenários comuns.

Por Que Extrair Conteúdo

Muitas vezes, o objetivo de extrair o conteúdo é duplicá-lo ou salvá-lo separadamente em um novo documento. Por exemplo, você pode extrair conteúdo e:

  • Copie-o para um documento separado
  • Converter uma parte específica de um documento em PDF ou imagem
  • Duplique o conteúdo do documento várias vezes
  • Trabalhar com conteúdo extraído separado do resto do documento

Isso pode ser facilmente alcançado usando Aspose.Words e a implementação do código abaixo.

Extraindo Algoritmo De Conteúdo

O código desta secção aborda todas as situações possíveis acima descritas com um método generalizado e reutilizável. O esboço geral desta técnica envolve:

  1. Reunir os nós que ditam a área de conteúdo que será extraída do seu documento. A recuperação desses nós é tratada pelo usuário em seu código, com base no que eles desejam extrair.
  2. Passando esses nós para o método ExtractContent fornecido abaixo. Você também deve passar um parâmetro booleano que indica se esses nós, atuando como marcadores, devem ser incluídos na extração ou não.
  3. Recuperar uma lista de conteúdos clonados (nós copiados) especificados para serem extraídos. Você pode usar essa lista de nós de qualquer maneira aplicável, por exemplo, criando um novo documento contendo apenas o conteúdo selecionado.

Como extrair conteúdo

Trabalharemos com o documento abaixo neste artigo. Como você pode ver, ele contém uma variedade de conteúdos. Observe também que o documento contém uma segunda seção que começa no meio da primeira página. Um marcador e um comentário também estão presentes no documento, mas não são visíveis na imagem abaixo.

extract-content-aspose-words-java

Para extrair o conteúdo do seu documento, você precisa chamar o método ExtractContent abaixo e passar os parâmetros apropriados.

A base subjacente a este método consiste em encontrar nós a nível de bloco (parágrafos e tabelas) e cloná-los para criar cópias idênticas. Se os nós do marcador passados forem de nível de bloco, o método poderá simplesmente copiar o conteúdo nesse nível e adicioná-lo à matriz.

No entanto, se os nós do marcador forem inline (um filho de um parágrafo), a situação torna-se mais complexa, pois é necessário dividir o parágrafo no nó inline, seja uma execução, campos de marcadores, etc. O conteúdo nos nós pai clonados não presentes entre os marcadores é removido. Esse processo é usado para garantir que os nós embutidos ainda mantenham a formatação do parágrafo pai.

O método também executará verificações nos nós passados como parâmetros e lançará uma exceção se um dos Nós for inválido. Os parâmetros a serem passados para este método são:

  1. StartNode e EndNode. Os dois primeiros parâmetros são os nós que definem onde a extração do conteúdo deve começar e terminar, respectivamente. Esses nós podem ser de nível de bloco (Paragraph, Table) ou nível embutido (por exemplo Run, FieldStart, BookmarkStart etc.):

    1. Para passar um campo, você deve passar o objeto FieldStart correspondente.
    2. Para passar marcadores, os nós BookmarkStart e BookmarkEnd devem ser passados.
    3. Para passar comentários, os nós CommentRangeStart e CommentRangeEnd devem ser usados.
  2. IsInclusive. Define se os marcadores estão incluídos na extração ou não. Se esta opção for definida como false e o mesmo nó ou nós consecutivos forem passados, uma lista vazia será retornada:

    1. Se um nó FieldStart for passado, esta opção define se o campo inteiro deve ser incluído ou excluído.
    2. Se um nó BookmarkStart ou BookmarkEnd For passado, esta opção define se o marcador está incluído ou apenas o conteúdo entre o intervalo de marcadores.
    3. Se um nó CommentRangeStart ou CommentRangeEnd For passado, esta opção define se o comentário em si deve ser incluído ou apenas o conteúdo no intervalo de comentários.

A implementação do método ExtractContent você pode encontrar aqui. Este método será referido nos cenários do presente artigo.

Também definiremos um método personalizado para gerar facilmente um documento a partir de nós extraídos. Este método é usado em muitos dos cenários abaixo e simplesmente cria um novo documento e importa o conteúdo extraído para ele.

O exemplo de código a seguir mostra como pegar uma lista de nós e inseri-los em um novo documento:

// 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;
}

Extrair Conteúdo Entre Parágrafos

Isso demonstra como usar o método acima para extrair conteúdo entre parágrafos específicos. Neste caso, queremos extrair o corpo da carta encontrada na primeira metade do documento. Podemos dizer que isso está entre os parágrafos 7 e 11.

O código abaixo cumpre esta tarefa. Os parágrafos apropriados são extraídos usando o método getChild no documento e passando os índices especificados. Em seguida, passamos esses nós para o método ExtractContent e declaramos que eles devem ser incluídos na extração. Este método devolverá o conteúdo copiado entre estes nós que são então inseridos num novo documento.

O exemplo de código a seguir mostra como extrair o conteúdo entre parágrafos específicos usando o método ExtractContent acima:

// 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");

O documento de saída contém os dois parágrafos que foram extraídos.

extract-content-result-aspose-words-java

Extrair conteúdo entre diferentes tipos de nós

Podemos extrair conteúdo entre quaisquer combinações de nós em nível de bloco ou inline. Neste cenário a seguir, extrairemos o conteúdo entre o primeiro parágrafo e a tabela na segunda seção, inclusive. Obtemos os nós marcadores chamando o método getFirstParagraph e getChild na segunda seção do documento para recuperar os nós Paragraph e Table apropriados. Para uma ligeira variação, vamos duplicar o conteúdo e inseri-lo abaixo do original.

O exemplo de código a seguir mostra como extrair o conteúdo entre um parágrafo e uma tabela usando o método ExtractContent:

// 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");

O conteúdo entre o parágrafo e a tabela foi duplicado abaixo é o resultado.

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

Extrair conteúdo entre parágrafos com base no estilo

Pode ser necessário extrair o conteúdo entre parágrafos do mesmo estilo ou de um estilo diferente, como entre parágrafos marcados com estilos de título.

O código abaixo mostra como conseguir isso. É um exemplo simples que extrairá o conteúdo entre a Primeira Instância dos estilos “Heading 1” e “cabeçalho 3” sem extrair os títulos também. Para fazer isso, definimos o último parâmetro como false, que especifica que os nós do marcador não devem ser incluídos.

Em uma implementação adequada, isso deve ser executado em um loop para extrair o conteúdo entre todos os parágrafos desses estilos do documento. O conteúdo extraído é copiado para um novo documento.

O exemplo de código a seguir mostra como extrair conteúdo entre parágrafos com estilos específicos usando o método ExtractContent:

// 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;
}

Abaixo está o resultado da operação anterior.

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

Extrair Conteúdo Entre Execuções Específicas

Você também pode extrair conteúdo entre nós embutidos, como a Run. Runs de diferentes parágrafos podem ser passados como marcadores. O código abaixo mostra como extrair texto específico entre o mesmo nó Paragraph.

O exemplo de código a seguir mostra como extrair conteúdo entre execuções específicas do mesmo parágrafo usando o método ExtractContent:

// 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));

O texto extraído é apresentado na consola.

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

Extrair conteúdo utilizando um campo

Para usar um campo como marcador, o nó FieldStart deve ser passado. O último parâmetro do método ExtractContent definirá se o campo inteiro deve ser incluído ou não. Vamos extrair o conteúdo entre o campo de mesclagem" FullName " e um parágrafo no documento. Usamos o método moveToMergeField da classe DocumentBuilder. Isso retornará o nó FieldStart do nome do campo de mesclagem passado para ele.

No nosso caso, vamos definir o último parâmetro passado para o método ExtractContent como false para excluir o campo da extração. Vamos renderizar o conteúdo extraído para PDF.

O exemplo de código a seguir mostra como extrair conteúdo entre um campo específico e um parágrafo no documento usando o método ExtractContent:

// 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");

O conteúdo extraído entre o campo e o parágrafo, sem os nós do campo e do marcador de parágrafo renderizados para PDF.

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

Extrair conteúdo de um marcador

Em um documento, o conteúdo definido em um marcador é encapsulado pelos nós BookmarkStart e BookmarkEnd. O conteúdo encontrado entre estes dois nós constitui o marcador. Você pode passar qualquer um desses nós como qualquer marcador, mesmo aqueles de marcadores diferentes, desde que o marcador inicial apareça antes do marcador final no documento.

No nosso documento de exemplo, temos um marcador, denominado “Bookmark1”. O conteúdo deste marcador é o conteúdo destacado no nosso documento:

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

Vamos extrair este conteúdo para um novo documento usando o código abaixo. A opção de parâmetro IsInclusive mostra como reter ou descartar o marcador.

O exemplo de código a seguir mostra como extrair o conteúdo referenciado a um marcador usando o método ExtractContent:

// 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");

A saída extraída com o parâmetro IsInclusive definido como true. A cópia também manterá o marcador.

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

A saída extraída com o parâmetro IsInclusive definido como false. A cópia contém o conteúdo, mas sem o marcador.

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

Extrair conteúdo de um comentário

Um comentário é composto pelos nós CommentRangeStart, CommentRangeEnd e Comment. Todos esses nós são inline. Os dois primeiros nós encapsulam o conteúdo do documento que é referenciado pelo comentário, como pode ser visto na imagem abaixo.

O nó Comment em si é um InlineStory que pode conter parágrafos e execuções. Representa a mensagem do comentário como visto como uma bolha de comentário no painel de revisão. Como este nó é embutido e descendente de um corpo, você também pode extrair o conteúdo de dentro desta mensagem.

No nosso documento temos um comentário. Vamos exibi-lo mostrando a marcação na guia Revisão:

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

O comentário contém o título, o primeiro parágrafo e o quadro da segunda secção. Vamos extrair este comentário para um novo documento. A opção IsInclusive determina se o comentário em si é mantido ou descartado.

O exemplo de código a seguir mostra como fazer isso abaixo:

// 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");

Em primeiro lugar, a saída extraída com o parâmetro IsInclusive definido como true. A cópia também conterá o comentário.

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

Em segundo lugar, a saída extraída com isInclusive definida como false. A cópia contém o conteúdo, mas sem o comentário.

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

Extrair conteúdo utilizando DocumentVisitor

Aspose.Words pode ser usado não apenas para criar Microsoft Word documentos, construindo-os dinamicamente ou mesclando modelos com dados, mas também para analisar documentos para extrair elementos de documentos separados, como cabeçalhos, rodapés, parágrafos, tabelas, imagens e outros. Outra tarefa possível é encontrar todo o texto de formatação ou estilo específico.

Use a classe DocumentVisitor para implementar esse cenário de uso. Esta classe corresponde ao conhecido padrão de design do visitante. Com DocumentVisitor, é possível definir e executar operações personalizadas que requerem enumeração sobre a árvore de documentos.

DocumentVisitor fornece um conjunto de VisitXXX métodos que são invocados quando um elemento de documento específico (nó) é encontrado. Por exemplo, VisitParagraphStart é chamado quando o início de um parágrafo de texto é encontrado e VisitParagraphEnd é chamado quando o final de um parágrafo de texto é encontrado. Cada método DocumentVisitor.VisitXXX aceita o objeto correspondente que encontra para que você possa usá-lo conforme necessário (digamos, recuperar a formatação), por exemplo, VisitParagraphStart e VisitParagraphEnd aceitam um objeto Paragraph.

Cada método DocumentVisitor.VisitXXX retorna um valor VisitorAction que controla a enumeração de nós. Você pode solicitar a continuação da enumeração, ignorar o nó atual (mas continuar a enumeração) ou interromper a enumeração de nós.

Estas são as etapas que você deve seguir para determinar e extrair programaticamente várias partes de um documento:

  • Crie uma classe derivada de DocumentVisitor.
  • Substituir e fornecer implementações para alguns ou todos os métodos DocumentVisitor.VisitXXX para executar algumas operações personalizadas.
  • Chame Node.accept no nó de onde deseja iniciar a enumeração. Por exemplo, se você quiser enumerar o documento inteiro, use accept(DocumentVisitor).

DocumentVisitor fornece implementações padrão para todos os métodos DocumentVisitor.VisitXXX. Isso facilita a criação de novos visitantes de documentos, pois apenas os métodos necessários para o visitante específico precisam ser substituídos. Não é necessário substituir todos os métodos do visitante.

O exemplo a seguir mostra como usar o padrão de Visitante para adicionar novas operações ao modelo de objeto Aspose.Words. Neste caso, criamos um conversor de documentos simples em formato de texto:

// 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;
}

Extrair Apenas Texto

As formas de recuperar texto do documento são:

  • Use Document.save com SaveFormat para salvar como texto simples em um arquivo ou fluxo
  • Use Node.toString e passe o parâmetro SaveFormat.Text. Internamente, isso invoca Salvar como texto em um fluxo de memória e retorna a string resultante
  • Use Node.getText para recuperar texto com todos os caracteres de controle Microsoft Word, incluindo códigos de campo
  • Implementar um custom DocumentVisitor para executar a extração customizada

Utilização de Node.GetText e Node.ToString

Um documento do Word pode conter caracteres de controlo que designam elementos especiais, tais como campo, fim da célula, fim da secção, etc. A lista completa dos possíveis caracteres de controlo de palavras é definida na classe ControlChar. O método GetText retorna texto com todos os caracteres de caracteres de controle presentes no nó.

Chamar ToString retorna a representação de texto simples do documento apenas sem caracteres de controle. Para mais informações sobre a exportação em texto simples, Ver Using SaveFormat.Text.

O exemplo de código a seguir mostra a diferença entre chamar os métodos GetText e ToString em um nó:

// 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));

Usando SaveFormat.Text

Este exemplo guarda o documento da seguinte forma:

  • Filtra caracteres de campo e códigos de campo, forma, nota de rodapé, nota de fim e referências de comentários
  • Substitui os caracteres do fim do parágrafo ControlChar.Cr por combinações ControlChar.CrLf
  • Utiliza a codificação UTF8

O exemplo de código a seguir mostra como salvar um documento no formato TXT:

// 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");

Extrair imagens de formas

Pode ser necessário extrair imagens de documentos para executar algumas tarefas. Aspose.Words permite que você faça isso também.

O exemplo de código a seguir mostra como extrair imagens de um documento:

// 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++;
}
}