Java Teknolojileri ve Programcıları Derneği | İstanbul JUG

Bu yazıda google’ın open source olarak piyasaya sürdüğü ve giderek telefonlarda görmeye başladığımız Android işletim sistemine application(uygulama) yazmak için ilk adımları atacağız.

• 1.       Android hakkında kısa bilgi
• 2.       Android Application yazma hakkında bilgi
• 3.       Android SDK kurulumu
• 4.       Eclipse ve ADT(Android Development Kit) plugin kurulumu
• 5.       Creating  “Hello Android” app
• 6.       Virtual Device’da applicationı test etme

2005 yılında Google'ın Android adlı küçük şirketi aldı. Kasım 2007'de Android'in ilk SDK'sı sunuldu. Mart 2009 da 1.1 sürümü, Mayıs 2009'da 1.5, Eylül 2009'da 1.6 ve son olarakta geçen ay yani Ekim 2009'da da SDK 2.0 sürümünü yayınladı.

Android linux çekirdeğini kullanan mobil cihazlar için open source işletim sistemidir. Android'in SDK'sı Java ile program geliştirme araçlarını ve API'lerini sağlamaktadır. Sağladığı genel özellikler :
Android uygulama geliştirebilmek için Androdin sitesinin developer bölümünden Androidin SDK'sını indiriyoruz.



Ben windows altında çalışma ortamımı oluşturacağım. İndirdiğimiz dosyayı çalışma ortamımıza çıkartıyoruz. Daha sonra klasörün içindeki "SDK Setup" ı çalıştırıyoruz. Ufak bi ayar yapmamız gerekmekte.



https ile genelde çalışmıyor. Bu yüzden böyle bir ayar yapıyoruz. Devamında :



Intalled package'a gelip update all diyoruz.



Burada önceki Sdk'ları yüklememize gerek olmadığı için ben screenshot'daki 4ünü seçtim. Install Accepted diyerek devam edelim.





Ve SDK kurulumda Son:



Şimdi Eclipse ortamını hazırlayabiliriz. Eclipse'in yeni sürümleri kullanmamız gerekiyor. (3.4 ve sonrası) Eclipse'i açıyoruz.
ADT Pluginini kuralım. bunun için:



Help > Install New Softare daha sonra gelen ekrandan Add e tıklayalım.




Sonra ekrandaki name alanına Android App yazabilirsiniz. Location alanına da

"http://dl-ssl.google.com/android/eclipse/" giriyoruz. Daha sonrası Next Next olayı.

Eclipse kapatılıp açılacaktır, açıldıktan sonra ADT araçları göreceksiniz. ARTIK ÇALIŞMA ORTAMIMIZ HAZIR. Şimdi ilk uygulamamızı yazalım.

------------İlk Örneğimiz HeLLO Android ----------
Bunun için eclipse de File > New > Project diyoruz.



Android Project'i seçiyoruz.



Gelen ekrandan gerekli alanları dolduruyoruz. Burada;

Project Name

     Eclipse de oluşturduğumuz projenin adı.

Application Name

     Android uygulamasının üzerinde görülecek olan isim

Package Name

    Javadaki package yapısı ile aynı

Create Activity

   İlk başta package altında açılacak olan class'ın adı. (Opsiyonel)

Şimdi com.jtpd.helloAndroid altındaki HelloAndroid.java class'ını açalım.

 
Şimdi de Uygulamamıza ekleme yapalım.

Tüm olay bu kadar basit. Şimdi de çalıştırıp Virtual Device da test edelim. Bunun için Run as -> Android Applicaton seçiyoruz.









Umarım basit bir olayı karmaşıklaştırmamışımdır. Yazıyı oluştururken yararlandığım kaynak http://developer.android.com .

Bileşen bazı web çatısı (Component Based Web Framework) olan Apache Wicket ile kendimize ait bileşenler oluşturmak çok kolay. Web uygulamalarımızda çok kullandığımız kullanıcı yönlendirici mesajları göstermek için bir Wicket Bileşeni nasıl oluştururuz gelin hep birlikte görelim.
[--split--]

