Spring çatısı hakkında geniş bilgiyi yeni kitabım Pratik Spring Core‘da bulabilirsiniz.
Spring MVC
Günümüzde kullanılan birçok program web arayüzleriyle internet ve intranet ortamlarında kullanılmaktadır. Web tabanlı programların popüler olmasının sebepleri bir taraftan sadece bir web tarayıcısının (browser) yeterli olması, diğer taraftan da bu tür aplikasyonların bilgisayar üzerinde herhangi bir kurulum (install/setup) gerektirmemesidir.
Web tabanlı programlar kullanıcı (client) için herhangi bir kurulum gerektirmezken, server tarafında programın içinde çalışabileceği bir ortamın oluşturulması gerekmektedir. Bu ortamlar web protokolü olan HTTP1 üzerinden kullanıcı ile interaksiyona girebilecek yapıdadırlar. Gerekli bu ortamları oluşturmak için Apache2 ve Tomcat3 gibi server programları kullanılır. Java dünyasında web aplikasyonları oluşturmak için Servlet/JSP teknolojileri kullanılır. Bu teknolojilerle implemente edilmiş bir sistem Tomcat gibi bir Servlet Container içinde çalışabilir, çünkü Tomcat program için gerekli altyapı hizmetlerini sunmaktadır.
Bu yazıyı PDF olarak edinebilirsiniz.
Spring MVC (291,3 KiB, 21.941 yükleme)
Konuyla İlgili Kitaplar
Java Test Güdümlü Web Yazılımı Semineri
07.03.2009 tarihinde Işık üniversitesinde çevik süreçleri anlatan ve test güdümlü bir web aplikasyonun nasıl implemente edildiğini pratik bir örnek üzerinde gösteren bir seminer düzenledik. Işık ünivesitesinin daveti üzerine yaptığımız bu seminere Işık üniversitesi ögrencileri yanısıra yazılım endüstrisinde çalışan arkadaşlar katıldı.
Düzenlediğimiz diğer seminerleri Kurumsal Java Akademisi sayfalarından takip edebilirsiniz.
Seminerde kullanılan teknolojiler:
1.) Java 5.0
2.) Wicket Web Framework
3.) Spring Framework
4.) Hibernate
5.) HSQLDB
6.) Junit
7.) Eclipse 3.4
8.) JMock Mock Framework
9.) DBUnit
10.) EclEmma Code Coverage Tool
Web aplikasyonunda incelediğimiz uygulamalar:
1.) Wicket ile web yazılımı
2.) Spring ile transaktion yönetimi
3.) Spring ile Hibernate kullanımı
4.) Wicket ile onay/kabul testleri
5.) JUnit ile unit ve entegrasyon testleri
6.) JMock ile test güdümlü yazılımda mock nesne kullanımı
7.) Web aplikasyonlarında üç katmanlı mimari
8.) Ant ve HSQLDB ile yazılımda çevik bilgibankası kullanımı
9.) DBUnit ile regresyon testleri
10.) İşletme katmanında Facade tasarım şablonu kullanımı
11.) Persistens katmanında DAO tasarım şablonu kullanımı









