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 para Java é uma biblioteca poderosa que permite que desenvolvedores trabalhem com documentos do Word programaticamente. 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 para Java.
Pré-requisitos
Antes de mergulharmos nos exemplos de código, certifique-se de ter o Aspose.Words para Java instalado e configurado em seu projeto Java. Você pode baixá-lo emaqui.
Método auxiliar 1: Extraindo 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 tenham um estilo específico no seu documento do Word. Isso é útil quando você quer extrair conteúdo com uma formatação específica, como títulos ou citações em bloco.
Método auxiliar 2: Extraindo 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 qualquer marcador fizer parte de um comentário, incluindo o próprio comentário, precisamos mover o ponteiro
// encaminhar para o nó de comentário encontrado 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 em linha.
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 o conteúdo. Processe todos os nós de 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 regular, pois precisamos fatorar
// na extração usando nós inline, 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);
// Mova para o próximo nó e extraia-o. Se o próximo nó for nulo,
// o restante do conteúdo pode ser 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 {
// Mover para o próximo nó no 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ós.
return nodes;
}
Este método permite que você extraia conteúdo entre dois nós especificados, sejam eles parágrafos, tabelas ou quaisquer outros elementos de nível de bloco. Ele lida com vários cenários, incluindo marcadores em linha, 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 que você gere um novo documento importando uma lista de nós do documento de origem. Ele retém a formatação original dos nós, tornando-o útil para criar 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. O Aspose.Words para 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 ajudarão você a trabalhar eficientemente com documentos do Word em seus aplicativos Java.
Perguntas frequentes
Como posso instalar o Aspose.Words para Java?
Para instalar o Aspose.Words para Java, você pode baixá-lo do site Aspose. Visiteaqui 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 inicial e final que definem a seção que você deseja extrair.
O Aspose.Words para Java é compatível com o Java 11?
Sim, o Aspose.Words para 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. O Aspose.Words para Java fornece opções de formatação extensivas para atender às suas necessidades.
Onde posso encontrar mais documentação e exemplos do Aspose.Words para Java?
Você pode encontrar documentação abrangente e exemplos para Aspose.Words para Java no site Aspose. Visitehttps://reference.aspose.com/words/java/ para documentação e recursos detalhados.
