Metodi di supporto per l'estrazione di contenuto in Aspose.Words per Java
Introduzione ai metodi di supporto per l’estrazione di contenuti in Aspose.Words per Java
Aspose.Words per Java è una potente libreria che consente agli sviluppatori di lavorare con documenti Word a livello di programmazione. Un’attività comune quando si lavora con documenti Word è l’estrazione di contenuto da essi. In questo articolo, esploreremo alcuni metodi di supporto per estrarre contenuto in modo efficiente utilizzando Aspose.Words per Java.
Prerequisiti
Prima di immergerci negli esempi di codice, assicurati di aver installato e configurato Aspose.Words for Java nel tuo progetto Java. Puoi scaricarlo daQui.
Metodo di supporto 1: estrazione di paragrafi per stile
public static ArrayList<Paragraph> paragraphsByStyleName(Document doc, String styleName) {
// Crea un array per raccogliere i paragrafi dello stile specificato.
ArrayList<Paragraph> paragraphsWithStyle = new ArrayList<Paragraph>();
NodeCollection paragraphs = doc.getChildNodes(NodeType.PARAGRAPH, true);
// Esamina tutti i paragrafi per trovare quelli con lo stile specificato.
for (Paragraph paragraph : (Iterable<Paragraph>) paragraphs) {
if (paragraph.getParagraphFormat().getStyle().getName().equals(styleName))
paragraphsWithStyle.add(paragraph);
}
return paragraphsWithStyle;
}
Puoi usare questo metodo per estrarre paragrafi che hanno uno stile specifico nel tuo documento Word. È utile quando vuoi estrarre contenuti con una formattazione particolare, come titoli o citazioni a blocchi.
Metodo di supporto 2: estrazione del contenuto tramite nodi
public static ArrayList<Node> extractContentBetweenNodes(Node startNode, Node endNode, boolean isInclusive) {
// Per prima cosa, verifica che i nodi passati a questo metodo siano validi per l'uso.
verifyParameterNodes(startNode, endNode);
// Creare un elenco in cui archiviare i nodi estratti.
ArrayList<Node> nodes = new ArrayList<Node>();
// Se uno dei marcatori fa parte di un commento, incluso il commento stesso, dobbiamo spostare il puntatore
// inoltra al nodo Commento trovato dopo il nodo CommentRangeEnd.
if (endNode.getNodeType() == NodeType.COMMENT_RANGE_END && isInclusive) {
Node node = findNextNode(NodeType.COMMENT, endNode.getNextSibling());
if (node != null)
endNode = node;
}
// Conservare un registro dei nodi originali passati a questo metodo per suddividere i nodi marcatori, se necessario.
Node originalStartNode = startNode;
Node originalEndNode = endNode;
//Estrai il contenuto in base ai nodi a livello di blocco (paragrafi e tabelle). Attraversa i nodi padre per trovarli.
// Divideremo il contenuto del primo e dell'ultimo nodo a seconda che i nodi marcatori siano in linea o meno.
startNode = getAncestorInBody(startNode);
endNode = getAncestorInBody(endNode);
boolean isExtracting = true;
boolean isStartingNode = true;
// Il nodo corrente che stiamo estraendo dal documento.
Node currNode = startNode;
// Inizia l'estrazione del contenuto. Elabora tutti i nodi a livello di blocco e dividi specificamente il primo
// e gli ultimi nodi quando necessario, in modo da mantenere la formattazione del paragrafo.
// Questo metodo è un po' più complicato di un normale estrattore poiché dobbiamo considerare
// nell'estrazione mediante nodi in linea, campi, segnalibri, ecc., per renderlo utile.
while (isExtracting) {
// Clonare il nodo corrente e i suoi figli per ottenere una copia.
Node cloneNode = currNode.deepClone(true);
boolean isEndingNode = currNode.equals(endNode);
if (isStartingNode || isEndingNode) {
// Dobbiamo elaborare ogni marcatore separatamente, quindi passiamolo a un metodo separato.
// Per mantenere gli indici dei nodi, è necessario elaborare prima la fine.
if (isEndingNode) {
// !isStartingNode: non aggiungere il nodo due volte se i marcatori sono lo stesso nodo.
processMarker(cloneNode, nodes, originalEndNode, currNode, isInclusive,
false, !isStartingNode, false);
isExtracting = false;
}
//Le condizioni devono essere separate poiché i marcatori di inizio e fine a livello di blocco potrebbero essere lo stesso nodo.
if (isStartingNode) {
processMarker(cloneNode, nodes, originalStartNode, currNode, isInclusive,
true, true, false);
isStartingNode = false;
}
} else
// Il nodo non è un indicatore di inizio o di fine, basta aggiungere la copia all'elenco.
nodes.add(cloneNode);
// Passa al nodo successivo ed estrailo. Se il nodo successivo è nullo,
// il resto del contenuto si trova in una sezione diversa.
if (currNode.getNextSibling() == null && isExtracting) {
// Passa alla sezione successiva.
Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
currNode = nextSection.getBody().getFirstChild();
} else {
// Passa al nodo successivo nel corpo.
currNode = currNode.getNextSibling();
}
}
// Per compatibilità con la modalità con segnalibri in linea, aggiungere il paragrafo successivo (vuoto).
if (isInclusive && originalEndNode == endNode && !originalEndNode.isComposite())
includeNextParagraph(endNode, nodes);
// Restituisce i nodi compresi tra i marcatori dei nodi.
return nodes;
}
Questo metodo consente di estrarre il contenuto tra due nodi specificati, siano essi paragrafi, tabelle o altri elementi a livello di blocco. Gestisce vari scenari, tra cui marcatori in linea, campi e segnalibri.
Metodo di supporto 3: Generazione di un nuovo documento
public static Document generateDocument(Document srcDoc, ArrayList<Node> nodes) throws Exception {
Document dstDoc = new Document();
// Rimuovi il primo paragrafo dal documento vuoto.
dstDoc.getFirstSection().getBody().removeAllChildren();
// Importa ogni nodo dall'elenco nel nuovo documento. Mantieni la formattazione originale del nodo.
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;
}
Questo metodo consente di generare un nuovo documento importando un elenco di nodi dal documento sorgente. Mantiene la formattazione originale dei nodi, rendendolo utile per creare nuovi documenti con contenuti specifici.
Conclusione
L’estrazione di contenuto da documenti Word può essere una parte cruciale di molte attività di elaborazione di documenti. Aspose.Words per Java fornisce potenti metodi di supporto che semplificano questo processo. Che tu abbia bisogno di estrarre paragrafi per stile, contenuto tra nodi o generare nuovi documenti, questi metodi ti aiuteranno a lavorare in modo efficiente con documenti Word nelle tue applicazioni Java.
Domande frequenti
Come posso installare Aspose.Words per Java?
Per installare Aspose.Words per Java, puoi scaricarlo dal sito web di Aspose. VisitaQui per ottenere la versione più recente.
Posso estrarre contenuti da sezioni specifiche di un documento Word?
Sì, puoi estrarre contenuti da sezioni specifiche di un documento Word utilizzando i metodi menzionati in questo articolo. Specifica semplicemente i nodi di inizio e fine che definiscono la sezione che vuoi estrarre.
Aspose.Words per Java è compatibile con Java 11?
Sì, Aspose.Words per Java è compatibile con Java 11 e versioni successive. Puoi utilizzarlo nelle tue applicazioni Java senza alcun problema.
Posso personalizzare la formattazione del contenuto estratto?
Sì, puoi personalizzare la formattazione del contenuto estratto modificando i nodi importati nel documento generato. Aspose.Words per Java fornisce ampie opzioni di formattazione per soddisfare le tue esigenze.
Dove posso trovare ulteriore documentazione ed esempi per Aspose.Words per Java?
Puoi trovare documentazione completa ed esempi per Aspose.Words per Java sul sito web di Aspose. Visitahttps://reference.aspose.com/words/java/ per documentazione e risorse dettagliate.