Apache Wicket ile Bileşen Tabanlı (Component Based) Web uygulaması gerçekleştirmek kolay ve zevkli bir iş haline geliyor. Bir iki klavye hamlesi ile AJAX uygulaması yazabilirsiniz.

Uygulamalarda kullanıcı bilgilendirme mesajları kimi zaman ilgili formun üzerinde, form girişlerinin yanında ve ya ayrı sayfalarda gösterilmektedir. Bu mesajların gösterimindeki görsel uyumluluk kullanıcının mesajı okumadan içeriği hakkında bilgi sahibi olmasını sağlar. Yönlendirme düğmeleri (button) kullanılarak hangi işleme devam etmesi seçenek olarak sunulur.

Aşağıdaki gibi bir mesaj kutusu tasarladım.



1. SUCCESS, INFO, WARNING, ERROR ve UNAUTHORIZED şeklinde 5 tip mesaj gösterebiliriz.
2. Her mesaj tipinin kendisine ait logosu olacak.
3. Bazı genel mesajlarda title ve footer alanı olmayacak.
4. İstediğim kadar yönlendirme düğmesi ekleyebilmeliyim.

Çizmiş olduğumuz arayüz tasarımını, tasarımcıya verip HTML ve CSS kodlamalarını gerçekleştirelim.

HTML kodları içerisinde Apache Wicket bileşenlerine wicket:id eklemesini yapalım.


Wicket bileşenleri:
 
         1. Mesaj Logosu
         2. Mesaj Başlık Panel’i
         3. Mesaj Başlığı (Title)
         4. Mesaj Gövdesi (Body)
         5. Mesaj Sonu (Footer)
         6. Yönlendirme Düğmeleri (Buttons)


Neden mesaj başlığını bir panel içerisine koyuyoruz? Cevabı basit, başlığı olmayan bir mesaj göstermek istediğimde gövdenin yukarısında göze batacak kadar boşluk olmasını istemiyorum. Bu yüzden burada bulunan div’i gizlemem gerek. Bunun için de başlığın bulunduğu div’e bir wicket panel’i olarak işlem yapacağım.


UML Sınıf Diyagramım aşağıdaki gibi olacaktır:



Gösterilecek olan başlık anahtarını, içerik anahtarını (ResourceBundle Key), düğmeleri taşıyacak Message sınıfı oluşturdum.



Gösterilecek olan mesajın tipine göre logo değişimi olacaktır. Bu yüzden resim tanımlarını mesaj tipi ile ilişkilendirdim. Bunun için Enum yapısını kullanabiliriz. Eğer renk farklılığı da olması istenirse CSS tanımlarını da burada kullanabiliriz.


MessageButton soyut sınıfından oluşturacağımız her nesnenin kendine özel davranışı olacaktır. Bu yüzden soyut clickButton yordamı tanımladık. AjaxLink Wicket yapısını kullanarak butonların HTML Button’u olarak işlem görmesini Form Submit Button’u olarak tanımlanmamasını sağlarız. Parametre olarak aldığımız AjaxRequestTarget nesnesinin addCompenent() yordamını kullanarak bize Ajax Call’u sonunda hangi bileşenlerin yeniden yorumlanacağını (rendering) ve yeni HTML kodu üretileceğini belirleriz.


Gelelim mesajlarımızı ve diğer görsel bileşenleri Wicket Panel ile göstermeye. Bunun için Panel Wicket yapısından türemiş MessagePanel sınıfını oluşturmalıyız.


