Documenten invoegen en toevoegen
Soms is het nodig om meerdere documenten te combineren in een. U kunt dit handmatig of u kunt gebruiken Aspose.Words functie invoegen of toevoegen.
Met de invoegoperatie kunt u de inhoud van eerder aangemaakte documenten in een nieuwe of bestaande invoegen.
Dankzij de functie toevoegen kunt u een document alleen aan het einde van een ander document toevoegen.
Dit artikel legt uit hoe je een document op verschillende manieren invoegt of toevoegt aan een ander en beschrijft de gemeenschappelijke eigenschappen die je kunt toepassen tijdens het invoegen of toevoegen van documenten.
Document invoegen
Zoals hierboven vermeld, in Aspose.Words een document wordt weergegeven als een boom van knooppunten, en de werking van het invoegen van een document in een ander document is het kopiëren van knooppunten van de eerste documentboom naar de tweede.
U kunt documenten op verschillende locaties op verschillende manieren invoegen. U kunt bijvoorbeeld een document invoegen via een vervangende bewerking, een merge-veld tijdens een merge-operatie of via een bladwijzer.
U kunt ook de InsertDocument of de InsertDocumentInline methode, die lijkt op het invoegen van een document in Microsoft Word, om een heel document in te voegen op de huidige cursorpositie zonder eerdere import.
Het volgende voorbeeld van code laat zien hoe een document met behulp van de InsertDocument methode:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document srcDoc = new Document(getMyDir() + "Document source.docx"); | |
Document dstDoc = new Document(getMyDir() + "Northwind traders.docx"); | |
DocumentBuilder builder = new DocumentBuilder(dstDoc); | |
builder.moveToDocumentEnd(); | |
builder.insertBreak(BreakType.PAGE_BREAK); | |
builder.insertDocument(srcDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING); | |
builder.getDocument().save(getArtifactsDir() + "JoinAndAppendDocuments.insertDocument.docx"); |
Het volgende voorbeeld van code laat zien hoe een document met behulp van de InsertDocumentInline methode:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
DocumentBuilder srcDoc = new DocumentBuilder(); | |
srcDoc.write("[src content]"); | |
// Create destination document. | |
DocumentBuilder dstDoc = new DocumentBuilder(); | |
dstDoc.write("Before "); | |
dstDoc.insertNode(new BookmarkStart(dstDoc.getDocument(), "src_place")); | |
dstDoc.insertNode(new BookmarkEnd(dstDoc.getDocument(), "src_place")); | |
dstDoc.write(" after"); | |
Assert.assertEquals("Before after", dstDoc.getDocument().getText().trim()); | |
// Insert source document into destination inline. | |
dstDoc.moveToBookmark("src_place"); | |
dstDoc.insertDocumentInline(srcDoc.getDocument(), ImportFormatMode.USE_DESTINATION_STYLES, new ImportFormatOptions()); | |
Assert.assertEquals("Before [src content] after", dstDoc.getDocument().getText().trim()); |
De volgende subsecties beschrijven de opties gedurende welke u het ene document in een ander kunt invoegen.
Een document invoegen tijdens het zoeken en vervangen
U kunt documenten invoegen tijdens het uitvoeren van zoeken en vervangen operaties. Een document kan bijvoorbeeld paragrafen bevatten met de tekst [INTRODUCTIE] en [CONCLUSIE]. Maar in het uiteindelijke document moet je die paragrafen vervangen door de inhoud die uit een ander extern document is verkregen. Om dat te bereiken, moet u een begeleider voor de vervanging evenement.
Het volgende voorbeeld van code laat zien hoe je een handler kunt maken voor de vervangende gebeurtenis om het later in het invoegproces te gebruiken:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
private static class InsertDocumentAtReplaceHandler implements IReplacingCallback | |
{ | |
public /*ReplaceAction*/int /*IReplacingCallback.*/replacing(ReplacingArgs args) throws Exception | |
{ | |
Document subDoc = new Document(getMyDir() + "Document insertion 2.docx"); | |
// Insert a document after the paragraph, containing the match text. | |
Paragraph para = (Paragraph)args.getMatchNode().getParentNode(); | |
insertDocument(para, subDoc); | |
// Remove the paragraph with the match text. | |
para.remove(); | |
return ReplaceAction.SKIP; | |
} | |
} |
Het volgende voorbeeld van code laat zien hoe inhoud van een document in een ander document wordt ingevoegd tijdens een zoek- en vervangoperatie:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document mainDoc = new Document(getMyDir() + "Document insertion 1.docx"); | |
// Set find and replace options. | |
FindReplaceOptions options = new FindReplaceOptions(); | |
{ | |
options.setDirection(FindReplaceDirection.BACKWARD); | |
options.setReplacingCallback(new InsertDocumentAtReplaceHandler()); | |
} | |
// Call the replace method. | |
mainDoc.getRange().replace(Pattern.compile("\\[MY_DOCUMENT\\]"), "", options); | |
mainDoc.save(getArtifactsDir() + "CloneAndCombineDocuments.InsertDocumentAtReplace.docx"); |
Een document invoegen tijdens Mail Merge Werking
U kunt een document invoegen in een merge veld tijdens een Mail Merge operatie. Bijvoorbeeld a Mail Merge template kan een merge-veld bevatten zoals [Samenvatting]. Maar in het uiteindelijke document moet je content uit een ander extern document invoegen in dit merge veld. Om dat te bereiken, moet u een begeleider voor de merge event.
Het volgende voorbeeld van code laat zien hoe je een handler aanmaakt voor de fuserende gebeurtenis om het later in het invoegproces te gebruiken:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
private static class InsertDocumentAtMailMergeHandler implements IFieldMergingCallback | |
{ | |
// This handler makes special processing for the "Document_1" field. | |
// The field value contains the path to load the document. | |
// We load the document and insert it into the current merge field. | |
public void /*IFieldMergingCallback.*/fieldMerging(FieldMergingArgs args) throws Exception | |
{ | |
if ("Document_1".equals(args.getDocumentFieldName())) | |
{ | |
// Use document builder to navigate to the merge field with the specified name. | |
DocumentBuilder builder = new DocumentBuilder(args.getDocument()); | |
builder.moveToMergeField(args.getDocumentFieldName()); | |
// The name of the document to load and insert is stored in the field value. | |
Document subDoc = new Document((String)args.getFieldValue()); | |
insertDocument(builder.getCurrentParagraph(), subDoc); | |
// The paragraph that contained the merge field might be empty now, and you probably want to delete it. | |
if (!builder.getCurrentParagraph().hasChildNodes()) | |
builder.getCurrentParagraph().remove(); | |
// Indicate to the mail merge engine that we have inserted what we wanted. | |
args.setText(null); | |
} | |
} | |
public void /*IFieldMergingCallback.*/imageFieldMerging(ImageFieldMergingArgs args) | |
{ | |
// Do nothing. | |
} | |
} |
Het volgende voorbeeld van code laat zien hoe je een document in het merge veld plaatst met behulp van de aangemaakte handler:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document mainDoc = new Document(getMyDir() + "Document insertion 1.docx"); | |
mainDoc.getMailMerge().setFieldMergingCallback(new InsertDocumentAtMailMergeHandler()); | |
// The main document has a merge field in it called "Document_1". | |
// The corresponding data for this field contains a fully qualified path to the document. | |
// That should be inserted to this field. | |
mainDoc.getMailMerge().execute(new String[] { "Document_1" }, new Object[] { getMyDir() + "Document insertion 2.docx" }); | |
mainDoc.save(getArtifactsDir() + "CloneAndCombineDocuments.InsertDocumentAtMailMerge.doc"); |
Een document invoegen bij bladwijzer
U kunt een tekstbestand importeren in een document en het direct invoegen na een bladwijzer die u in het document hebt gedefinieerd. Om dit te doen, maak een paragraaf met bladwijzers waar u wilt dat het document wordt ingevoegd.
Het volgende coderingsvoorbeeld laat zien hoe je de inhoud van het ene document in een bladwijzer in een ander document invoegt:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document mainDoc = new Document(getMyDir() + "Document insertion 1.docx"); | |
Document subDoc = new Document(getMyDir() + "Document insertion 2.docx"); | |
Bookmark bookmark = mainDoc.getRange().getBookmarks().get("insertionPlace"); | |
insertDocument(bookmark.getBookmarkStart().getParentNode(), subDoc); | |
mainDoc.save(getArtifactsDir() + "CloneAndCombineDocuments.InsertDocumentAtBookmark.docx"); |
Een document toevoegen
U kunt een use case hebben waar u extra pagina’s moet opnemen van een document tot het einde van een bestaand document. Om dit te doen, moet je gewoon de AppendDocument methode om een document aan het einde van een ander document toe te voegen.
Het volgende voorbeeld van code laat zien hoe je een document toevoegt aan het einde van een ander document:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document dstDoc = new Document(); | |
dstDoc.getFirstSection().getBody().appendParagraph("Destination document text. "); | |
Document srcDoc = new Document(); | |
srcDoc.getFirstSection().getBody().appendParagraph("Source document text. "); | |
// Append the source document to the destination document. | |
// Pass format mode to retain the original formatting of the source document when importing it. | |
dstDoc.appendDocument(srcDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING); | |
dstDoc.save(getArtifactsDir() + "JoinAndAppendDocuments.KeepSourceFormatting.docx"); |
Knoppen handmatig importeren en invoegen
Aspose.Words Hiermee kunt u documenten automatisch invoegen en toevoegen zonder eerdere importvereisten. Als u echter een specifieke knoop van uw document wilt invoegen of toevoegen, zoals een sectie of een paragraaf, dan moet u eerst deze knoop handmatig importeren.
Wanneer u een sectie of paragraaf moet invoegen of toevoegen aan een andere, moet u in wezen de knooppunten van de eerste document node boom importeren in de tweede met behulp van de ImportNode methode. Na het importeren van uw nodes, moet u de InsertAfter methode om een nieuwe knoop in te voegen na/voor het referentieknooppunt. Hiermee kunt u het invoegproces aanpassen door knooppunten uit een document te importeren en het op bepaalde posities in te voegen.
U kunt ook de AppendChild methode om een nieuw gespecificeerd knooppunt toe te voegen aan het einde van de lijst van kindknooppunten, bijvoorbeeld als u inhoud wilt toevoegen op paragraafniveau in plaats van op sectieniveau.
Het volgende voorbeeld van code laat zien hoe u handmatig knooppunten importeert en ze invoegt na een specifieke knooppunt met behulp van de InsertAfter methode:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
/// <summary> | |
/// Inserts content of the external document after the specified node. | |
/// Section breaks and section formatting of the inserted document are ignored. | |
/// </summary> | |
/// <param name="insertionDestination">Node in the destination document after which the content | |
/// Should be inserted. This node should be a block level node (paragraph or table).</param> | |
/// <param name="docToInsert">The document to insert.</param> | |
private static void insertDocument(Node insertionDestination, Document docToInsert) | |
{ | |
if (insertionDestination.getNodeType() == NodeType.PARAGRAPH || insertionDestination.getNodeType() == NodeType.TABLE) | |
{ | |
CompositeNode destinationParent = insertionDestination.getParentNode(); | |
NodeImporter importer = | |
new NodeImporter(docToInsert, insertionDestination.getDocument(), ImportFormatMode.KEEP_SOURCE_FORMATTING); | |
// Loop through all block-level nodes in the section's body, | |
// then clone and insert every node that is not the last empty paragraph of a section. | |
for (Section srcSection : docToInsert.getSections()) | |
for (Node srcNode : srcSection.getBody()) | |
{ | |
if (srcNode.getNodeType() == NodeType.PARAGRAPH) | |
{ | |
Paragraph para = (Paragraph)srcNode; | |
if (para.isEndOfSection() && !para.hasChildNodes()) | |
continue; | |
} | |
Node newNode = importer.importNode(srcNode, true); | |
destinationParent.insertAfter(newNode, insertionDestination); | |
insertionDestination = newNode; | |
} | |
} | |
else | |
{ | |
throw new IllegalArgumentException("The destination node should be either a paragraph or table."); | |
} | |
} |
Inhoud wordt per sectie in het document van bestemming geïmporteerd, wat betekent dat instellingen, zoals pagina-instellingen en headers of voetteksten, tijdens import behouden blijven. Het is ook handig om op te merken dat u formatteringsinstellingen kunt definiëren wanneer u een document invoegt of toevoegt om aan te geven hoe twee documenten worden samengevoegd.
Gemeenschappelijke eigenschappen voor invoegen en toevoegen van documenten
Beide InsertDocument en AppendDocument methoden accepteren ImportFormatMode en ImportFormatOptions als inputparameters. De ImportFormatMode kunt u controleren hoe documentopmaak wordt samengevoegd wanneer u inhoud importeren van het ene document in het andere door het selecteren van verschillende indelingsmodi zoals UseDestinationStyles, KeepSourceFormatting, en KeepDifferentStyles. De ImportFormatOptions stelt u in staat verschillende importopties te selecteren, zoals IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, en SmartStyleBehavior.
Aspose.Words stelt u in staat om de visualisatie van een resulterend document aan te passen wanneer twee documenten samen worden toegevoegd in een invoeg- of voegbewerking door gebruik te maken van de Section en PageSetup eigenschappen. De PageSetup eigenschap bevat alle eigenschappen van een sectie zoals SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, en anderen. De meest voorkomende use case is om de SectionStart eigenschap om te bepalen of de toegevoegde inhoud op dezelfde pagina zal verschijnen of in een nieuwe zal splitsen.
Het volgende voorbeeld van code laat zien hoe het ene document aan het andere kan worden toegevoegd, terwijl de inhoud niet over twee pagina’s kan worden gesplitst:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document srcDoc = new Document(getMyDir() + "Document source.docx"); | |
Document dstDoc = new Document(getMyDir() + "Northwind traders.docx"); | |
// Set the source document to continue straight after the end of the destination document. | |
srcDoc.getFirstSection().getPageSetup().setSectionStart(SectionStart.CONTINUOUS); | |
// Restart the page numbering on the start of the source document. | |
srcDoc.getFirstSection().getPageSetup().setRestartPageNumbering(true); | |
srcDoc.getFirstSection().getPageSetup().setPageStartingNumber(1); | |
// To ensure this does not happen when the source document has different page setup settings, make sure the | |
// settings are identical between the last section of the destination document. | |
// If there are further continuous sections that follow on in the source document, | |
// this will need to be repeated for those sections. | |
srcDoc.getFirstSection().getPageSetup().setPageWidth(dstDoc.getLastSection().getPageSetup().getPageWidth()); | |
srcDoc.getFirstSection().getPageSetup().setPageHeight(dstDoc.getLastSection().getPageSetup().getPageHeight()); | |
srcDoc.getFirstSection().getPageSetup().setOrientation(dstDoc.getLastSection().getPageSetup().getOrientation()); | |
// Iterate through all sections in the source document. | |
for (Paragraph para : (Iterable<Paragraph>) srcDoc.getChildNodes(NodeType.PARAGRAPH, true)) | |
{ | |
para.getParagraphFormat().setKeepWithNext(true); | |
} | |
dstDoc.appendDocument(srcDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING); | |
dstDoc.save(getArtifactsDir() + "JoinAndAppendDocuments.DifferentPageSetup.docx"); |