Métodos auxiliares para extrair conteúdo em Aspose.Words para Java
Introdução aos métodos auxiliares para extração de conteúdo em Aspose.Words para Java
Aspose.Words for Java é uma biblioteca poderosa que permite aos desenvolvedores trabalhar com documentos do Word de forma programática. Uma tarefa comum ao trabalhar com documentos do Word é extrair conteúdo deles. Neste artigo, exploraremos alguns métodos auxiliares para extrair conteúdo de forma eficiente usando Aspose.Words for Java.
Pré-requisitos
Antes de mergulharmos nos exemplos de código, certifique-se de ter o Aspose.Words for Java instalado e configurado em seu projeto Java. Você pode baixá-lo emaqui.
Método auxiliar 1: extração de parágrafos por estilo
public static ArrayList<Paragraph> paragraphsByStyleName(Document doc, String styleName) {
// Crie uma matriz para coletar parágrafos do estilo especificado.
ArrayList<Paragraph> paragraphsWithStyle = new ArrayList<Paragraph>();
NodeCollection paragraphs = doc.getChildNodes(NodeType.PARAGRAPH, true);
// Examine todos os parágrafos para encontrar aqueles com o estilo especificado.
for (Paragraph paragraph : (Iterable<Paragraph>) paragraphs) {
if (paragraph.getParagraphFormat().getStyle().getName().equals(styleName))
paragraphsWithStyle.add(paragraph);
}
return paragraphsWithStyle;
}
Você pode usar este método para extrair parágrafos que possuem um estilo específico em seu documento do Word. Isso é útil quando você deseja extrair conteúdo com uma formatação específica, como títulos ou citações em bloco.
Método auxiliar 2: extração de conteúdo por nós
public static ArrayList<Node> extractContentBetweenNodes(Node startNode, Node endNode, boolean isInclusive) {
// Primeiro, verifique se os nós passados para este método são válidos para uso.
verifyParameterNodes(startNode, endNode);
// Crie uma lista para armazenar os nós extraídos.
ArrayList<Node> nodes = new ArrayList<Node>();
// Se algum dos marcadores fizer parte de um comentário, incluindo o próprio comentário, precisamos mover o ponteiro
// encaminhe para o nó Comment localizado após o nó CommentRangeEnd.
if (endNode.getNodeType() == NodeType.COMMENT_RANGE_END && isInclusive) {
Node node = findNextNode(NodeType.COMMENT, endNode.getNextSibling());
if (node != null)
endNode = node;
}
// Mantenha um registro dos nós originais passados para este método para dividir os nós marcadores, se necessário.
Node originalStartNode = startNode;
Node originalEndNode = endNode;
//Extraia conteúdo com base em nós de nível de bloco (parágrafos e tabelas). Percorra os nós pais para encontrá-los.
// Dividiremos o conteúdo do primeiro e do último nó, dependendo se os nós marcadores estão embutidos.
startNode = getAncestorInBody(startNode);
endNode = getAncestorInBody(endNode);
boolean isExtracting = true;
boolean isStartingNode = true;
// O nó atual que estamos extraindo do documento.
Node currNode = startNode;
// Comece a extrair conteúdo. Processe todos os nós em nível de bloco e divida especificamente o primeiro
// e últimos nós quando necessário para que a formatação do parágrafo seja mantida.
// Este método é um pouco mais complicado do que um extrator normal, pois precisamos fatorar
// na extração usando nós embutidos, campos, marcadores, etc., para torná-lo útil.
while (isExtracting) {
// Clone o nó atual e seus filhos para obter uma cópia.
Node cloneNode = currNode.deepClone(true);
boolean isEndingNode = currNode.equals(endNode);
if (isStartingNode || isEndingNode) {
// Precisamos processar cada marcador separadamente, então passe-o para um método separado.
// End deve ser processado primeiro para manter os índices dos nós.
if (isEndingNode) {
// !isStartingNode: não adicione o nó duas vezes se os marcadores forem o mesmo nó.
processMarker(cloneNode, nodes, originalEndNode, currNode, isInclusive,
false, !isStartingNode, false);
isExtracting = false;
}
//Condicional precisa ser separado, pois os marcadores de início e fim do nível do bloco podem ser o mesmo nó.
if (isStartingNode) {
processMarker(cloneNode, nodes, originalStartNode, currNode, isInclusive,
true, true, false);
isStartingNode = false;
}
} else
// O nó não é um marcador de início ou fim, basta adicionar a cópia à lista.
nodes.add(cloneNode);
// Vá para o próximo nó e extraia-o. Se o próximo nó for nulo,
// o resto do conteúdo é encontrado em uma seção diferente.
if (currNode.getNextSibling() == null && isExtracting) {
// Vá para a próxima seção.
Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
currNode = nextSection.getBody().getFirstChild();
} else {
// Vá para o próximo nó do corpo.
currNode = currNode.getNextSibling();
}
}
// Para compatibilidade com o modo com marcadores embutidos, adicione o próximo parágrafo (vazio).
if (isInclusive && originalEndNode == endNode && !originalEndNode.isComposite())
includeNextParagraph(endNode, nodes);
// Retorne os nós entre os marcadores de nó.
return nodes;
}
Este método permite extrair conteúdo entre dois nós especificados, sejam eles parágrafos, tabelas ou quaisquer outros elementos em nível de bloco. Ele lida com vários cenários, incluindo marcadores embutidos, campos e marcadores.
Método auxiliar 3: gerando um novo documento
public static Document generateDocument(Document srcDoc, ArrayList<Node> nodes) throws Exception {
Document dstDoc = new Document();
// Remova o primeiro parágrafo do documento vazio.
dstDoc.getFirstSection().getBody().removeAllChildren();
// Importe cada nó da lista para o novo documento. Mantenha a formatação original do nó.
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;
}
Este método permite gerar um novo documento importando uma lista de nós do documento de origem. Mantém a formatação original dos nós, tornando-o útil para a criação de novos documentos com conteúdo específico.
Conclusão
Extrair conteúdo de documentos do Word pode ser uma parte crucial de muitas tarefas de processamento de documentos. Aspose.Words for Java fornece métodos auxiliares poderosos que simplificam esse processo. Se você precisa extrair parágrafos por estilo, conteúdo entre nós ou gerar novos documentos, esses métodos o ajudarão a trabalhar de forma eficiente com documentos do Word em seus aplicativos Java.
Perguntas frequentes
Como posso instalar o Aspose.Words para Java?
Para instalar o Aspose.Words for Java, você pode baixá-lo no site do Aspose. Visitaaqui para obter a versão mais recente.
Posso extrair conteúdo de seções específicas de um documento do Word?
Sim, você pode extrair conteúdo de seções específicas de um documento do Word usando os métodos mencionados neste artigo. Basta especificar os nós iniciais e finais que definem a seção que você deseja extrair.
O Aspose.Words para Java é compatível com Java 11?
Sim, Aspose.Words for Java é compatível com Java 11 e versões superiores. Você pode usá-lo em seus aplicativos Java sem problemas.
Posso personalizar a formatação do conteúdo extraído?
Sim, você pode personalizar a formatação do conteúdo extraído modificando os nós importados no documento gerado. Aspose.Words for Java oferece amplas opções de formatação para atender às suas necessidades.
Onde posso encontrar mais documentação e exemplos para Aspose.Words for Java?
Você pode encontrar documentação abrangente e exemplos para Aspose.Words for Java no site Aspose. Visitahttps://reference.aspose.com/words/java/ para documentação e recursos detalhados.