Yukarıda gördüğümüz gibi MessagePanel sınıfı IHeaderContributor arayüzünü gerçekleştirmiş. Eğer bir Wicket Bileşen’inin Header’da değişiklik yapmasını istiyorsak bu arayüzün renderHead() yordamını gerçekleştirmesini sağlamalıyız. CSS ve resim dosyalarının MessagePanel ile paketlemek istediğimiz için aynı dizinde bulunmalıdırlar. Wicket tarafından kullanılabilir olmaları için herbirine ait ResourceReference nesnesi oluşturuyoruz.

Mesaj kutusunun inşaası yapılandırıcı içerisinde gerçekleşmekte. Yapılandırıcı dışında onBeforeRender() yordamı içerisinde de bunu gerçekleştirebiliriz.

Yapılandırıcı içerisinde liste içerisindeki MessageButton’ları göstermek için ListView Wicket yapısını kullanıyoruz. Bu yapı da bir wicket html tanımına ihtiyaç duymaktadır.


Önceki paragraflarda title’in isteğimize göre görünmesini/görünmemesini bunu ayrı bir Wicket Panel gibi düşünerek sağlayabiliriz demiştik. Yapılandırı içerisindeki son satırlarda göndermiş olduğumuz hideTitle parametresine göre panelin setVisible(false) yordamını çağırıyoruz. Başlığı içerecek kısmı panel olarak tanımladığımız için buna ait Wicket Panel sınıfı ve html dosyası oluşturmamız gerekmektedir. Encapsulation prensiplerine uyarak bu panel sınıf tanımını private erişim belirtecine sahip Inner Class olarak yapalım.


Wicket Html tanımı ise ConfirmMessagePanel$TitlePanel.html dosyası içerisinde bulunmalı. Dikkat edildiği gibi derleme sonrasında oluşacak inner class dosya ismi ile aynı.


Oluşak olan uygulama dizin yapısı aşağıdaki gibidir:


Uygulama içerisinde MessagePanel’imizi nasıl kullanacağız? İşte burada bir örnek mevcut:



Sonuç :



Mesajlarımızın ModalBox içerisinde görünmesini istiyorsak

Apache Wicket ile modal pencereleri yapmak çok kolay. ModalWindow Wicket yapısından yeni yapılar türeterek bunu gerçekleştirebiliriz.

MessagePanel nesnesini Modal özelliği katmak için sarmalayıcı bir sınıf oluşturalım. MessageModal, ModalWindow’dan türeyen bir yapı.



MessageModal ile gösterilen mesajlarda başlıklar pencerenin başlığı olarak görünmesini istedim. Bunun için MessagePanel’in yapılandırıcısına hideTitle parametresi için TRUE değeri gönderdim, ModalWindow’dan miras aldığım setTitle() ile ModalWindow’a başlık ataması yaptım.

ModalWindow’u göstermek için show() yordamını kullanıyoruz. Bunun için Ajax desteği olan bir bileşenin oluşturduğu istek ile AjaxRequestTarget nesnesi gelmesi gerekmektedir.

MessageModal’ın bir de HTML dosyası olmalı :


Modal kullanımları için ilgili modal kodlarını içerecek bir Wicket Bileşeni tanımlamamız gerekmektedir.


MessagePanel oluşturur gibi MessageModal oluşturabiliriz:


Göstermek için ise bir Ajax olayına ihtiyacımız var. Bunun için bir önceki bölümde oluşturduğumuz MessagePanel nesnesine “Show” isimli yeni bir buton ekliyorum.


Uygulamayı çalıştırıp sonucunu görelim:




Proje kodlarına buradan ulaşabilirsiniz.

CETURK olarak Çankaya Üniversitesi Uygulamalı Matematik Bilgisayar Bilimleri Topluluğu ile birlikte  “JAVA ve Kariyer Günü” etkinliği düzenliyoruz. Etkinlik konusu dahilinde JAVA dünyasındaki kariyer olanaklarından bahsedilecek ve etkinlik sonundaki panelimiz ile bilgi alışverişi gerçekleştirilecektir.

Etkinliğe katılım her zamanki gibi ücretsizdir.Bu etkinliği sitesinde duyuran 2 kişiye kitap hediye edilecektir.

