Cocoon 1 ve Cocoon 2

Ali GAZİOĞLU
20021871
COCOON 2’ye GİRİŞ
İçindekiler
1. Giriş
Cocoon Nedir?
Cocoon 1 ve Cocoon 2
2. Cocoon’u Kurmak ve Ayarlamak
Tomcat’i kurmak
Cocoon hızlı kurma işlemi
3. Cocoon 2 Mimarisi
Giriş
Pipeline modeli
Pipeline Bileşenleri
Girdiler: Üreticiler ve Okuyucular
İşleme: Dönüştürücüler ve Eylemler(Actions)
Çıktılar: Serileştiriciler
Koşullu İşlemler: Eşleyiciler ve Seçiciler
Pipeline’ı Çalıştırmak
4. Sitemap’in Temelleri
Sitemap’in Görevleri
Sitemap’in Yapısı
Sitemap Bileşenlerinin Tanımlanması
Genişleyebilirlik
5. Sitemap: Pipeline’ları tanımlamak
Sitemap Ayarları
Bileşen Tanımlamaları
Durağan Bir Belgenin Sunulması
Wildcard’ların Kullanımı
Dönüşüm Yapma İşlemi
Diğer Çıktı Biçimlerinin Oluşturulması
Parametrelerin Aktarımı
KAYNAKLAR
Bölüm 1
Giriş
Cocoon Nedir?
Cocoon; XSLT (XML Stylesheet Language-Transformation) dönüşümlerini
kullanarak XML içeriğinin dinamik yayınını sağlayan bir Java sunucu yapısıdır.
Cocoon, içeriğini tanımlamak için XML’i, bu içeriği çeşitli biçimlere dönüştürmek için
XSLT’yi kullanarak ; içerik,mantık ve sunum arasında güçlü bir ayırım yeteneğine
sahip uygulamalar geliştirebileceğimiz bir platform sağlar.
Cocoon ağa içerik yayınlamada pipeline anlayışını kullanır. Geniş bir bileşen çeşitliliği
sunar ve bu bileşenlerin ayarlanması ile, fazla bir geliştirim süresi harcanmadan
karmaşık işlemlerin yapılmasını sağlar.
Örneğin yalnızca XML ve XSLT kullanılarak Cocoon
ƒ
ƒ
ƒ
ƒ
Dinamik olarak yaratılan sonuçları sunabildiği gibi durağan kütüklerin
yayınlanmasını da sağlayabilir.
Basit ve çok kademeli XSLT dönüşümleri yapar.
Parametrelerin dinamik olarak XSLT dönüşümlerine geçirilmesini sağlar.
XML, HTML, PNG, JPEG, SVG,ve PDF gibi pek çok türde çıktı
oluşturulabilir.
Cocoon sayesinde olabilecek en az karmaşıklıkla dinamik web siteleri yaratmak
mümkündür.
Cocoon 1 ve Cocoon 2
Cocoon, Apache XML çalışmasının bir parçası olarak geliştirilen serbest kaynak
kodlu bir projedir. Cocoon 2 orijinal cocoon projesinin güncellenerek yeniden yazılmış
halidir ve kullanılması tavsiye edilen sürümüdür. Mevcut Cocoon 1 kullanıcıları
cocoon 2 ye geçmeli ve yeni kullanıcılar doğrudan Cocoon 2 ile başlamalıdır.
Cocoon 2’nin geliştirim amacı Cocoon 1’in geliştirimi sırasında alınan dersleri
kullanarak daha verimli ve ölçeklenebilir bir platform geliştirmektir. Cocoon 1 XML
verilerinin parçalar arasındaki iletişimini sağlamak için Belge Nesne
Modeli(Document Object Model - DOM -) API’sine dayanır. DOM,veri aktarımı için
etkisiz bir yoldur çünkü tipik bir DOM ağacı orijinal XML belgelerinden birkaç kat daha
fazla bellek tüketebilir. Bu durum Cocoon’un ölçeklenebililirliğini kısıtlıyordu. Cocoon
2, XML verilerini işlemenin daha verimli bir yolu olan SAX 2 üzerine kurulmuştur.
Cocoon’un bu iki sürümü arasındaki bir diğer önemli farklılık uygulama yönetimidir.
Cocoon 1 de; XML belgeleri, Cocoon işleme komutlarıyla nasıl işleneceklerine göre
tanımlanırlar. Bu durum belgelerin Cocoon 1’e özel bir şekilde düzenlenmelerine yol
açarak içeriğin farklı şekillerde yeniden kullanılma esnekliğini kısıtlar. Cocoon 2,
işlem yönetimini sitemap olarak bilinen bir ayar kütüğüne kaydeder.
Bu durum, işlem mantığının içerikten ayrılmasını sağlar. Böylece içerik,mantık ve
sunum birbirinden ayrılmış olur.
Cocoon 2, orjinal Cocoon uygulamasından daha ölçeklenebilir ve esnek bir platform
olduğu için bu belgenin konusudur.
Bölüm 2
Cocoon’u Kurmak ve Ayarlamak
Tomcat’i kurmak
Bu bölüm, Jakarta Tomcat servlet motorunun nasıl kurulacağının anlatan talimatlarla
başlamaktadır. Bölümün geri kalan kısmı, Cocoon 2 nin nasıl indirilip, kurulup,
ayarlanacağını anlatır. Cocoon’un doğrudan kaynak kodunu derleyerek veya hazır bir
kurulumunu kullanarak nasıl kurulacağını açıklar. Jakarta Tomcat 4.0.1 in son
sürümüne http://jakarta.apache.org/builds/jakarta-tomcat-4.0/release/
bağlantısından erişilebilir.
Jakarta Tomcat’in hazır kurulumunu indirdikten sonra yapılması gereken tek şey
sıkıştırılmış kütüğü bir dizine açmaktır.
Bu dizine işaret eden bir değişken (CATALINA_HOME) oluşturulur.
Örneğin :
CATALINA_HOME=/usr/local/jarkarta-tomcat-4.0.1.
Tomcat, $CATALINA_HOME/bin dizinindeki script’leri kullanarak başlatılabilir ve
kapatılabilir. Tomcat başlangıçta port 8080’i kullanacak şekilde ayarlanmıştır. Bu
port’un kullanımının bir çakışmaya yol açması durumunda;
$CATALINA_HOME/conf/server.xml belgesindeki “8080” değeri uygun bir değerle
değiştirilebilir.
Tomcat, $CATALINA_HOME/bin/startup.sh scriptini kullanarak başlatıldığında,
kurma işleminin sonucu http://localhost:8080 sayfasına girilerek test edilebilir. Eğer
kurma işlemi başarıyla sonuçlanmışsa bir açılış sayfası gözükür.
Cocoon hızlı kurma işlemi
Cocoon 2, http://xml.apache.org/cocoon/dist/. bağlantısından hazır olarak da elde
edilebilir. Kütüğü indirip uygun bir dizine açtıktan sonra, cocoon.war kütüğünü bulmak
gerekir. Bu kütük servlet motoru içine yerleşebilen Cocoon Web uygulama arşividir.
Cocoon u, Tomcat içine yerleştirmek basittir.
Eğer Tomcat çalışıyorsa, öncelikle $CATALINA_HOME/bin/shutdown.sh scripti
kullanılarak kapatılmalıdır.
Daha sonra, cocoon.war kütüğü, $CATALINA_HOME/webapps dizinine
kopyalanmalı ve daha sonra Tomcat başlatılmalıdır.
Tomcat Web arşivini otomatik olarak $CATALINA_HOME/webapps/cocoon yoluna
açar. Kurma işlemi http://localhost:8080/cocoon/ bağlantısına bağlanarak sınanabilir.
Sunucu ayar kütüklerini derlerken bir duraklama olacaktır.
Bölüm 3
Cocoon 2 Mimarisi
Giriş
Bu bölümde Cocoon 2 mimarisinin temel ilkeleri üzerinde durulacaktır.
İlk olarak, bir XML belgesini işlemek birkaç bağımsız adıma bölünebilir. Bu adımların
birleşimiyle bir pipeline oluşur. Bu pipeline; girdi, işlem ve çıktı oluşturma adımlarını
içerir. Cocoon 2 bu adımlar arasındaki bağlantıyı SAX olaylarını(SAX events)
kullanarak sağlar.
Pipeline’daki her bir aşama farklı bileşenler kullanılarak modellenebilir. Mesela girdi
üretmek için bir üretici (generator) ve çıktı üretmek için de bir dizileştirici (serializer)
kullanılabilir. Cocoon birden fazla bileşen, ve her bir bileşen için birçok gerçekleştirim
yolu sunar.
Kullanıcı istemlerine yanıt vermek için doğru pipeline’ı saptamak (girdilere göre) ve o
pipeline’ın istemciye sonuç üretmek için komutlarla yönlendirmek gereklidir.
Pipeline modeli
Cocoon 2 mimarisini gözden geçirdiğimizde, bu mimarinin öne çıkan özelliği
pipeline’dır. Bir pipeline bir girdi verisi ve bu veriyi işleyen bir işlem dizisinden oluşur.
Her bir işlem adımı bir öncekinin çıktısını girdi olarak kabul eder ve bu işlem son çıktı
üretilene kadar devam eder.
Karmaşık bir işlemi, daha küçük alt adımlara bölmek basit bir işlemdir. Bu işlem find,
grep, sort gibi basit işlemleri bir araya getirerek görevler yaratan UNIX kullanıcılarına
tanıdık gelecektir.
Bu da bize pipeline’ın başka bir olası faydasını örnekler. Çünkü her işlem adımı
düzenli bir şekilde tanımlanmış davranışlar ve sabit girdi-çıktılar içerir. Böylece genel
amaçlı ve yeniden kullanılabilir pipeline bileşenleri elde edilebilir. Bu yeniden
kullanılabilirlik az kod yazarak uygulama geliştirilmesine olanak sağlamaktadır.
Pipeline Bileşenleri
Cocoon birbirilerine verimli şekillerde bağlanabilen genel pipeline bileşenleri içerir. Bu
bileşenler pipeline’da oynadıkları rollere göre çok farklı şekillerde gruplanabilirler.
•
•
•
•
Pipeline girdileri
İşlem adımları
Pipeline çıktıları
Koşullu işlemler
-Üreticiler (generators) ve okuyucular (readers)
-Dönüştürücüler (transformers) ve eylemler (actions)
-Serileştiriciler(serializers)
-Eşleyiciler (matchers) ve seçiciler (selectors)
Bir Cocoon pipeline, genellikle en az bir üretici ve bir serileştiriciden oluşur, fakat
birden fazla işlem adımından da oluşabilir. Veri, Cocoon pipeline’ından bir SAX olayı
olarak geçirilir.
Girdiler: Üreticiler ve Okuyucular
Üreticiler, veri kaynağını okumakla (örneğin bir kütük) ve o veriyi bir SAX olayları
dizisi olarak pipeline’a geçirmekle sorumludurlar. En basit üretici SAX parser’dır. SAX
olaylarının serisi olarak gösterilebilen herhangi bir veri kaynağı bir üreticinin temelini
oluşturabilir.
Cocoon içinde birkaç tane kullanılabilir üretici vardır. Bunların arasında en faydalıları:
•
•
•
Kütük üreticileri(FileGenerator): XML kütüklerini kütük sistemlerinden veya
Web’den okurlar.
HTML üreticileri: HTML kütüklerini kütük sistemlerinden veya Web’den
okurlar.
Dizin üreticisi : Dizin listesini oluşturmak için kütük sistemlerini okur.
Okuyucular Cocoon pipeline modelinde özel bir durum teşkil eder. Çünkü okuyucular
XML’den bağımsızdır. Okuyucuların tek yaptığı, harici bir kaynağa erişip veriyi
doğrudan yanıt olarak kopyalamaktır.
Bunlar genellikle resim veya CSS stylesheets gibi durağan kütükleri sunmak için
kullanılır. Okuyucular kendi içlerinde birer pipeline gibi görülebilirler; girdi verisini
oluşturup,bunu sonuç olarak serileştirirler.
İşleme: Dönüştürücüler ve Eylemler(Actions)
Dönüştürücüler, Cocoon pipeline içerisinde temel işlem adımlarını oluşturur. SAX
olaylarını girdi olarak kabul eder, bu girdi üzerinde işlemler yapar ve sonuçları SAX
olayları olarak pipeline’a geçirir.Bir dönüştürücü, SAX olaylarını işleyip değiştiren bir
bileşen olarak da tanımlanabilir. Bu bakış açısıyla, dönüştürücülerin SAX filtrelerine
benzer işlemler yaptığını söyleyebiliriz.
En çok kullanılan dönüştürücü XSLT dönüştürücüsüdür. Kendi girdisini XSLT
dönüşümlerini yapan XSLT işleyicilerine verir. Dönüşümün sonuçları da SAX olayları
olarak pipeline’a girer.
Eylemler, pipeline’ların daha dinamik yapılara kavuşmasını sağlar ve genellikle
uygulamaya özel hazırlanırlar. Yine de Cocoon bazı genel eylemleri içinde barındırır.
Mesela veri tabanı etkileşimlerini sağlamak, mail yollamak gibi.
Bir eylemin başarıyla tamamlanması işlemin ilerleyen adımları da etkiler.
Çıktılar: Serileştiriciler
Serileştiriciler, Cocoon pipeline’nın son aşamasıdır. Serileştiriciler bir üretici
tarafından üretilmiş veya bir önceki işlem adımından (örneğin bir dönüştürücü) çıktı
olarak üretilmiş bir SAX olayları dizisini alıp uygun bir biçime sokmakla görevlidirler.
Bu uygun biçim kullanılan serileştiriciye bağlıdır.
En basit serileştirici, SAX olaylarını XML kütüklerine dönüştüren XML serileştiricisidir.
Diğer serileştiriciler HTML, düz metin , PDF kütükleri ve hatta resimler üretebilirler.
Bütün bu serileştiriciler; SAX olayı akışının, özel bir XML sözdizimine uygun hale
getirildiğini varsayarlar :
•
•
•
HTML serileştiricisi: XHTML’yi geçerli HTML’ye dönüştürür.
SVG serileştiricisi: SVG kütüklerini JPEG yada PNG formatına dönüştürür.
PDF serileştiricisi: XSL-FO’yu PDF kütüklerine dönüştürür.
XML bileşenlerini alma, işleme ve çeşitli biçimlerde sunma Cocoon’un esas
özelliğidir.
Koşullu İşlemler: Eşleyiciler ve Seçiciler
Bir pipeline genellikle bazı koşullu kesimler içerir. Örneğin işlem adımlarını tam olarak
oluşturmak; istem parametreleri ve kullanıcının kullandığı browser gibi koşullara
bağlıdır.
Eşleyiciler, bu iki koşullu bileşenin basit olanıdır ve programa dillerinden tanıdık
olduğumuz “if” ifadesine karşılık gelirler. Koşulların kontrol edilmesiyle bir pipeline
seçilir yada pipeline’nın bir bölümü işleme alınır.
Diğer koşullu bileşen ise “if-then-else” ifadesine karşılık gelen seçicilerdir. Seçiciler,
birden fazla seçenekten biri uygunsa kullanılır. Eşleyiciler bir pipeline’a girilip
girilmeyeceğini anlamakta kullanılırken, seçiciler genellikle bir pipeline içerisinde
koşullu kesimler oluşturmakta kullanılır.
Bu bileşenlerin her birinin değişik uygulamaları vardır. Hepsi, istemleri(usr-agent,
hostname, parametreler veya URL gibi) ya da kullanıcının oturumunu sınamak için
ortak bir örüntüyü kullanır. Seçiciler, bütün olabilecek koşulları sınar ; eşleme işlemi
ise wildcard veya sıradan ifadeler kullanarak yapılabilir.
Pipeline’ı Çalıştırmak
Cocoon pipeline’larını oluşturmakta kullanılan bileşenleri gördük.İstemlerin alınması
ve sonuçların sunulması işlemini oluşturan mantıksal çevrim şu şekilde
özetlenebilir:
1. Kullanıcıdan istemi al.
2. Bu istemi yorumlamak ve yanıt oluşturmak için kullanılacak doğru pipeline’ı
belirle.(eşleyici kullanarak)
3. Uygun,önceden tanımlanmış bileşenleri kullanarak pipeline oluştur.
4. İstemi karşılaması için pipeline’a komut ver.
5. Pipeline tarafından oluşturulan yanıtı kullanıcıya döndür. (Sonuçlar
muhtemelen sonraki kullanımlar için önbelleğe alınır.)
Bu, Cocoon’un XML verilerini Web’de yayınlamak için kullandığı temel istem-yanıt
çevrimidir. Bu çevrimi yönetmek için Cocoon, sitemap denilen bir XML ayar kütüğü
sağlar.
Bu bölümde, Cocoon pipeline’larını oluşturmak için sıkça kullanılan bileşenlerin
yalnızca bir kısmı gözden geçirildi. Yeniden kullanılabilir bu bileşenler, pipeline
modelinin bir avantajıdır ve bu bileşenlerin kullanılması gelişmiş işlem mantığının hiç
yada çok az programlamayla oluşturulmasına sağlar (XSLT style sheet’lerin
oluşturulması hariç).
Bölüm 4
Sitemap’in Temelleri
Sitemap’in Görevleri
Sitemap, Cocoon Web sitesinin yönetildiği merkezdir. İki görevi yerine getirir.
SiteMap:
• Bileşenlerin pipeline içinde kullanılmadan önce tanımlandığı yerdir.
• Pipeline’ların bileşenleri kullanarak tanımlandığı yerdir.
Bu bölüm, bu görevlerin birincisi üzerinde durur ve sitemap’in temel yapısını anlatır.
Sitemap’in Yapısı
Sitemap, bir ayar kütüğüdür ve doğası gereği iyi tanımlanmış bir yapıya sahiptir.
Varsayılan Cocoon sitemap’i (sitemap.xmap), Cocoon Web uygulama dizininden
bulunabilir:
$CATALINA_HOME/webapps/cocoon/sitemap.xmap
Sitemap, aşağıda yazılı olan XML parçasında verilen ana şekle göre yapılandırılır.
Özel bir sitemap namespace olduğuna dikkat çekmek gerekir.
http://apache.org/cocoon/sitemap/1.0 , sitemap unsurlarını belirlemede kullanılır.
Sitemap, belirtilen bu iki görevini belirten iki ileri düzey bölüme ayrılmıştır;
map:components ve map:pipelines.
<map:sitemap
xmlns:map="http://apache.org/cocoon/sitemap/1.0">
<map:components>
<!—bileşen tanımları -->
<map:generators/>
<map:readers/>
<map:transformers/>
<map:actions/>
<map:serializers/>
<map:actions/>
<map:matchers/>
<map:selectors/>
</map:components>
<map:pipelines>
<!-- pipeline tanımları -->
</map:pipelines>
</map:sitemap>
Her türdeki bileşen için yapılan tanımlamalar belirli ana başlıklarla gruplandırılırlar.
Örneğin, bütün üreticilerin tanımlamaları map:generators başlığı altında bulunabilir.
Sitemap Bileşenlerinin Tanımlanması
Bileşenler, sitemap’te aşağıdaki örnekte belirtilen genel bir sözdizimiyle tanımlanır.
•
•
•
•
•
Component-type, bileşenin türüdür. Örneğin; üretici elemanı üretici tanımlarını
içerir.
Her bileşenin biricik bir nitelik olarak bir adı olmalıdır. Bileşen isimleri
sitemap’te bileşenlere erişmek için kullanılır.
Her bileşen kendi gerçekleştirimini bilmelidir. Aynı gerçekleştirime sahip fakat
farklı isimlerle tanımlanmış birden fazla bileşen içerilmesi mümkündür.
Varsayılan bir bileşen sistem tarafından tanınabilir. Bu durum bileşene isim
verilmediği zaman işimize yarar.
Bileşenler, parametre geçirebilirler. Bu nedenle aynı bileşeni farklı
parametrelerle kullanmak mümkündür. Parametreler bileşenleri birbirinden
ayırt etmekte kullanılabilir.
<map:component-types
default="bileşen_adı">
<map:component-type
name="bileşen_adı"
src="implementation">
<!— bileşen türü
parametreler -->
</map:component-type>
</map:component-types>
Bileşen tanımlarının özel örnekleri için, default sitemap’in 1.bölümünü okuyunuz.
$CATALINA_HOME/webapps/cocoon/sitemap.xmap
Genişleyebilirlik
Cocoon, sitemap’teki tanımlamalarla belirtilen bileşenleri Java’nın dinamik sınıf
yükleme yeteneğini kullanarak yükler. Her bileşen dinamik olarak yüklenebilmek ve
pipeline’a yerleştirilmek için, kendi türüne göre değişen bir Java arayüzünü(interface)
implement etmelidir. Örneğin, bütün üreticiler aşağıdaki interface’i implement etmek
zorundadır.
org.apache.cocoon.generation.Generator
Bileşen türlerini tanımlamak için ara yüzlerin esas alınması , Cocoon’un
yeteneklerinin, bu ara yüzlerin yeni gerçekleştirimlerini yazarak ve sitemap’e uygun
tanımlamalar ekleyerek kolayca genişletilebilmesini sağlar.
Şu basit senaryoyu göz önüne alalım:
Hem orijinal haliyle hem de HTML şeklinde sunulabilmesi gereken CSV (comma
seperated values – virgülle ayrılmış veri) türünde büyük miktarda verimiz var. Bir
yaklaşım, CSV verisini okuyan ve onu XML haline dönüştüren bir uygulama yazmak
olacaktır. Bu yaklaşım bize, hem esas veriyi ham haliyle, hem de XML olarak
saklama gibi fazladan bir yük yükler. Bunun yanı sıra yeni veri geldikçe onu XML
haline dönüştürme işlemi de sistemin taşıması gereken fazladan bir yüktür.
Cocoon ile bu soruna daha verimli bir çözüm üretilebilir. CSV verilerini doğrudan SAX
olayları haline getiren bir dönüştürücü yazmak mantıklı bir çözüm olacaktır.
(com.mycompany.CSVGenerator) Bu sınıf sitemap’in içinde tanımlanarak, aşağıda
gösterildiği gibi Cocoon’a entegre edilebilir.
<map:generator name="csv" src="com.mycompany.CSVGenerator"/>
Bu bileşen, artık pek çok türe dönüştürülebildiği, kullanabildiği ve serileştirilebildiği
CSV verilerini Cocoon pipeline’larına girdi olarak vermekte kullanılabilir. Yine de esas
CSV kütüğü READER bileşeni kullanılarak okunabilir. Çünkü sadece bir tane kaynak
veri kütüğü var ve bütün dinamik dönüşümler Cocoon tarafından sağlanıyor. Gereksiz
veri yönetimi yükünden kurtulmuş oluyoruz. Bu örnek pek çok farklı belge biçimi için
genişletilebilir ve içerik yönetim sistemlerinden belgeleri okumak için kullanılabilir. Bu
da Cocoon’un genişleyebilirlik yeteneğini ortaya koyar.
5. Bölüm
Sitemap: Pipeline’ları tanımlamak
Sitemap Ayarları
Bu bölümde, önceki bölümlerde tanıtılan bileşenlerin verimli bir şekilde kullanılmak
amacıyla nasıl bir araya getirilebileceklerini gösteren birkaç örnek içermektedir. Bu
bölümde özel dönüşümler ve XML türlerinin detaylarından ziyade Cocoon sitemap
ayarları üzerinde durulacaktır.
Örnekler, aşağıdaki dizin yapısının $CATALINA_HOME/webapps/cocoon ( bu
noktadan itibaren bu yol $COCOON_HOME olarak kabul edilecektir) dizini altında
oluşturulduğunu varsaymaktadırlar.
/static Durağan HTML belgesi
/content XML içeriği
/styles CSS style sheets
/transforms XSLT style sheets
İpucu: Cocoon ile çalışırken,
$CATALINA_HOME/webapps/cocoon-dev altında bir dizin oluşturun. Daha sonra
gerekli bütün Cocoon sınıflarını kapsayan $COCOON_HOME/cocoon.xconf ve
$COCOON_HOME/WEB-INF dizilerini bu dizin altına kopyalayın. Böylece temiz bir
çalışma ortamı oluşturmuş oluruz. Bu şekilde,
http://localhost:8080/cocoon-dev/ bağlantısından erişilebilecek ayrı bir
Cocoon Web uygulaması oluşturulur.
Son olarak, bu dizin içinde yeni bir sitemap.xmap oluşturun. Böylece çalışmalar,
orijinal örnek ve belgeleri bozmadan yapılabilir.
Bileşen Tanımlamaları
Aşağıdaki ayar örnekleri, tanımlamalarının sitemap içinde yapıldığı varsayılarak
verilmiştir :
<map:generators default="file">
<map:generator name="file"
src="org.apache.cocoon.generation.FileGenerator"/>
</map:generators>
<map:transformers default="xslt">
<map:transformer name="xslt"
src="org.apache.cocoon.transformation.TraxTransformer"/>
</map:transformers>
<map:readers default="resource">
<map:reader name="resource"
src="org.apache.cocoon.reading.ResourceReader"/>
</map:readers>
<map:serializers default="html">
<map:serializer name="xml" mime-type="text/xml"
src="org.apache.cocoon.serialization.XMLSerializer"/>
<map:serializer name="html" mime-type="text/html"
src="org.apache.cocoon.serialization.HTMLSerializer"/>
<map:serializer name="svg2png"
src="org.apache.cocoon.serialization.SVGSerializer" mime<map:serializer name="fo2pdf"
src="org.apache.cocoon.serialization.FOPSerializer" mimetype="</map:serializers>
<map:matchers default="wildcard">
<map:matcher name="wildcard"
src="org.apache.cocoon.matching.WildcardURIMatcher"/>
</map:matchers>
Durağan Bir Belgenin Sunulması
Cocoon kullanarak durağan bir belgenin sunumunu yapmak başlangıç için iyi bir
örnektir.
Aşağıdaki pipeline tanımlaması, bunun bir okuyucu kullanarak nasıl yapıldığını
gösterir. Açıkçası ,mevcut Web sunucusunun durağan kütükleri ele almasını
sağlamak tercih edilen yöntemdir, fakat bu konu bize pipeline’larla çalışma
konusunda basit bir örnek sağlayabilir.
<map:pipelines>
<map:pipeline>
<map:match pattern="index.html">
<map:read src="static/index.html" mime-type="text/html"/>
</map:match>
</map:pipeline>
<map:pipelines>
İlk olarak, tüm pipeline tanımlarının map:pipelines elemanının bir çocuğu olan
map:pipeline kullanılarak yapıldığını görmek gerekir.
Eşleyici bileşen, bir eşleme örüntüsü kullanarak pipeline ile istemi eşeleştirmekte
kullanılır. Bu örnekte, "index.html" (http://localhost:8080/cocoon/index.html)
belgesi için yapılacak bir istem pipeline’ı tetikleyecektir.
Daha sonra, pipeline tetiklendiğinde yapılması gereken işlem tanımlanır. Burada
okuyucu(reader) bileşenine, $COCOON_HOME/static/index.html kütüğünü mimetype text/html ile kullanıcıya göndermesi için komut verilir. Kütüğün yeri, onu
istemek için kullanılan URL yolundan tamamen bağımsızdır.
Bir kütüğü bir pipeline ile bu şekilde ilişkilendirmek çok zahmetli bir işlem olacaktır.
Fakat eşleyici bileşen bu işlemlerden kurtarır.
Wildcard’ların Kullanımı
Başlangıçtaki örnek, istenmiş URL parçalarını eşleştirmek için wildcard’ların
kullanımını göstermek amacıyla genişletilebilir. Pipeline, HTML belgeleri gibi CSS
stylesheets’e de erişimi sağlamak için bir parça genişletilmiştir. Bu işlemi yapmak
için, mevcut pipeline’a fazladan bir eşleyici eklemek gerekir. Bu durum yeni bir
pipeline tanımlamakla aynı maliyete sahiptir. Çünkü Cocoon tüm örüntüleri
sınayacaktır.
<map:pipeline>
<map:match pattern="*.css">
<map:read src="styles/{1}.css" mime-type="text/css"/>
</map:match>
<map:match pattern="**.html">
<map:read src="static/{1}.html" mime-type="text/html"/>
</map:match>
</map:pipeline>
Wildcard eşleyicisi iki çeşit wildcard’ın kullanımına izin verir. Başlangıçta bir asterisk
forward slash(/) dışındaki bütün karakterleri eşler. Çift asteriks ise forward slash dahil
tüm karakterleri eşler. Bu örüntülerle eşleştirilmiş metin diğer sitemap bileşenleriyle
uyumludur ve kullanılan wildcard sayısına göre {1}, {2}, {3}… şeklinde
erişilebilir durumdadır.
Yukarıdaki örnekte, http://localhost:8080/mysite.css bağlantısına
yapılacak bir istem, CSS örüntüsünü eşleyecek ve "mysite" ın değeri {1} olarak
atanacaktır. Daha sonra okuyucu(reader) $COCOON_HOME/styles/mysite.css ’i
doğru mime-type ile kullanıcıya gönderecektir.
http://localhost:8080/styles/mysite.css bağlantısına yapılacak bir
istem tek bir asterisk belirttiği için örüntüyle eşleşmez.
Geliştirilmiş HTML eşleme örüntüsü, wildcard gibi çift asterisk kullanır. Böylece
http://localhost:8080/help/help.html bağlantısına yapılan bir istem başarıyla
eşleştirilmiş olacaktır ve help/help değeri {1} olarak atanacaktır. Daha sonra
okuyucu, $COCOON_HOME/static/help/help.html ’i kullanıcıya geri gönderecektir.
Cocoon, eşleştirme örüntülerini sitemap’te tanımlanmış olan sıra ile çalıştırır.
Cocoon, başarıyla eşleştirilen ilk örüntüye göre istemi işler. Yani, sitemap’teki sıra
anlamlı bir sıradır ve ilk önce ele alınması gereken eşleşmeler; en anlamlı
eşleşmeler, yani türe özel eşleşmeler olmalıdır. Örneğin, index.html için, bir
eşleştirme örüntüsü *.html ‘den önce tanımlanmalıdır.Aksi takdirde eşelşme
sağlanamaz.
Dönüşüm Yapma İşlemi
Bir dönüşüm için en az üç bileşen gereklidir:
XML belgelerini okumak için bir üretici,
dönüşümü sağlamak için bir dönüştürücü ve
sonuçları oluşturmak için bir serileştirici. Aşağıda, dönüşümü sağlamak için nasıl
birleştirildikleri gösterilmektedir.
İlk olarak pipeline’ı ve onu tetiklemekte kullanılan örüntüyü tanımlanmalıdır.
<map:pipe>
<map:match pattern="content/*.html">
Sonra XML belgelerini içerik dizininden okumak için, bir üretici eklenmelidir.
<map:generate src="content/{1}.xml"/>
Daha sonra XML belgelerini belirtilen bir style sheet’i kullanarak dönüştürecek bir
dönüştürücü eklenmelidir.
<map:transform src="transforms/content2html.xsl"/>
Son olarak, dönüşümün sonuçlarını HTML belgesine çevirmek için bir serileştirici
kullanılmalıdır
<map:serialize type="html"/>
</map:match>
</map:pipe>
//localhost:8080/content/document.html URL sine istem yapmak pipeline’ı
tetikleyecek ve Cocoon’un ilk önce document.xml i oluşturmasını sağlayacaktır. Daha
sonra Cocoon, sonuçları browser’a döndürmeden önce
$COCOON_HOME/transforms/content2html.xsl yi kullanarak dönüştürür.
Pipeline’a daha fazla dönüştürücüler eklenerek daha karmaşık dönüşümler
gerçekleştirilebilir. Burada wildcard kullanımı bizi, eşleştirme işleminin sonuçlarını
kullanarak pipeline’ın girdilerini tanımlama işinden kurtarır.
Diğer Çıktı Biçimlerinin Oluşturulması
XML içeriğinden HTML’nin nasıl oluşturulduğunu gördük. Fakat burada önemli bir
konu da diğer belge biçimlerini nasıl ele alabileceğimizdir. Cocoon bu durumu
serileştiricileri kullanarak ele alır.
Dönüşüm sonucu olarak HTML değil de XML elde etmek için XML serileştiricisi
kullanılmalıdır. Eğer içeriği gruplamak için bir RSS kütüğü oluşturacak bir dönüşüm
yapabiliyorsak, pipeline aşağıdaki kesimi içererek yazılabilir:
<map:transform src="transforms/content2rss.xsl"/>
<map:serialize type="xml"/>
Burada serileştirici bileşeninin type niteliği kullanılarak, özel bir serileştirici seçilmiştir.
Ve bu serileştiricinin Value niteliği daha önceki sayfalarda yapılan bileşen
tanımlamalarındaki serileştiricilerden biri ile aynıdır.
SVG (Scalable Vector Graphics) doğru diyagramlarını tanımlamak için kullanılan bir
XML türüdür. Normalde, SVG belgelerini görmek için bir browser plugin gereklidir.
Fakat Cocoon, bir SVG belgesinden JPEG veya PNG resmi oluşturabilen bir
serileştiriciye sahiptir. Bu serileştirici aşağıdaki gibi çalıştırılabilir :
<map:transform src="transforms/content2svg.xsl"/>
<map:serialize type="svg2png"/>
Cocoon, XSL-FO belgelerinden PDF kütüklerinin oluşturulmasını da destekler.
Bunun için Style sheet’in belirlenmiş serileştiriciye girdi olarak doğru belge biçimini
vermesi yeterlidir:
<map:transform src="transforms/content2fo.xsl"/>
<map:serialize type="fo2pdf"/>
Parametrelerin Aktarımı
Parametreleri XSLT dönüşümlerine aktarmak genellikle faydalı bir yöntemdir. Cocoon
sitemap’in içinden parametre geçirmeyi destekler. Bunu yapmanın bir yolu
map:parameter elemanını kullanmaktır.
Buna bir örnek:
<map:transform src="transforms/content2html.xsl">
<map:parameter name="myFixedParam" value="fixed-value"/>
<map:parameter name="myDynamicParam" value="{1}"/>
</map:transform
Parametrenin adı ve değeri map:parameter elemanının nitelikleri olarak belirlenmiştir.
Bu yöntemle, sabit ve dinamik parametreleri style sheet’lere aktarmak mümkündür.
İkinci parametre elemanı değerini bir eşleştirme örüntüsündeki ilk wildcard’ı
kullanarak alacaktır. Style Sheet , “xsl:param” elemanını içerdiği sürece, parametre
dönüşüme doğru olarak aktarılacaktır.
Parametreleri style sheet’e aktarmanın alternatif bir yolu, URL istem parametrelerinin
hepsinin aktarılmasına izin verir.
Örneğin,
Eğer http://localhost:8080/content.html?param1=value1&param2=value2 için bir
istem pipeline’nın tetiklenmesine sebep olursa bu iki parametre (param1 ve param2)
Style sheet’e aktarılır.
<map:transform src="transforms/content2html.xsl">
<map:parameter name="use-request-parameters" value="true"/>
</map:transform
Bu yöntem, bir isteme aktarılacak parametre sayısı değişkense işimize yarar. Fakat
bu biraz performans kaybına neden olur. Çünkü, Cocoon bu tarz dönüştürme
işlemlerinin sonuçlarını ön belleğe alma işleminde, sabit sayıda parametre ile yapılan
dönüştürümlere göre daha verimsizdir.
Eğer herhangi bir URL parametresi değiştirilirse (style sheet tarafından doğrudan
kullanılmamış olsa bile) saklanmış sonuçlar kullanılmayacaktır.
KAYNAKLAR:
http://www-106.ibm.com/developerworks/views/java/tutorials.jsp
METİN YAZARI:
Leigh Dodds
ÇEVİREN:
Ali GAZİOĞLU