Çevik Java EE Web Semineri
28 Şubat 2009 tarihinde İstanbul IBM Türk’de CETURK tarafından düzenlenen Çevik Süreç ve TDD seminerine konuşmacı olarak katıldım ve Çevik Java EE Web Uygulamaları ve Mimarileri isimli bir sunum yaptım. Sunum dosyasını aşağıdaki link üzerinden edinebilirsiniz.
Çevik Java EE 5 Web Uygulamaları ve Mimarileri (1,8 MiB, 8.351 yükleme)
» Eclipse Java Projesi
» Tüm resimler
Extreme Programming Hakkında Bazı Soru ve Cevapları
Kullanıcı hikayesi (user story) nedir?
XP projelerinde müşteri gereksinimlerinin yer aldığı kullanıcı hikayeleri oluşturulur. Bir kullanıcı hikayesi sistemin tipik bir özelliğini bir ya da iki cümle ile anlatan araçtır. Örneğin üye girişi olan bir sistemde, şöyle bir kullanıcı hikayesi düşünülebilir:
Kullanıcı isim ve şifreni kullanarak sisteme giriş yapar.
Kullanıcı hikayeleri hikaye kartlarına (story card) yazılır. Bu kartlar sürüm ve implementasyon planları yapılırken kullanılır. Her kullanıcı hikayesinin implementasyon zamanı programcılar tarafından tahmin edilir. Müşteri kullanıcı hikayelerine öncelik sırası vererek implementasyon sırasını tayin eder. Programcılar tarafından yapılan tahmin ve müşteri tarafından belirlenen öncelik sırası kullanıcı hikayesinin üzerinde yer aldığı hikaye kartlarına not edilir. Ayrıca müşteri tarafından oluşturulan akseptans (onay/kabul) testleri hikaye kartlarının arka bölümüne not edilir.
Bir kullanıcı hikayesinin büyüklüğü ne kadar olmalı?
Bu sorudaki büyüklük sıfatı ile kullanıcı hikayesinin kaç günde implemente edilebilir olduğu kastedilmektedir. Programcılar tarafından kullanıcı hikayelerin implementasyon süreleri gün bazında tahmin edilir. Bir kullanıcı hikayesinin en fazla dört yada beş günde implemente edilebilir yapıda olması gerekmektedir. Daha fazla zaman gerektiren kullanıcı hikayelerinin müşteri tarafından bölünerek, küçültülmeleri gerekmektedir.
Kullanıcı hikayelerini kim oluşturur?
Kullanıcı hikayelerini müşteri oluşturur, çünkü gereksinimleri en iyi bilen müşteridir.
XP projelerinde müşterin programcılarla beraber çalışması talep edilir. Müşteri kendi işini bırakıp, nasıl proje için çalışabilir? Başka işi yok mu?
Bu genelde müşterinin kendi işini gücünü bırakıp, projede başka işlerle uğraşması gerektiği şeklinde değerlendirilir, ama durum öyle değildir. Müşterinin programcılara yakın bir yerde olması, programcıların oluşan sorulara kısa sürede müşteri yardımıyla cevap bulmalarını kolaylaştırır. Asıl maksatta budur zaten. Müşteri gün boyunca programcıların sorularına cevap verir. Bunun yanı sıra kendi günlük işlerini takip eder. Çoğu zaman günlük işleri yapabilmek için bir bilgisayar yeterli olacaktır. Müşteri kendi işlerini yaparken ara sıra programcılara zaman ayırarak, soruları cevaplar.
Birden fazla müşteri varsa, hangisinin sözü geçerlidir?
Proje ekibinin karşısında sadece bir müşteri olmalıdır. Eğer birden fazla müşteri varsa, bu şahıslar bir araya gelerek, tek bir şahıs gibi programcı ekibi ile iletişim kurmalıdırlar.
Sürüm planını kim oluşturur?
Sürüm planı müşteri ve programcılar tarafından ortaklaşa oluşturulur. Ne ve hangi sıraya göre yapılması gerektiği müşteri tarafından belirlenir. Bu yüzden sürüm planının oluşumunda müşterinin ağırlığı daha fazladır. Planlama için zaman tahminleri programcılar tarafından yapılır. Bu şekilde programcılar proje planlama sürecine aktif olarak katılarak sorumluluk alırlar.
Sürüm planını ne oranda sabittir?
Proje başında oluşturulan sürüm planı projenin çeşitli safhalarında değişikliğe uğrayabilir. Bu doğaldır. Müşteri yazılım sisteminin ilk sürümleriyle gereksinimlerinin ne olduğunu daha iyi anlayabilir ve mevcut kullanıcı hikayeleri üzerinde değişilik yapılmasını talep edebilir ya da yeni kullanıcı hikayeleri oluşturabilir. Bu durumda sürüm planının değiştirilmesi gerekmektedir.
Sürüm ve iterasyon arasındaki fark nedir?
Sürüm yazılım sisteminin belirli bir versiyondaki halidir. Her yeni sürüm yeni özelliklerin implemente edildiği ve müşteri tarafından produktif kullanılan program versiyonudur. XP projelerinde her yeni sürüm bir ile dört ay süren bir çalışma sonunda oluşturulur. Müşteri tarafından seçilen kullanıcı hikayeleri belirli bir zamansal uzunluğa sahip olan iterasyonlarda implemente edilir. İterasyonlar bir ile dört haftalık zaman birimini kapsarlar.
Bir önceki resimde yer alan sürüm beş iterasyondan oluşmaktadır. Her iterasyon iki hafta sürmektedir. Sürüm onuncu haftanın sonunda oluşturulmaktadır.
Hangi kullanıcı hikayesiyle işe başlanır?
Bu sorunun cevabını sürüm ve iterasyon planı verir. Sürüm ve iterasyon planlarında müşteri tarafından belirlenen kullanıcı hikayeleri yer alır. Müşteri, kullanıcı hikayeleri için sahip oldukları değere göre öncelik sırası belirler. Sürüm ve iterasyon planlarında kullanıcı hikayeleri bu öncelik sırasına göre yer alırlar. Programcılar her iterasyonda, o iterasyon için seçilmiş olan kullanıcı hikayelerini öncelik sırası yüksekten düşüğe doğru implemente ederler. Buradaki ana amaç, müşteri için en değerli özelliklerin yer aldığı bir sürümü oluşturarak, müşteri tarafından kullanılabilir hale getirmektir. Bu yüzden her zaman müşteri açısından en değerli olan sistem özellikleri öncelikli olarak implemente edilir.
Kullanıcı hikayesi implementasyonu ne zaman tamamlanmıştır?
Programcılar bir kullanıcı hikayesini test güdümlü implemente ederler. Testler tamamlandıktan sonra akseptans testleri yapılmak üzere kullanıcı hikayesinin yer aldığı hikaye kartı (story card) testçiye (tester) devredilir. Testçi müşteri tarafından tanımlanmış olan akseptans (onay/kabul) testlerini implemente eder. Akseptans testlerini geçen bir implementasyon bitmiş olarak kabul edilir.
Mevcut projeler üzerinde XP uygulanabilir mi?
Bu büyük ölçüde projedeki JUnit testleri oluşturma alışkanlığına bağlı. XP test güdümlü implementasyonu şart koşmaktadır. Eğer programcılar tarafından programlara paralel olarak testler geliştiriliyorsa, test güdümlü implementasyona geçmeleri zor olmayacaktır. Bunun yanı sıra projedeki mevcut iletişim kültürü önemlidir. XP çok yönlü iletişimi gerekli kılmaktadır. Örneğin pair programming gibi tamamen iletişim ve takım işine bağımlı olan bir metot programcılar tarafından ne oranda uygulanabilir, bunun araştırılması gerekmektedir.
Sürekli entegrasyon, test güdümlü yazılım, müşterinin projeye dahil edilmesi, kısa sürelerde yeni sürüm oluşturulması gibi konular XP’yi yeni başlamayan projeler için zor adapte edilebilir kılmaktadırlar. XP’nin yeni projelerde adaptasyonu çok daha kolaydır.
Bir iterasyon süresi ne kadar olmalı?
Bu yazılım sisteminin sahip olması gereken özelliklerle doğru orantılıdır. Eğer iki ay içinde ilk sürüm oluşturulması planlanıyorsa, iterasyon süresi bir ile iki hafta olacak şekilde seçilebilir. Bunun yanı sıra müşteri tarafından oluşturulan kullanıcı hikayelerinin implementasyonu için programcılar tarafından verilen tahminlerin dikkate alınması gerekmektedir. Örneğin programcılar tarafından ortalama her kullanıcı hikayesi için bir ile iki gün tahmin edilmişse, bir haftalık iterasyonda en az üç en çok beş kullanıcı hikayesi implemente edilebilir. Eğer kullanıcı hikayeleri ortalama dört veya üzeri günde implemente edilebilir durumda ise, o zaman interasyonun en az iki hafta olarak seçilmesi gerekmektedir. İterasyon süresi sabittir ve uzatılamaz, bu yüzden seçilen kullanıcı hikayelerinin seçilen sürede implemente edilebilir yapıda olmaları gerekmektedir.
Akseptans (okay/kabul) testlerini kim oluşturur?
Akseptans testleri kullanıcı hikayesini oluşturan müşteri tarafından tanımlanır. Akseptans testlerinin implementasyonunu programcılar yada testçiler üstlenir.
Kaç tane JUnit testi hazırlanmalı?
Produktif olarak kullanılan her sınıf için bir JUnit testi sınıfı oluşturulması gerekmektedir. Bu sınıf bünyesinde birden fazla test metodu yer alır. Produktif sınıfta bulunan her metodun test edilmesi gerekmektedir. Çoğu zaman oluşturulan test sınıfının büyüklüğü test edilen sınıfın 2-3 katı büyüklüğe sahiptir. Bu test adedi hakkında bir fikir sahibi olmanızı kolaylaştırır.
Kod paylaşımı nasıl yapılır?
Kod paylaşımını kolaylaştırmak için bir versiyon kontrol sisteminin kullanılması şarttır. Subversion son zamanlarda kullanılan en popüler açık kaynaklı versiyon kontrol sistemi haline gelmiştir.
Kurumsal Java Akademisi Subversion eğitimi »
Pair programming yaparken tecrübeli bir programcı ile tecrübesiz bir programcının beraber çalışması zaman ve kaynak kaybı değil midir?
Hayır! Pair programming tekniği ile programcıların teknik anlamda ayni seviyeye gelmeleri sağlanır. Tecrübeli programcılar can, tecrübesiz programcılar patlıcan değildir :) Tecrübesiz programcılar için seminer düzenlemek yerine, onlara pair programming seanslarında teknoloji ve proje hakkında bilgi transfer etmek daha mantıklıdır.
Pair programming iki programcının bir kişilik iş çıkarması anlamına gelmez mi?
Pair programming maliyetli bir yöntemdir. Lakin iki programcının beraber aynı implementasyon üzerinde çalışmasından sinerjiler doğar. Pair programming iş kalitesini yükseltir. Ayrıca pair programming ile kodun ve tasarımın iki değil dört göz ile kontrol edilmesini sağlanır.
XP projelerinde mimariyi ve tasarım nasıl oluşur?
Mimari (altyapı) proje öncesinde yapılan keşif safhasında (Exploration Phase) oluşur. Programcılar müşteri tarafından oluşturulan kullanıcı hikayelerini okudukça, neye ihtiyaç duyduklarını anlarlar ve ona göre altyapıyı geliştirirler.
Proje öncesi detaylı tasarım oluşturulmaz. Tasarım test güdümlü implementasyon esnasında programcılar tarafından oluşturulur. Eğer programcılar implementasyon esnasında sorunlarla karşılaşırlarsa, refactoring yöntemleri kullanarak tasarım üzerinde değişiklik yaparlar. Unit testleri refactoring işleminin yapılmasını kolaylaştırır. Yapılması gereken değişiklikler sonraya bırakılmaz, çünkü bu ilerde maliyetin yükselmesine sebep olabilir.
XP projelerinde mimariyi ve tasarımı kim oluşturur?
Programcılar.
Bilgi bankası olan bir sistemde test güdümlü yazılım nasıl uygulanır?
Bunun çeşitli yöntemleri vardır. Öncelikle bilgi bankası işlemlerinin DAO (Dao Access Object) tasarım şablonu kullanılarak bir interface sınıf arkasında saklanması en mantıklı çözümdür. Mock sınıflar kullanılarak DAO katmanı simule edilebilir. Bu sistemin diğer bölümlerinin test güdümlü implementasyonunu kolaylaştırır. DAO kullanıldığı taktirde, gerçek bilgi bankasına olan bağımlılık azaltılır. DAO interface sınıfını değişik türde implemente ederek, bilgi bankası yerine başka bir yapıda kullanılabilir.
Hibernate ve IBatis gibi bir framework kullanılması durumunda, test güdümlü yazılımı mümkün kılabilmek için bu frameworklerin sunduğu interface sınıflar (SessionFactory, Session vs.) mock nesneler ile simüle edilebilir.
Planlama pokeri nedir?
Programcı bir kullanıcı hikayesini implementasyon öncesi tüm detaylarıyla bilmek zorunda değildir. Bir kullanıcı hikayesini en son detayına kadar kavramaya çalışmak zaman kaybı olabilir, çünkü kullanıcı hikayesinde yeralan müşteri gereksinimi değişikliğe uğrayabilir. Bu genelde müşterinin programın ilk sürümlerini görmesiyle gerçekleşir. Çalışır bir program aracılığıyla müşteri gereksinimlerini daha iyi kavrayacak ve gerekli değişiklikleri talep edecektir. Bu sebepten dolayı implementasyona başlamadan önce kullanıcı hikayesinin ihtiva ettiği tüm detayları tespit etmek faydalı olmayacaktır, çünkü kullanıcı hikayesi değişikliğe ugrayabilir. Programcı ekibin kullanıcı hikayesi hakkında implementasyon için gerekli zamani tahmin edebilecek kadar bilgiye sahip olması yeterli olacaktır.
Programcılar müşteri tarafından seçilen kullanıcı hikayesinin implementasyon süresini tahmin ederler. Bu tahminler planlama pokerinde yapılır.
Planlama pokeri yapılmayan tahminler bazen sağlıklı sonuçlar vermeyebilir. Bir programcı tarafından yapılan tahmin diger programcıları etkiliyebilir. Yada bazı programcılar herhangi bir sebepten dolayı tahmin etme sürecine aktif olarak dahil olmayabilirler. Bu gibi sebeplerden dolayı oluşan tahmin süreleri yanıltıcı olabilir. Daha geçerli tahminler elde edebilmek için planlama pokeri oynanır.
Planlama pokeri için kullanılan kartlar bir önceki resimde yer almaktadır. Her programcı bu kartların bir setine sahiptir. Planlama pokeri şu şekilde oynanır: Bir moderator ilk kullanıcı hikayesini okur. Müşteri bu kullanıcı hikayesi için implementasyon süresinin ne olduğunu sorar. Programcılar kısa bir zaman düşündükten sonra hep beraber planlama poker kartlarından birisini seçerek gösterirler. Çoğu zaman kullanılan kartlardakı değerler farklı olacaktır. En çok süreyi ve en az süreyi tahmin eden programcılardan bu sonuca nasıl vardıklarının açıklanması istenir. Verilen bilgiler dogrultusunda ortak bir değer bulunur.
Tahminler için hikaye puanları (story points) kullanılır. 1 hikaye puanı örneğin 1 iş günü (8 saat) olabilir. Programcılar her kullanıcı hikayesini kendi başına tahmin etmek yerine, kullanıcı hikayelerini birbirleriyle kıyaslıyarak tahminde bulunurlar. Örneğin kullanıcı hikayesi A için 2 hikaye puanı tahmin edilmişse, kullanıcı hikayesi B bu değer göz önünde bulundurularak tahmin verilir. Eğer kullanıcı hikayesi B A dan üç katı daha büyükse, o zaman B için tahmin 2×3 = 6 hikaye puanı olarak verilir.
Load Factor nedir?
Bir kullanıcı hikayesinin ideal şartlarda implementasyonu için gerekli zaman dilimi ile normal şartlarda implementasyonu için gerekli zaman dilimi farklı olacaktır. Örneğin programcılar gün boyunca yazılım haricinde toplantı, bilgi alışverişi gibi işler için zaman ayırmak zorundadir. Bir programcının sekiz saatlik bir iş gününde sekiz saat program yazabilmesi ideal zaman dilimi olarak tanımlanır. Toplantı ve diğer işler için kullanılan zaman ideal zaman diliminde çikartıldığı zaman normal zaman dilimi elde edilir. Kullanıcı hikayelerinin tahminlerinde ideal ve normal zaman dilimlerinin göz önünde bulundurulması gerekmektedir, aksi taktirde kullanıcı hikayesi için yapılan tahmin gercekleri yansıtmıyacaktır. Gerçekci bir tahmin yapabilmek için load factor olarak bilinen değer kullanılır. Bu değer bir kullanıcı hikayesinin implementasyonu için kullanılan zamanın ideal zamana bölünmesiyle elde edilir. Örneğin bir kullanıcı hikayesi için 1 iş günü (8 saat) tahmin edilmiş ve programcı kullanıcı hikayesini 2 iş gününde tamamlamış olsun. Bu durumda load factor 16 / 8 = 2 olacaktır. Load factor için 2 ila 5 arasında bir değer normaldir. Tahmin yapılırken tahmin edilen implementasyon zamanı load factor ile çarpılır. Örneğin programcı bir kullanıcı hikayesini 2 iş gününde implemente edebileceğini düşünüyorsa, kullanıcı hikayesi için tahmin süresi 2 değil, 2 iş günü x 2 load factor = 4 olmalıdır. Bu şekilde daha gerçekci tahmin elde edilir.
Programcılar load factor değerini göz önünde bulundurarak, tahminde bulunurlar.
Spike solution nedir?
Eğer programcılar bir kullanıcı hikayesi için tahminde bulunamazlarsa küçük çaplı bir demo implementasyonu yaparak implementasyon süresini tahmin etmeye çalışırlar. XP dilinde bu işe spike solution ismi verilir. İdeal şartlarda bu işlemin sürüm planlama oyunundan önce yapılmış olması gerekir. Buradan sürüm planlama oyunu için kullanıcı hikayelerinin oyun öncesi hazırlanmış olması gerektiği sonucunu çikartabiliriz.
Programcılar yaptıkları denemeler sonunda kullanıcı hikayesi için tahmin verebilecek duruma gelirler.
Özcan Acar
Neden sürekli entegre edilmeli?
Oluşturduğunuz yazılım sistemini sürekli entegre etmiyorsanız, zamanı gelince toptan entegre etmek zorundasınız. Bunun, neden yazılım hayatınızda karşılaşabileceğiniz en büyük sorun olabileceğini bir örnek vererek açıklamak istiyorum.
Şimdi şunu hayal edin: Yeni bir otomobilin tasarlanması projesinde yer aldınız. Otomobil tasarlandı ve otomobili oluşturan parçalar 5 değişik ülkede, 20 değişik firma tarafından üretildi. Bu ülkelerde kullanılan uzunluk ve ağırlık birimleri (metre, kg vs.) değişik olabilir. Görev dağılımı esnasında yanlış anlamalardan dolayı üretilen parçalar birbirine uyumlu olmayabilir. Eğer tüm parçalar üretildikten sonra bir çırpıda tüm otomobili oluşturmak isterseniz, üretim sürecinde meydana gelen hataları daha önceden tespit edemediğiniz için, yamuk yumuk bir otomobil ortaya çıkacaktır. Ama üretim esnasında koordineli bir şekilde otomobili parça parça bir araya getirip, parçalar uyuşuyor mu diye kontrol etmiş olsaydınız, meydana gelen uyuşmazlıkları çok erken tespit ederek, gerekli değişiklikleri yapabilirdiniz. Bu yazılım sektörü için de geçerli. Oluşturulan sistem komponentleri ne kadar erken entegre edilirse, oluşan uyuşmazlıklar o kadar erken tespit edilir ve gerekli değişiklikler yapılabilir.
Sürekli entegrasyon çevik süreçlerde çok önemli bir yazılım metodudur. Sistem üzerinde yapılan her değişiklik sürekli entegrasyonu otomatik olarak gerçekleştiren sunucu tarafından kontrol edilir. Yazılımda kırılmalar oluşması (compile hataları, eksik sınıflar vs.) durumunda, tüm ekip sürekli entegrasyon sunucusu tarafından uyarılır. Bu geribildirim sayesinde entegrasyonun ne safhada olduğu anlaşılır.
Sürekli entegrasyon hakkında diğer bir makalemi
http://www.kurumsaljava.com/2008/11/26/surekli-entegrasyon-continuous-integration/
adresinden edinebilirsiniz.
Özcan Acar
Yazılımda Değişik Test Türleri
Yazılım sürecinde oluşturulan sistemin kalite kontrolü unit testleri ile yapılır. Java tabanlı sistemlerde unit testleri JUnit olarak isimlendirilir. Bu isim aynı ismi taşıyan test frameworkü olan JUnit’den gelmektedir. Java’da unit testleri yazabilmek için JUnit frameworkü (http://www.junit.org) kullanılır.
Değişik türde unit testleri oluşturmak mümkündür. Bunlar:
- JUnit testleri (Unit Testing)
- Entegrasyon testleri (Integration testing)
- Arayüz (interface) testleri (Functional Interface Testing)
- Regresyon testleri (Regression Testing)
- Akseptans (onay/kabul) testleri (Acceptance Testing)
- Sistem testleri (System Testing)
- Stres testleri (Stress Testing)
- Performans testleri (Performance Testing)

Programcılar sisteme eklenen her Java sınıfı için bir JUnit test sınıfı oluştururlar. Test sınıfında, test edilen sınıfın her metodu için bir test oluşturulur. Unit ismi buradan gelmektedir. Unit testleri ile kendi içinde bütün olan bir kod ünitesi test edilir. Bunlar genellikle sınıfların metotlarıdır. Test sınıfı kullanılarak, test edilen sınıfın işlevlerini doğru olarak yerine getirip, getirmediği test edilir. Metot bazında hazırlanan testlere JUnit testleri diyoruz. Sınıf üzerinde yapılan her değişiklik ardından o sınıf için hazırlanan unit testleri çalıştırılarak, yapılan değişikliğin yan etkileri olup, olmadığı kontrol edilir. Testlerin olumlu netice vermesi durumda, sınıfın görevini hatasız yerine getirdiği ispat edilmiş olur. Bu açıdan bakıldığında unit testleri programcılar için kodun kalitesini korumak ve daha ileri götürebilmek için vazgeçilmezdir. Sistem üzerinde yapılan her değişiklik yan etkilere sebep olabileceği için, sistemin her zaman çalışır durumda olduğunu sadece unit testleri ile kontrol edebiliriz. Onlarca ya da yüzlerce sınıfın olduğu bir programı, her değişikliğin ardından elde kontrol etmek imkansız olduğu için otomatik çalışabilen unit testlerine ihtiyacımız vardır.
Birçok komponentten oluşan bir sistemde, komponentler arası entegrasyonu test etmek için entegrasyon testleri oluşturulur. Entegrasyon testleri hakkında detaya girmeden önce, JUnit testleri hakkında bir açıklama daha yapma gereği duyuyorum. JUnit testleri, test edilen sınıfları kullandıkları diğer sınıflardan bağımsız olarak test ederler. Örneğin bir sınıf bilgibankasından veri edinmek için bir servis sınıfını kullanıyorsa, JUnit testinde bu servis sınıfı kullanılmaz, çünkü bu bilgibankasının çalışır durumda olmasını gerektirir. Eğer JUnit testi içinde bilgibankası kullanılıyorsa, bu JUnit testi değil, entegrasyon testidir, çünkü test edilen sınıf ile bilgibankası arasındaki ilişki dolaylı olarak test edilmektedir. Daha öncede belirttiğim gibi JUnit testleri metot bazında ve sınıfın dış dünyaya olan bağımlılıklarından bağımsız olarak gerçekleştirilir. Amacımız bir metot içinde bulunan kod satırlarının işlevini test etmektir. Bunun için bilgibankasına bağlantı oluşturulması gerekmez. Test edilen sınıfın bağımlılıklarını ortadan kaldırabilmek için Mock nesneler kullanılır. Bir Mock nesne ile servis sınıfı işlevini yerine getiriyormuşcasına simüle edilir. JUnit testinde, test edilen sınıf servis sınıfı yerine onun yerine geçmiş olan Mock nesnesini kullanarak, işlevini yerine getirir. Entegrasyon testlerinde Mock nesneleri kullanılmaz. Entegrasyon testlerindeki ana amaç sistemin değişik bölümlerinin (subsystem) entegre edilerek işlevlerini kontrol etmektir. Entegrasyon testlerinde test edilen sınıflar için gerekli tüm altyapı (bilgibankası, email serveri vs.) çalışır duruma getirilir ve entegrasyon test edilir.
Sistem komponentleri bir veya birden fazla sınıftan oluşabilir. Komponent kullanımını kolaylaştırmak için interface sınıflar tanımlanır. Komponenti kullanmak isteyen diğer komponent ve modüller bu interface sınıfına karşı programlanır. Komponentler arası interaksiyon Arayüz (interface) testleri ile test edilir. Bu testlere fonksiyon testleri adı da verilir.
Regresyon bir adım geri atmak anlamına gelmektir. Regresyon yazılım esnasında, programın yapılan değişiklikler sonucu çalışır durumdan, çalışmaz bir duruma geçtiği anlamına gelir. Regresyon testleri ile sistemden yapılan değişikliklerin bozulmaları neden olup, olmadığı kontrol edilir. Sistem üzerinde yapılan her değişiklik istenmeyen yan etkiler doğurabilir. Her değişikliğin ardından regresyon testleri yapılarak, sistemin bütünlüğü test edilir. Regresyon testlerinde sistem için kullanılan altyapı tanımlanmış bir duruma getirildikten sonra testler uygulanır. Örneğin test öncesi bilgibankası silinerek, test için gerekli veriler tekrar yüklenir. Her test başlangıcında aynı veriler kullanılarak, sistemin nasıl reaksiyon gösterdiği test edilir. Regresyon testlerinin uygulanabilmek için test öncesinde tüm altyapının başlangıç noktası olarak tanımlanan bir duruma getirilmesi gerekmektedir.
Akseptans testleri ile sistemin bütünü kullanıcı gözüyle test edilir. Bu tür testlerde sistem kara kutu olarak düşünülür. Bu yüzden akseptans testlerinin diğer bir ismi kara kutu testleridir (black box test). Kullanıcının sistemin içinde ne olup bittiğine dair bir bilgisi yoktur. Onun sistemden belirli beklentileri vardır. Bu amaçla sistem ile interaksiyona girer. Akseptans testlerinde sistemden beklenen geri dönüm test edilir.
Stres testleri tüm sistemin davranışını eksepsiyonel şartlar altında test eden testlerdir. Örneğin bir web tabanlı programın eşli zamanlı yüz kullanıcı ile gösterdiği davranış, bu rakam iki yüze çıktığında aynı olmayabilir. Stres testleri ile sistemin belirli kaynaklar ile (hardware, ram, işletim sistemi) stres altındaki davranışı test edilmiş olur.
Performans testleri ile sistemin, tanımlanmış kaynaklar (hardware, ram, işletim sistemi) yardımıyla beklenen performansı ölçülür. Test öncesi sistemden beklenen davranış biçimi tayin edilir. Test sonrası beklentiler test sonuçlarıyla kıyaslanır ve kullanılan kaynakların beklenen davranış için yeterli olup olmadığı incelenir. Sistemin davranış biçimi kullanılan kaynakların yetersiz olduğunu göstermesi durumunda, ya sistem üzerinde değişikliğe gidilir ve sistemin mevcut kaynaklar ile yetinmesi sağlanır ya da kaynaklar genişletilerek sistemin istenilen davranışı edinmesi sağlanır.
Çevik süreçlerde unit testleri büyük önem taşımaktadır. Extreme Programming bir adım daha ileri giderek, test güdümlü yazılım (Test Driven Development – TDD) konseptini geliştirmiştir. Test güdümlü yazılımda baş rolü unit testleri oynar. Sınıflar oluşturulmadan önce test sınıfları oluşturulur. Bu belki ilk bakışta çok tuhaf bir yaklaşım gibi görünebilir. Var olmayan bir sınıf için nasıl unit testleri yazılabilir diye bir soru akla gelebilir. TDD uygulandığı taktirde, oluşturulan testler sadece sistemde olması gereken fonksiyonların programlanmasını sağlar. Programcılar kafalarında oluşan modelleri program koduna çevirirler. Bu süreçte çoğu zaman sistemi kullanıcı gözlüğüyle değil, programcı gözlüğüyle görürler. Bu da belki ilk etapta gerekli olmayan davranışların sisteme eklenmesine sebep verebilir. Unit testlerinde bu durum farklıdır. Örneğin akseptans testlerinde tüm sistem bir kullanıcının perspektifinden test edilir. Bu testlerde sistemin mutlaka sahip olması gerektiği davranışlar test edilmiş olur. Eğer akseptans testleri oluşturarak yazılım sürecine başlarsak, testin öngördüğü fonksiyonları implemente ederiz. Böylece gereksiz ve belki bir zaman sonra kullanılabileceğini düşünerek oluşturduğumuz fonksiyonlar programlanmaz. TDD ile testler oluşturulan sisteme paralel olarak oluşur. Sonradan bir sistem için onlarca ya da yüzlerce unit testi oluşturmak çok zor olacağı için, unit testlerini oluşturarak yazılama başlamak çok daha mantıklıdır. TDD konseptini bir sonraki bölümde detaylı olarak yakından inceleyeceğiz.
Özcan Acar
Yazılımda Şelale (Waterfall) Yöntemi
Şelale yönteminde yazılım geliştirme süreci analiz, tasarım, kodlama, test, sürüm ve bakım gibi safhalardan oluşur. Geleneksel yazılım metodlarında bu safhalar şelala modelinde olduğu gibi linear olarak işler. Her safha, baslangıç noktasında bir önceki safhanın ürettiklerini bulur. Kendi bünyesindeki değişikler doğrultusunda teslim aldıklarını bir sonraki safhanın kullanabileceği şekilde degiştirir.

Şelale modelinin özelliklerini şu şekilde sıralayabiliriz:
- Şelalenin her basamağında yer alan aktiviteler eksiksiz olarak yerine getirilir. Bu bir sonraki basamağa geçmenin şartıdır.
- Her safhanın sonunda bir doküman oluşturulur. Bu yüzden şelale modeli doküman güdümlüdür.
- Yazılım süreci lineardir, yani bir sonraki safhaya geçebilmek için bir önceki safhada yer alan aktivitelerin tamamlanmış olması gerekir.
- Kullanıcı katılımı baslangıç safhasında mümkündür. Kullanıcı gereksinimleri bu safhada tespit edilir ve detaylandırılır. Daha sonra gelen tasarım ve kodlama safhalarında müşteri ve kullanıcılar ile diyaloga girilmez.
Bu modelin beraberinde getirdiği problemleri şu şekilde sıralayabiliriz:
- Safhaların birbirinden kesin olarak ayrı tutulmaları gerçekci değildir. Projelerde safhalar arasındaki bu sınırlar yok olabilir.
- Teoride safhalar birbirlerini takip edeler. Projelerde bunun bazen mümkün olmadığını ve önceki safhalara geri dönülmek zorunda kalındığını görebiliriz.
- Safhalar arası geri dönüş yetersizdir. Model değişikliğe açık değildir.
- Müşteri gerensinimlerinin proje öncesi detaylı olarak kağıt üzerinde oluşturulması ilerde sorun yaratabilir. Müşteri gereksinimleri değişikliğe uğrayabileceği için, yazılım sisteminin de yapısal değişikliğe uğraması kaçınılmaz olabilir. Böyle bir durum maliyeti artırır, çünkü yeni ve değişen gereksinimleri implemente edebilmek için modelde yer alan safhaların birkaç kere uygulanması gerekebilir.
- Sistemin kullanılır hale gelmesi uzun zaman alabilir.
- Baslangıçta yapılan hataların tespiti çok uzun zaman alabilir. Bu hataların giderilmesi maliyeti yükseltir.
- Modül implementasyonları için zaman tahminleri proje planlarını oluşturan yöneticiler tarafından yapılır. Teknik bilgiye sahip olmayan şahıslar tarafından yapılan bu tahminler çoğu zaman dogru değildir. Bu durum proje planlama sürecini negatif etkiler.
Proje başlangıcında her detayı göz önünde bulundurmak mümkün olmadığı için, şelale modeliyle geliştirilen yazılım sistemlerinin müşteri gereksinimlerini tam tatmin etmediğini görmekteyiz. Bunun önüne geçebilmek için projenin başlangıç safhasında analiz için çok zaman harcanır ve müşteri gereksinimleri en ince detayına kadar tespit edilir. Aslında proje başlangıcıyla oluşturulan dokümanlar obsolet (eskimiş) hale gelmiştir, çünkü müşteri gereksinimleri piyasa ve rekabet koşulları gereği değişikliğe uğramış olabilir. Ne yazik ki şelale modeli bunları dikkate almaz ve müşterinin talep ettigi değişiklikleri aza indirmeye çalışır. Bunun bir sebebide sonradan gelen değişiklik taleplerinin maliyeti yükseltmesidir, çünkü bu durumda şelale modelinde yer alan safhaların birkaç kere uygulanması gerekebilir.

Bu çerçeveden bakıldığında proje sonunda oluşan program müşterinin aktüel gereksinimlerini tatmin etmez durumdadır. Program daha çok müşterinin proje başlangıcında sahip olduğu gereksinimleri tatmin edecek şekilde tasarlanmıştır. Projelerin birkaç sene boyunca sürebileceğini düşünürsek, aslında bu süreç sonunda oluşan program aktuel değildir.
Neden yazılımda şelale yöntemi kullanılmamalı?
-
Müşteri ne istediğini tam olarak bilmeyebilir. Bu yüzden proje öncesi detaylı analiz yapılması, müşterinin her gereksimini dile getirdiğinin garantisi değildir. Müşterinin bazı gereksinimlerini projenin ilerleyen safhalarında keşfetmesi durumunda, oluşan değişikliklerin projeye dahil edilmesi hemen hemen imkansiz olacaktır. Bunun en büyük sebeplerinden birisi de yazılım için oluşturulan tasarımın projesi öncesi belirlenmesi ve bu yüzden ilerde meydana gelebilecek değişikliklerin göz önünde bulundurulmamış olmasıdır. Projenin ilerleyen safhalarında meydana gelen her değişiklik tasarımı zorlar. Tasarım çevik olmadığı için değişiklikleri taşıyamaz.
-
Müşteri ne istediğini doğru olarak ifade edemeyebilir. Bu durumda proje öncesi yapılan analizler doğru olmayacaktır. Bu müşterinin istemediği bir yazılım sisteminin meydana gelmesine sebep olur. Şelale yöntemi müşteri ile devamlı diyalog içinde olunmasını engeller. Müşteriden geri dönüş sağlanamadığı için, müşterinin analiz safhasında meydana gelen yanlış anlaşılmaları düzeltmesi mümkün değildir.
-
Şelale yönteminde proje akışı bir sonraki safhaya geçiş yönündedir. Bu yüzden iletişim tek yönlüdür. Safhalar arası geri dönüş mümkün değildir. Bu yapılan hataların tamir edilmesini engeller.
-
Şelale yöntemi ile müşterinin istediği yazılım sistemi proje sonunda tamamlanır. Ancak bu safhada müsteri yazılım sistemini test edebilir. Müşteri tamamlanan yazılım sistemini tüm artı ve eksileriyle kabullenmek ve kullanmak zorundadır.
Özcan Acar
Çevik Süreç ve TDD Günü
Çevik Sürece Geciş Nasıl Olmalı?
Extreme Programming ve Scrum gibi çevik süreçlerin popüler olmasının sebebi, müşteri gereksinimlerini tatmin edebilen yazılım sistemlerinin oluşturulma sürecini kolaylastırmalarında yatmaktadır. Bu böyle olunca, yazılım firmaları, yıllarca şelala (Waterfall) metodundan çektikleri sıkıntılardan kurtulmak amacıyla çevik süreçlerin adaptasyonuna yönelmektedirler. Doğal olarak burada firmaların çevik sürecin adaptasyonu esnasında kafalarında oluşan bazı sorular var. Bunlardan en önemli iki soru şöyle: Okumaya devam et
Kurumsal Java Yazışma Grubu
Java / J2EE / Java EE / Extreme Programming konularında bilgi paylaşımını kolaylaştırmak için, Kurumsal Java Grubu ismini taşıyan bir Google Grup oluşturdum. Fikir alış verişinde bulunmak isteyen herkesi bu gruba davet ediyorum.
Grup websayfa adresi:
http://groups.google.com/group/kurumsaljava
Grup E-Posta adresi:
kurumsaljava@googlegroups.com Okumaya devam et
Eclipse ile Java EE Ear Projesi
Java EE 5 aplikasyonları EAR (Enterprise Archive) arşiv dosyaları içinde yer alır. Bir EAR dosyası JAR (Java Archive) dosyası yapısına ve .ear dosya ekine sahiptir. EAR dosyası içinde bir Java EE projesini oluşturan diğer modül arşivleri yer alır. Bir sonraki resimde bir EAR arşiv dosyasının yapısı yer almaktadır.

Bir EAR arşivinde yer alabilecek modül arşivleri şunlardır:
-
EJB JAR: EJB komponentlerin yer aldığı JAR dosyasıdır. Bu dosya içinde sadece EJB implementasyonları yer alır.
-
EJB Client JAR: EJB komponentlerinin sahip oldukları Remote ve Local EJB interface sınıflar EJB Client JAR arşivlerinde yer alır. Bu JAR dosyası EJB komponentlerini kullanmak isteyen diger modüllerin kullanımına sunulur.
-
WAR: Web aplikasyonları WAR (Web Application Archive) arşiv dosyalarında yer alır.
Bu yazıyı PDF olarak edinebilirsiniz.
Eclipse ile EJB 3 EAR Arşiv Projesi (760,4 KiB, 10.401 yükleme)
Eclipse projesini .rar dosyasi olarak edinebilirsiniz.
Türkiye’nin İlk Extreme Programming Konulu Kitabı
Pratik Agile isimli kitabım Pratik Programcı Yayınevi tarafından yayımlandı.
Çevik Java EE 5 Web Uygulamaları ve Mimarileri Semineri
7 Mart 2009 tarihinde, İstanbul Işık üniversitesinde çevik Java EE 5 web uygulamaları ve mimarileri isimli bir seminer vereceğiz. Seminer 09:00 – 18:00 saatleri arasında yapılacaktır. Bu seminerde çevik metot ve araçlar kullanarak, bir web projesinin test güdümlü olarak nasıl geliştirildiğini uygulamalı olarak yakından inceleyeceğiz.

Seminerde kullanılacak teknolojiler:
1.) Java 5.0
2.) Wicket Web Framework
3.) Spring Framework
4.) Hibernate
5.) HSQLDB
6.) Junit
7.) Eclipse 3.4
8.) JMock Mock Framework
9.) DBUnit
10.) EclEmma Code Coverage Tool
Web aplikasyonunda inceleyeceğimiz uygulamalar:
1.) Wicket ile web yazılımı
2.) Spring ile transaktion yönetimi
3.) Spring ile Hibernate kullanımı
4.) Wicket ile onay/kabul testleri
5.) JUnit ile unit ve entegrasyon testleri
6.) JMock ile test güdümlü yazılımda mock nesne kullanımı
7.) Web aplikasyonlarında üç katmanlı mimari
8.) Ant ve HSQLDB ile yazılımda çevik bilgibankası kullanımı
9.) DBUnit ile regresyon testleri
10.) İşletme katmanında Facade tasarım şablonu kullanımı
11.) Persistens katmanında DAO tasarım şablonu kullanımı
Katılım ücretsizdir. Kapasite sınırlı olduğu için, seminere katılmak isteyenlerin rezervasyon yaptırmaları gerekmektedir. Lütfen rezervasyon için aşağıdaki bağlantı bilgilerini kullanınız.
Bu bir uygulamalı seminer olduğu için, katılımcıların uygulamayı yapabilecekleri bir notebook ile gelmeleri tavsiye edilmektedir. Örnek proje katılımcılara seminer esnasında verilecektir.
Dikkat: 27.1.2009 tarihi itibariyle yoğun başvuru nedeniyle kontenjan dolmuştur. Lütfen başvuru için email göndermeyiniz.
Kendi üniversitelerinde bu tür seminerlerin düzenlenmesini isteyenler, lütfen bizimle iletişime geçsinler.
Rezervasyon
Rezervasyon için lütfen Mehmet beye bir email gönderiniz.
Mehmet Tolga Ertürk
Email: mtolgaerturk@gmail.com
SEMİNERİN YERİ VE TARİHİ
7 Mart 2009 – Cumartesi, 09:00 – 18:00 arası.
IŞIK ÜNIVERSİTESİ Kumbaba Mevkii ŞİLE, 34980
Santral: (0-216) 712 14 60
Faks: (0-216) 712 14 68
http://www.isikun.edu.tr
XP Plan Poker Kartları
Mike Cohn un sahibi olduğu Mountain Goat Software firmasından sipariş verdiğim planlama poker kartları bugün bana ulaştı. Bunlar bizim bildiğimiz poker kartlari değil. Kimse benim poker oynadığımı düşünmesin :) Bu kartlar planlama oyununda programcılar tarafından kullanıcı hikayelerinin implementasyon süresini tahmin etmek için kullanılıyor. Okumaya devam et
Extreme Programming Bünyesinde Proje Planlaması
Bir geminin rotası sefer öncesi kaptanı tarafından planlanır. Bu planda geminin demir atacağı limanlar ve seyahatin son noktası olan hedef liman yer alır. Okumaya devam et
The J2EE Architect’s Handbook
Derek C. Ashmore tarafından kaleme alınan bu kitapta, J2EE tabanlı mimarilerin nasıl oluşturulduğu tematize edilmektedir. Okumaya devam et
BizimAlem.com – Bir Sistemin Tasarlanış Hikayesi
BizimAlem.com 2001 ocak ayında başlamış olduğum bir web projesi. Amacım, Avrupa’da yaşayan 5 milyondan fazla Türk kökenli vatandaşımız için bir araya gelebilecekleri bir sanal ortam oluşturmaktı. Okumaya devam et
Çankaya Üniversitesi Wicket Sunumu
3 ocak 2009 tarihinde Ankara Çankaya üniversitesinde CETURK tarafından düzenlenen Java teknolojileri seminerine konuşmacı olarak katıldım ve Apache Wicket framework hakkında bir sunum yaptım. Sunum dosyalarını aşağıdaki linkler üzerinden edinebilirsiniz.
- Sunumda kullandığım Power Point presentasyonu
Wicket Webframework Sunumu (974,9 KiB, 7.108 yükleme)
- Wicket hakkında kaleme aldığım bir makale
Web Framework Gökyüzünde Yeni Bir Yıldız: Wicket! (805,8 KiB, 26.299 yükleme)
.




EOF (End Of Fun)
Özcan Acar

