Bir Belge İçindeki Düğüm Arasında İçerik Çıkartın
Bir belge üzerinde çalışırken, bir belgedeki belirli bir aralıktan içeriği kolayca ayıklayabilmek önemlidir. Bununla birlikte, içerik paragraflar, tablolar, resimler vb. gibi karmaşık öğelerden oluşabilir.
İçerik ihtiyaçlarına bakılmaksızın, o içeriği ayıklamak için kullanılan yöntem her zaman içeriği ayıklamak için hangi düğümlerin seçileceğini belirler. Bunlar ya tüm metin gövdeleri ya da basit metin koşuludur.
İçeriği ayıklarken birçok olası durum ve bu nedenle dikkate alınması gereken çok farklı düğüm türü vardır. Örneğin, içeriği ayıklamak isteyebilirsiniz:
- İki spesifik paragraf
- Belirli metinler
- Çeşitli tipte alanlar, örneğin birleştirme alanları
- Bir imzanın veya yorumun başlangıç ve bitiş aralıkları
- Çeşitli metinler, ayrı bölümlere dahil edilmiştir
Bazı durumlarda, paragraf ve bir alan arasında veya bir çalıştırma ve bir yer işareti arasındaki içeriği ayıklamak gibi farklı düğüm türlerini birleştirmeniz gerekebilir.
Bu makale farklı düğümler arasındaki metinleri ayıklamak için kod uygulamasını sağlar ve yaygın senaryoların örneklerini verir.
İçeriği Neden Çıkartın?
İçeriği ayıklamanın amacı genellikle onu yeni bir belgeye ayrı olarak kopyalamak veya kaydetmektir. Örneğin, içeriği ayarlayabilir ve:
- Bunu ayrı bir belgeye kopyala
- Bir belgeden belirli bir kısmı PDF veya görüntüye dönüştürün “- Dokümantaki içeriği birçok kez çoğaltın.”
- Çıkartılan içeriği diğer tüm belgeyle ayrı olarak çalışın
Bu kolayca Aspose.Words ve aşağıdaki kod uygulaması kullanılarak gerçekleştirilebilir.
İçerik Çıkarma Algoritması
Bu bölümde yer alan kod, yukarıda tanımlanan olası tüm durumları tek bir genelleştirilmiş ve yeniden kullanılabilir yöntemle ele alır. Bu tekniğin genel kapsamı şu şekildedir:
- Belirli bir belgeden ayıklanacak içeriğin alanını belirten düğümleri toplayın. Bu düğümleri kullanıcı, istedikleri ayıklanacak şeylere bağlı olarak kodunda alır.
- Bu düğümleri aşağıda sağlanan ExtractContent yöntemine geçirin. Ayrıca bir Boolean parametresini de geçirmelisiniz, bu parametre bu düğümlerin, işaretçiler olarak faaliyet gösterdikleri, ayıklama işleminin bir parçası olup olmamaları gerektiğini belirtir.
- Alınan bir kopyalanmış içerik listesi (kopya düğümler) belirtilen ayıklama. Bu liste düğümleri herhangi bir uygulanabilir şekilde kullanabilirsiniz, örneğin yalnızca seçilen içeriği içeren yeni bir belge oluşturun.
İçeriği Nasıl Çıkartılır
Bu makale içinde aşağıda bulunan belge ile çalışacağız. Gördüğünüz gibi belge içerik çeşitliliği içerir. Ayrıca not alın, belgenin ikinci bölümü ilk sayfanın ortasında başlar. Belgenin bir yer imi ve yorumu da var ancak bu ekran görüntüsünde görünmezler.
İçeriği belgeden ayıklamak için, aşağıdaki ExtractContent
yöntemini çağırmanız ve uygun parametreleri geçirmeniz gerekir.
Bu yöntemin temelini oluşturan, blok seviyesinde bulunan düğümleri ( Paragraflar ve tablolar ) bulup onları aynısını oluşturmak için klonlamaktır. Geçirilen işaretleyici düğümlerin blok seviyesi ise yöntem basitçe içeriği o seviyede kopyalayıp diziye ekleyebilmektedir.
Ancak, işaretleme düğümleri satır içi (bir paragrafın çocuğu) ise durum daha karmaşık hale gelir çünkü satır içi düğümü, bir çalışma alanı, yer imi alanları vb. Ne olursa olsun paragrafı bölmek gerekmektedir. Klon ebeveyn düğümlerinde bulunan ancak işaretler arasında olmayan içerik kaldırılır. Bu işlem, içeriğin ana paragrafın biçimlendirmesini koruyarak satır içi düğümlerde hala kalmasını sağlamak için kullanılır.
Bu yöntem parametreler olarak geçirilen düğümlerde de denetimleri çalıştıracak ve geçersiz bir düğüm varsa bir özel durum atacaktır. Bu yönteme geçirilecek parametreler şunlardır:
-
StartNode ve EndNode. İlk iki parametre içeriğin çıkarılması başlamak ve bitmek için sırasıyla tanımlayan düğümlerdir. Bu düğümler hem blok düzeyinde (Paragraph, Table) hem de satır içi düzeyde (örn. Run, FieldStart, BookmarkStart vb.):
- Bir alanı geçmek için, buna karşılık gelen FieldStart nesnesini geçmelisiniz.
- İşaretlemeleri geçirmek için, BookmarkStart ve BookmarkEnd düğümleri geçirilmelidir.
- Yorumlar geçirmek için, CommentRangeStart ve CommentRangeEnd düğümleri kullanılmalıdır.
-
IsInclusive. Çıkarma işleminde işaretçilerin dahil edilip edilmeyeceğini belirtir. Bu seçenek false olarak ayarlanırsa ve aynı düğüm veya ardışık düğümler geçirilirse boş bir liste döndürülür:
- Eğer bir FieldStart düğümü geçirilirse, bu seçenek, tüm alanın dahil edilip edilmeyeceğini veya dışlanacağını tanımlar.
- Bir BookmarkStart veya BookmarkEnd düğümü geçilirse, bu seçenek yer iminin dahil edilip edilmeyeceğini veya sadece yer imi aralığındaki içeriklerin dahil edilip edilmeyeceğini tanımlar.
- Bir CommentRangeStart veya CommentRangeEnd düğümü geçirilirse bu seçenek, yorumun kendisi dahil edilip edilmeyeceğini ya da yalnızca yorum aralığındaki içeriğin dahil edilip edilmeyeceğini tanımlar.
Bu yöntem uygulamasını ExtractContent bulabilirsiniz here. Bu yöntem bu makalede açıklanan senaryolarda referans verilecektir.
Ekstrakt edilmiş düğümlerden kolayca bir belge oluşturmak için özel bir yöntem tanımlayacağız. Bu yöntem birçok senaryoda kullanılır ve basitçe yeni bir belge oluşturur ve içeriği içeri aktarır.
Aşağıdaki kod örneği, bir düğüm listesi nasıl alınır ve yeni bir belgeye eklenir gösteriyor:
// 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; | |
} |
paragraflar arasındaki içeriği ayıkla
Bu, yukarıdaki yöntemi kullanarak belirli paragraflar arasındaki içeriği nasıl ayıklayacağını göstermektedir. Bu durumda, belgenin ilk yarısındaki bulunan mektubun gövdesini ayıklamak istiyoruz. Bunu 7. ve 11. paragraflar arasında olduğunu söyleyebiliriz.
Aşağıdaki kod bu görevi gerçekleştirir. Uygun paragraflar, belgedeki getChild yöntemini kullanarak ve belirtilen dizinleri geçirerek alınır. Bu düğümler daha sonra ExtractContent yöntemine geçirilir ve bunların eklenmesinin belirtildiği söylenir. Bu yöntem, bu düğümler arasındaki kopyalanmış içeriği döndürecektir. Bu içerik daha sonra yeni bir belgeye eklenecektir.
Aşağıdaki kod örneği, yukarıdaki ExtractContent
yöntemini kullanarak nasıl özel paragraflar arasında içeriği ayıklayacağınızı göstermektedir:
// 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"); |
Çıkış belgesi, çıkarılan iki paragrafı içerir.
Farklı Tiplerdeki Düğümler Arasında İçerik Çıkar
Herhangi bir blok düzeyli veya iç içe geçmiş düğümlerin birleşimi arasındaki içeriği ayıklayabiliriz. Aşağıdaki senaryoda, ilk paragraf ve ikinci bölümde bulunan tablo arasında içerik ayıklayacağız dahil olmak üzere. Belirtilen belgeyi almak için getFirstParagraph ve getChild yöntemini çağırarak uygun Paragraph ve Table düğümlerini alıyoruz. Hafif bir varyasyon için içeriği kopyalayalım ve orijinalin altında yerleştirelim.
Aşağıdaki kod örneği, bir paragraf ile tablo arasındaki içeriği ExtractContent yöntemi kullanarak nasıl ayıklayacağını göstermektedir
// 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"); |
Paragraf ile tablo arasındaki içerik çoğaltılmıştır. Aşağıdaki sonuçtur.
Stil Tabanlı Paragraflar Arası İçerik Çıkar
Paragraflar içinde içerik ayıklamak için aynı veya farklı stillerde paragraflar arasında, örneğin başlık stilleriyle işaretlenmişler arasında ihtiyacınız olabilir.
Aşağıdaki kod bu şekilde elde edilebileceğini gösterir. Bu, “Heading 1” ve “Header 3” stillerinin arasındaki içeriği ayıklamak için bir örnektir, başlıkları da ayıklamaz. Bunu yapmak için son parametreyi false olarak ayarlıyoruz, böylece işaretleyici düğümlerin dahil edilmemesi gerektiğini belirtiriz.
Doğru bir uygulamada, bu tüm bu stillerin paragraflar arasındaki içeriği belgeye eklemek için döngüde çalıştırılmalıdır. Ayıklanan içerik yeni bir belgenin içine kopyalanır.
Aşağıdaki kod örneği ExtractContent yöntemini kullanarak paragraflar arasındaki içeriği nasıl ayıklayacağınızı göstermektedir:
// 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; | |
} |
Aşağıda önceki işlemin sonucu yer almaktadır.
Belirli Çalışmalar Arasında İçeriği Çıkar
Bir satır içi düğümleri gibi, bir Run arasında yer alan içeriği de ayıklayabilirsiniz. Farklı paragraflar için işaretçiler olarak Runs geçilebilir. Aşağıdaki kod, aynı Paragraph düğümü arasında belirli metinlerin nasıl ayıklanacağını gösterir.
Aşağıdaki kod örneği, aynı paragrafta belirli çalıştırmalar arasında içeriği nasıl ayıklayacağınızı gösterir ExtractContent yöntemi:
// 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)); |
Ayıklanan metin konsola gösterilir
İçeriği Bir Alan Kullanarak Ayıkla
Bir alanı bir işaretçi olarak kullanmak için FieldStart
düğümü geçirilmelidir. ExtractContent
yönteminin son parametresi, tüm alanın dahil edilip edilmeyeceğini tanımlamalıdır. Bir belge içinde “FullName” birleştirme alanı ve bir paragraf arasındaki içeriği ayıklayalım. Bu, [moveToMergeField](https://reference.aspose.com/words/java/com.aspose.words/documentbuilder/#moveToMergeField(java.lang.String) sınıfının DocumentBuilder yönteminin FieldStart düğümünü adından geçiren bir yöntemdir.
Eğer bizim durumumuz için son parametreyi ExtractContent yöntemine geçirilen false’e ayarlayalım ve alanı ayıklamayı hariç tutalım. Ayıklanan içeriği PDF olarak sunacağız.
Aşağıdaki kod örneğinde, ExtractContent yöntemini kullanarak belge içinde belirli bir alan ve paragraf arasındaki içeriği nasıl ayıklayacağınız gösterilmiştir:
// 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"); |
Alan ve paragraf arasındaki ayıklanan içerik, alan ve paragraf işareti düğümleri pdf olarak oluşturulmuş.
Bir İşaretçiden İçeriği Çıkar
Bir belgede, bir işaretleyici içinde tanımlanan içerik BookmarkStart
ve BookmarkEnd düğümleri tarafından kapsüllenir. Bu iki düğüm arasındaki bulunan içerik işaretleyiciyi oluşturur. Başlangıç işaretçisi ile bitiş işaretçisi arasında yer alan her işaretçi, başka bir işaretliğin işaretçisi olarak geçebilir, hatta farklı işaretleyicilerde olabilirler, ancak başlangıç işaretçisi bitiş işaretçisinden önce belgede görünecek.
Örnek belge içinde, “Bookmark1” adlı bir imzajız var. Bu imzanın içeriği belgemizdeki vurgulanan içeriktir:
Aşağıdaki kod kullanarak bu içeriği yeni bir belgeye ayıklayacağız. IsInclusive parametre seçeneği, yer imlerini nasıl tutacağınızı veya atacağınızı gösterir.
Aşağıdaki kod örneği, bir yer iminin içeriğini ExtractContent yöntemini kullanarak nasıl ayıklayacağınızı göstermektedir:
// 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"); |
Ayıklanan çıktı IsInclusive
parametresi ile true olarak ayarlandı. Kopyada yer işareti de korunacak.
Çıkarılan çıktı ile IsInclusive parametresi false’e ayarlanmış. Kopyası içeriği içerir ama ekleme işaretlemesi olmadan.
Yorumdan İçeriği Çıkar
Bir açıklama KommentRangeStart, KommentRangeEnd ve Komment düğümlerinden oluşur. Tüm bu düğümler dizedir. İlk iki düğüm yorum yapılan belgenin içeriğini kapsülleyen düğümlerdir, bunun ekran görüntüsü aşağıda gösterilmiştir.
Comment düğümü kendisinin bir InlineStory olarak paragraflar ve bölümler içerebilir. İnceleme penceresinde yorum kabarcığı olarak görülen mesajı temsil eder. Bu düğüm satır içi ve bir gövdenin nesnesi olduğu için bu mesaj içindeki içeriği de ayıklayabilirsiniz.
Aletimizde bir yorumumuz var. İnceleme sekmesinde gösterilen mark-up ile görüntüleyelim:
Yoruma başlık, ilk paragraf ve ikinci bölümde bulunan tablo kapsüllenir. Bu yorumu yeni bir belgeye ayıklayalım. IsInclusive seçeneği yorumun kendisinin korunup korunmayacağını belirtir.
Aşağıdaki kod örneğinin bunu nasıl yapılacağını gösterdiğini gösteriyor:
// 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"); |
İlk olarak, parametre ayarı IsInclusive
ile çıkarılan çıktı true’e. Kopyası, yorumu da içerecek.
İkinci olarak, İnclusive ayarlanmış ekstra çıktı false. Kopyası içerik içerir ancak yorum olmadan.
DocumentVisitor kullanarak İçeriği Çıkar
Aspose.Words yalnızca dinamik olarak oluşturma veya şablonları veri ile birleştirme yoluyla Microsoft Word belgeleri oluşturmak için değil, aynı zamanda başlıklar, altbilgiler, paragraflar, tablolar, resimler ve diğerleri gibi ayrı belge öğelerini ayıklamak için ayrıştırmak üzere de kullanılabilir. Başka bir mümkün görev tüm özel biçimlendirme veya stil içeren metinleri bulmaktır.
Bu kullanım durumunu uygulamak için DocumentVisitor sınıfını kullanın. Bu sınıf iyi bilinen Ziyaretçi tasarım desenine karşılık gelir. DocumentVisitor ile, belge ağacında yineleme gerektiren özel işlemleri tanımlayabilir ve uygulayabilirsiniz.
DocumentVisitor belirli bir belge öğesi (düğüm) karşılaştığında çağrılan bir dizi VisitXXX yöntemini sağlar. Örneğin, “VisitParagraphStart” bir metin paragrafının başlangıcını bulduğunda ve “VisitParagraphEnd” bir metin paragrafının bitişini bulduğunda çağrılır. Her DocumentVisitor.VisitXXX yöntemi karşılaştığı ilgili nesneyi kabul eder böylece ihtiyacınız olan şekilde kullanabilirsiniz (örneğin biçimlendirmeyi al) örneğin hem VisitParagraphStart hem de VisitParagraphEnd bir Paragraph nesnesini kabul eder.
Her DocumentVisitor.VisitXXX yöntemi, düğümlerin sıralanmasını kontrol eden bir VisitorAction değeri döndürür. Devam etmemeyi, geçerli düğüme atlamayı (ama sıralamanın devam etmesini) veya düğümlerin sıralamasını durdurmayı talep edebilirsiniz.
Bu, programlı olarak bir belgeden çeşitli parçaların belirlenmesi ve çıkarılması için izlenmesi gereken adımlardır:
- DocumentVisitor‘den türetilmiş bir sınıf oluşturun.
- DocumentVisitor.VisitXXX yöntemleri için geçersiz kılma ve özel işlemler gerçekleştirmek için bunların bazılarını veya tamamını uygulayın.
- Node.accept‘den saymaya başlamak istediğiniz düğümde çağrı yapın. Örneğin, tüm belgenin numaralandırılmasını istiyorsanız, accept(DocumentVisitor)‘i kullanın.
DocumentVisitor tüm DocumentVisitor.VisitXXX yöntemleri için varsayılan uygulamalar sağlar. Bu, yeni belge ziyaretçilerinin oluşturulmasını kolaylaştırır çünkü yalnızca belirli bir ziyaretçi için gerekli olan yöntemlerin geçersiz kılınması gerekir. Tüm ziyaretçi yöntemlerinin geçersiz kılınmasına gerek yoktur.
Aşağıdaki örnek, Aspose.Words nesne modeline yeni işlemler eklemek için Ziyaretçi deseninin nasıl kullanılacağını göstermektedir. Bu durumda, basit bir metin biçimine dönüştürmek için bir belge dönüştürücüsü oluşturuyoruz:
// 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; | |
} |
Yalnızca Metni Çıkar
Metni belgezdenden almak için yollar şunlardır:
- Document.save ile SaveFormat‘i düz metin olarak bir dosyaya veya akışa kaydetmek için kullanın
- Node.toString kullanın ve
SaveFormat.Text
parametresini geçirin. İçsel olarak bu metin olarak kaydetme bir bellek akışına çağrıda bulunur ve sonuçtaki dize döndürülür - Tüm Microsoft Word denetim karakterleri dahil alan kodlarıyla birlikte metin almak için Node.getText kullanın
- Özelleştirilmiş bir DocumentVisitor uygulayın özelleştirilmiş ayıklama yapmak için
Node.GetText
ve Node.ToString
kullanmak
Bir Word belgesinde alan, hücre sonu, bölüm sonu vb. gibi özel öğeleri belirten kontrol karakterleri içerebilir. Olası Word kontrol karakterleri kümesinin tamamı ControlChar sınıfında tanımlanmıştır. GetText yöntemi, düğümdeki tüm kontrol karakterlerinin bulunduğu metni döndürür.
Calling ToString döndürür sadece kontrol karakterleri olmadan belge için düz metin gösterimini." “Düz metin olarak dışa aktarma hakkında daha fazla bilgi için Using SaveFormat.Text bakın.
Aşağıdaki kod örneği, bir düğümde GetText ve ToString yöntemlerini çağırmanın arasındaki farkı göstermektedir:
// 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)); |
SaveFormat.Text
kullanmak
Bu örnek, belgeri şu şekilde kaydeder:
- Alan karakterleri ve alan kodlarını filtreler, şekil, not, sonnot ve yorum referansları
- Paragraflardan ControlChar.Cr karakter, ControlChar.CrLf kombinasyon ile değiştirir
- UTF8 kodlamasını kullanır
Aşağıdaki kod örneği bir belgenin TXT formatında nasıl kaydedileceğini göstermektedir:
// 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"); |
Şekillerden Görüntü Çıkar
Belge resimlerini ayıklamak bazı görevleri gerçekleştirmek için gerekebilir. Aspose.Words bunu yapmanıza da izin verir.
Aşağıdaki kod örneği bir belgeden nasıl resim ayıklanacağını gösterir:
// 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++; | |
} | |
} |