Konuşmacılar  ve Seminer Konuları:

Kadir Teke – Mehmet Gursul : İş İlanlarında Java

Kenan Sevindik : Java, Kariyer ve Gelecek

Mert Çalışkan : Fikrim Açık, Kodum Açık

Ümit Vardar : JavaFX

Adres:

Çankaya Üniversitesi – Mavi Salon

Tarih: 19 Şubat 2010

Saat: 10:30 – 17:00

Kayıt işlemi için tıklayın.

"In the end, the project was a big success and a breakthrough not in the country but at the global level. So I think developing enterprise application doesn’t mean you gotta go JavaEE. Putting together your own OSGI stack is much better. Plus while developing, you will get the joy of restarting the application in a matter of seconds rather then in minutes in comparison to application servers..."

Hasan Ceylan (http://tr.linkedin.com/in/hasanceylan) tarafından yazılan yazının devamı için buraya gidebilirsiniz.

Java 1.5 ile gelen yenilikler içerisinde bulunan Genel Tipler ile bazı kod yazma pratiklerimizi değiştirmek ve kendimizi geliştirmek zorunda kaldık. Data Access Object ve Service gibi Üst Seviye Tasarım Kalıplarında (Enterprise Design Patterns), Java Torbalarında (Collections & Map) çok sık kullanır olduk. Tasarımsal olarak getirdiği faydalar olduğu gibi kötü kullanımda da kod okunabilirliliğini azaltmaktadır. Gelin Genel Tipler'in nasıl kullanıldığını bir bakalım...  Yazının diğer bölümleri : Bölüm-2
[--split--]
Nedir bu genel tipler (Generic Types)? Beynimizi çok yormaya gerek yok. Java 1.5 öncesinde bir liste oluşturduğumuzda ve bu listeden bir nesne almak istediğimizde zahmetli bir işe kalkışırdık :
    1:   List liste = new ArrayList();
    2:   liste.add(new Integer(0));
    3:   liste.add(new Integer(1));
    4:   for(int i=0; i<liste.size(); i++){
    5:        Integer sayi = (Integer) liste.get(i);
    6:   }

6. satırda olduğu gibi istediğimiz tipe dönüşüm yaparak (upcasting / downcasting) istediğimiz nesneyi kullanabilirdik.
     1:    List liste = new ArrayList();
    2:   liste.add(new Integer(0));
    3:   liste.add(new Integer(1));
    4:   liste.add(new String("test"));
    5:   for(int i=0; i<liste.size(); i++){
    6:        Integer sayi = (Integer) liste.get(i);
    7:        System.out.println("["+i+"] = "+ sayi);
    8:   }

Sonuç:
[0] = 0
[1] = 1
Exception in thread "main" java.lang.ClassCastException: java.lang.String
    at com.articles.generics.objectcaching.ObjectPoolManager.main(ObjectPoolManager.java:67)

Oluşturduğumuz liste nin sadece Integer tipindeki nesneleri içereceğini düşünürken takım arkadaşımız başka bir yordam içerisinde öyle bir kod yazmışki bu liste içerisine String tipinde bir nesne atmış ( 4. satır ). Çalışma zamanında (Runtime) bu liste içerisindeki nesneleri Integer tipine dönüştürerek alırken String tipinde bir nesnenin gelmesi hata fırlamasına ve uygulamamızın durmasına neden olmaktadır.


Java 1.5 ile gelen genel tipler ( Generics ) bize tam burada yardımımıza koşmaktadır : çok sık kullandığımız Collection ve Map hiyerarşisindeki torbaların (containers) kullanımında yukarıdaki sorunların ortadan kalkması...
     1:    List<Integer> intList = new ArrayList<Integer>();
     2:    intList.add(new Integer(1));
     3:    intList.add(new Integer(2));
     4:    intList.add(new String("3"));

Satırları javac ile derlemeye çalıştığımızda :

şeklinde derleme uyarısı alırız. Çünkü 1. satırda <Integer> ifadesi (tip parametresi) ile oluşturacağımız listeye Integer tipi üzerinde işlem gerçekleştireceğimizi söyleriz. String tipinde bir nesneyi listeye koymak istediğimizde ise derleme hatası alırız. Böylece çalışma zamanında (Runtime) beklenmedik tip dönüşümlerinden meydana gelen hatalardan kurtulmuş oluruz.
Nesne Havuzu ( Object Pool )

Jenerik yapıları anlamak için gelin bir uygulama geliştirelim. Bu uygulama veritabanı bağlantı havuzu (DB Connection Pool) yada iş parçacıkları havuzu (Thread Pooling) gibi asıl amacı sürekli tekrarlayan işlemlerde belli bir tipteki nesnelerin her seferde oluşturulması ve silinmesini engellemektir. Böylece uygulamada gereksiz yavaşlamaları engelleyebilir ve nesne takibini iyileştirebiliriz.


Gelin öncelikle uygulamamızı süper yapıları tanımlayarak başlayalım. Bu süper yapılar : arayüzler (interface), süper sınıflar (super class) ve soyut sınıflar (abstract class) olabilir.
Süper yapılara üzerinden uygulamamızı geliştirdiğimiz zaman ileriye yönelik geliştirme ve sistemler arası iletişim daha kolay yapılmış olacaktır.


Oluşturacağımız süper yapılar:

1.      Yedeklenebilir Arayüzü (Interface) : Sistem tarafından havuzda tutalacak olan nesnelerin sınıf tanımlamaları bu arayüzü gerçekleştirmelidir.
2.      Havuz Arayüzü (Interface) : doldur(), cek()/koy(), bos() soyut yordamlarını içeren arayüzdür. Bu arayüzü gerçekleştiren sınıflar <<Yedeklenebilir>> arayüzünü gerçekleştirmiş yapılar için sınırlandırılmalıdır.
3.      HavuzYöneticisi Arayüzü (Interface) : nesneCek(), nesneKoy() ve havuzuKontrolEt() yordamlarını içermektedir.
    a.      nesneCek() yordamı istenen nesnenin tipine göre ilgili havuzdan nesne çekecek
    b.      nesneKoy() yordami gönderilen nesneyi, nesnenin tipine göre ilgili havuza geri koyar.
    c.       havuzuKontrolEt() yordami nesneCek() yordami çağrıldığında ilgili nesne için havuz nesnesinin yaratılıp içerisinin doldurulmasını kontrol eder.


          
 Havuz Arayüzü


/**
*{@link Yedeklenebilir}arayüzünügerçekleştirmiş
*nesneleriçinhavuzgörevinigörür.
*
*@param<T extends YedeklenebilirNesne>
*/
public interface Havuz <T extends Yedeklenebilir> {
    
     /**
      *Havuzdannesneçeker.
      *@returnT
      */
     T cek();
    
     /**
      *Nesneyigerikoyar.
      *@paramobject
      */
     void koy(T nesne);
    
     /**
      *clazztipindenesneleriyaratipkendisinidoldurur.
      *@paramclazz
      *@throwsNesneYaratmaHatasi
      */
     void doldur(Class<T> clazz) throws NesneYaratmaHatasi;
    
     /**
      *clazztipindenesnelerdenbelirtilenadetkadar
* yaratipkendisinidoldurur.
      *@paramclazz
      *@paramadet
      *@throwsNesneYaratmaHatasi
      */
     void doldur(Class<T> clazz, int adet) throws NesneYaratmaHatasi;
    
     /**
      *Havuzunbosolupolmadigikontroledilir
      *@returnboolean
      */
     boolean bos();
}


Havuz arayüzüne ait yukarıdaki tanımlamada dikkatimizi <T extends Yedeklenebilir> tip parametresi çekmektedir. Böylece Havuz arayüzünü sadece Yedeklenebilir arayüzüne erişmiş yapılar için genelleştirmiş / sınırlandırmış (bounding) olduk.

Taner Diler
taner.diler[et]gmail.com

Java 1.5 ile gelen yenilikler içerisinde bulunan Genel Tipler ile bazı kod yazma pratiklerimizi değiştirmek ve kendimizi geliştirmek zorunda kaldık. Data Access Object ve Service gibi Üst Seviye Tasarım Kalıplarında (Enterprise Design Patterns), Java Torbalarında (Collections & Map) çok sık kullanır olduk. Tasarımsal olarak getirdiği faydalar olduğu gibi kötü kullanımda da kod okunabilirliliğini azaltmaktadır. Gelin Genel Tipler'in nasıl kullanıldığını bir bakalım...  Yazının diğer bölümleri : Bölüm-1
[--split--]

NesneHavuzu Sınıfı


public class NesneHavuzu<T extends Yedeklenebilir>
     implements Havuz<T> {
    
     private Vector<T> havuz = new Vector<T>();


     /* (non-Javadoc)
      * @see com.articles.generics.objectcaching.Havuz#doldur(java.lang.Class)
      */
     public void doldur(Class<T> clazz) throws NesneYaratmaHatasi {
           this.doldur(clazz, 5);      
     }
    
     /* (non-Javadoc)
      * @see com.articles.generics.objectcaching.Havuz#doldur(java.lang.Class, int)
      */
     public void doldur(Class<T> clazz, int adet)
throws NesneYaratmaHatasi {


           try {
                 for(int sayac=0; sayac<adet; sayac++){
                       this.havuz.add(clazz.newInstance());
                 }
           } catch (InstantiationException e) {
                 NesneYaratmaHatasi ex =
new NesneYaratmaHatasi(clazz, e.getStackTrace());
                 throw ex;
           } catch (IllegalAccessException e) {
                 NesneYaratmaHatasi ex =
new NesneYaratmaHatasi(clazz, e.getStackTrace());
                 throw ex;
           }
     }
    
     /*
      * (non-Javadoc)
      *
      * @see com.articles.generics.objectcaching.Pool#pull()
      */
     public T cek() {
           T object = havuz.remove(0);
           return object;
     }


     /*
      * (non-Javadoc)
      *
      * @see com.articles.generics.objectcaching.Pool#push(com.articles.generics.objectcaching.CachableObject)
      */
     public void koy(T object) {
           havuz.add(object);
     }


     /* (non-Javadoc)
      * @see com.articles.generics.objectcaching.Havuz#bos()
      */
     public boolean bos() {
           return this.havuz.isEmpty();
     }}


NesneHavuzu sınıfına dikkat edersek :  Havuz arayüzündeki tip parametresi
<T extends Yedeklenebilir>  burada da mevcut. Neden böyle?  Bakalım:


NesneHavuzu sınıfında <T extends Object> tanımını kullanıp derlemek istediğimizde :
şeklinde bir uyarı ile karşılaşırdık. Bu uyarıda NesneHavuzu sınıfı tanımlamasındaki tip parametresi, Havuz arayüzünün beklediği tip parametresinin sınırları dışında oluduğu belirtilmektedir.

NesneHavuzu sınıfında <T extends X_Nesne> tanımını kullanıp derlemek istediğimizde herhangi sorun ile karşılaşmayız çünkü T tip parametresi Havuz arayüzünün beklediği sınırlar yani Yedeklenebilir arayüzünün alt hiyerarşisi içerisindedir.


Peki Havuz arayüzünün tanılamasını public interface Havuz <T> şeklinde değiştirdiğimiz de ne olur? Birşey olmaz çünkü böyle yaparak Havuz arayüzü üzerindeki kısıtlamayı kaldırıp bu arayüzü her tipten yapı için çalışır duruma getirmiş oluruz, standart Java paketi içerisindeki torba (Hash, List ...) yapılarında olduğu gibi.


Şimdi de şöyle bişey deneyelim. Havuz arayüzünü eski haline getirelim ama bu sefer NesneHavuzu sınıfı tanımını NesneHavuzu<T> implements Havuz<T> şeklinde değiştirelim. Derlemek istediğimiz de


<T extends Object> örneğimizde olduğu gibi yine aynı nedenden dolayı derleme zamanında uyarı  alırız.

Peki alt hiyerarşi sınırlandırması için bir tanımlama mevcutken üst hiyerarşi sınırlandırması için bir tanımlama mevcut mu?  <T super Yedeklenebilir> Yedeklenebilir arayüzünün üst hiyerarşisi için sınırlama yapılır.

Şimdiye kadar yazmış olduğumuz yapıların testini gerçekleştirelim.


public class HavuzTest extends TestCase {
     private X_Nesne x_n1 = new X_Nesne();
     private X_Nesne x_n2 = new X_Nesne();
     private Y_Nesne y_n1 = new Y_Nesne();
     private Y_Nesne y_n2 = new Y_Nesne();
    
     Object obje_1 = new Object();
    
     private NesneHavuzu<X_Nesne> x_havuz = new NesneHavuzu<X_Nesne>();
     private NesneHavuzu<Y_Nesne> y_havuz = new NesneHavuzu<Y_Nesne>();
     private NesneHavuzu<Yedeklenebilir> genel_havuz = new NesneHavuzu<Yedeklenebilir>();
    
     public void testCek() {
           X_Nesne x_nesne_1 = x_havuz.cek();
//          Y_Nesne x_nesne_2 = x_havuz.cek(); Derleme hatasi verir
           Y_Nesne y_nesne_1 = y_havuz.cek();
          
          
//          Cek yordami Yedeklenebilir tipinde değer dönerken
//          biz X_Nesne tipinde bekliyoruz.
//          X_Nesne x_nesne_3 = genel_havuz.cek();
          
           X_Nesne x_nesne_3 = (X_Nesne) genel_havuz.cek();
          
     }


     public void testKoy() {
           x_havuz.koy(x_n1);
           x_havuz.koy(x_n2);
//          x_havuz.koy(y_n1); Derleme hatasi verir
          
           y_havuz.koy(y_n1);
           y_havuz.koy(y_n2);
          
           genel_havuz.koy(x_n1);
           genel_havuz.koy(y_n1);
    
//          x_havuz.koy(obje_1);         DERLEME HATASI
//          y_havuz.koy(obje_1);         DERLEME HATASI
//          genel_havuz.koy(obje_1);     DERLEME HATASI
     }
}


HavuzYoneticisi Arayüzü

public interface HavuzYoneticisi {
    
<T extends Yedeklenebilir> void nesneKoy(T nesne) throws NesneYaratmaHatasi;
    
<T extends Yedeklenebilir> T nesneCek(Class<T> clazz) throws NesneYaratmaHatasi;
    
<T extends Yedeklenebilir> void havuzuKontrolEt(Class<T> clazz) throws NesneYaratmaHatasi;
}

Burada dikkat etmemiz gereken, arayüzü değil arayüz içerisindeki yordamları genelleştiriyor olmamız. <T extends Yedeklenebilir> tip parametresi korunarak yine hiyerarşi sınırlandırması yapmış oluyoruz. Eğer HavuzYoneticisi arayüzünü de <T extends Yedeklenebilir> tip parametresi ile genelleştirmiş olsaydık sadece tek tip bir yapı için çalışıyor hale gelirdi. Tıpkı Havuz arayüzü gibi :

           NesneHavuzu<X_Nesne> x_havuz = new NesneHavuzu<X_Nesne>();


NesneHavuzuYoneticisi Sınıfı

public class NesneHavuzuYoneticisi implements HavuzYoneticisi {


     private Map<Class<? extends Yedeklenebilir>,
Havuz<? extends Yedeklenebilir>>
havuzMap = new HashMap<
Class<? extends

Maven, Spring, Hibernate, Wicket ile uygulama geliştirmek için atacağınız ilk adımlar...

İzleyeceğimiz adımlar: 


Maven kurulumu için maven.apache.org sitesinden maven paketini indirip açtıktan sonra içerisindeki bin klasörününü de sistemin “Ortam Değişkenleri”ne tanımlayabilirsiniz.

mvn archetype:create -DgroupId=org.jtpd
                          -DartifactId=maven_spring_hibernate_wicket
                          -DpackageName=org.jtpd

komutunu kullanarak maven projemizi oluşturalım. Pom.xml içerisindeki packaging tanımını war yapalım.

Oluşan pom.xml :


Oluşan dizin yapısı:


Log4j, Spring gibi konfigurasyon dosyalarını koymak için /src/main/resources dizinini ve web dosyalarını koymak için /src/main/webapp oluşturalım. Ve sonrasında pom.xml'i açıp aşağıdaki ayarlamaları yapalım.


Gelin şimdi Spring & Hibernate paket bağımlılıklarını ayarlayalım:


Spring konfigurasyonunu gerçekleştirelim. Bunun için src/main/resources altında application-context.xml dosyasını oluşturalım.


Yukarıdaki konfigurasyonda, spring injectionlarının ve transaction tanımlarının annotationlar üzerinden yapılacağı belirtilir.
Uygulama içerisindeki kullanımı :


Şu ana kadar yazmış olduğumuz kod örneğini ve konfigurasyonu test etmek için standalone çalışabilecek bir kod çalışması yapalım. Öncelikle pom.xml içerisinde aşağıdaki konfigurasyonu yapalım.


org.jtpd.App java dosyasını oluşturalım:


App sınıfını komut satırından


komutu ile çalıştırabiliriz.
 
Herşey istediğimiz gibi ise şimdi geliştirdiğimiz yapıyı web uygulaması haline getirelim. Bunun için pom.xml'de :


src/main/webapp altında WEB-INF/web.xml dosyasını oluşturalım ve aşağıdaki konfigurasyonları tanımlayalım


Web.xml de  Spring ve Wicket çatılarına ait tanımlamaları yaptık.application-context.xml içerisinde de Wicket uygulamasını tanımlamamız gerekiyor. Web.xml içerisinde  WicketFilter konfigurasyonunda Wicket çatısına aşağıdaki WebApplication sınıfını hangi factory üzerinden alacağımızı belirtiyoruz. Burada Wicket ile Spring entegrasyonunu gerçekleştirmiş oluyoruz.


Şu ana kadar Maven, Spring, Hibernate ve Wicket entegrasyonunu bir şekilde gerçekleştirmiş bulunmaktayız. Fakat Wicket bileşenlerinden Spring bean'lerine injection yöntemiyle erişmek için JTPDWicketApplication sınıfının yapılandırıcı yordamlarında

 
çağırımlarını yapmamız gerekmektedir.
 
JTPDWicketApplication sınıfı :


WebApplication, WebPage gibi Wicket bileşenleri içerisinden Spring bean'lerini kullanabilmek için @SpringBean annotation'ını kullanmamız gerekmektedir. JTPDWebApplication içerisinden çağırılan Index.class yani WebPage'den türeyen Index sınıfını oluşturalım ve buradan userService Spring Bean'ini nasıl çağırdığımızı görelim.


Wicket çatısında yazılan WebPage, Panel gibi bileşenler için markup tanımlarını içeren  sınıf ile aynı isimde *.html uzantılı dosyalar bulunmalıdır. Maven ile derleme ve paket oluşturma sonucunda bu html dosyalarınında değerlendirilmesi için pom.xml’de şu eklemeyi yapacağız:


İlgili çalışmaya ait kodlara buradan ulaşabilirsiniz.