Previous
Next

Java Server Faces (JSF) nedir?

by Cem Kefeli 17. Mayıs 2016 05:49

Tüm java makalelerime buradan ulaşabilirsiniz...Java

Java Server Faces (JSF) kavramını anlatabilmek için ilk önce Java'nın bu güne kadar sunmuş olduğu önyüz/arayüz dinamik yapılarını incelemek gerekir diye düşünüyorum.

En başa java servlet'ler yerleşir ki java servlet'ler 1990'lı yıllardan ve de JDK 1.0'dan bu yana hayatımızdadırlar. Güncel versiyonu 4.0'dır ve en son J2EE 8 ile birlikte duyurulmuştur. Temel olarak sunucuya gelen HTTP isteğini keser, ilgili kod parçacığını çalıştırarak yorumlar, ve de istemciye bir cevap dönerler. Servlet'ler içerisinde java kodları bulunur ve istemciye gönderilecek HTML çıktılar bu kodların içerisinde barındırılırlar. Yani servlet teknolojisinde Java kodu içerisine HTML kodları gömülebilir.

İkinci sırada Java Server Pages (JSP) teknolojisi gelmektedir ki aslında JSP'ler de çalışma mantığı olarak yine servlet'ler üzerine kuruludurlar. Arka planda çalışan aslında bir servlet'tir. Fakat uygulamayı yazan kişi bu arka plandaki durumu görmez. Farkı ise JSP'lerin kodlama mantığının HTML üzerine kurulu olmasıdır. Nasıl ki yukarıda bahsettiğim gibi servlet'lerde java kodları arasında HTML kullanılıyorsa, JSP'lerde de HTML içerisine java kod parçacıkları gömülebilmektedir. HTML öğeleri örneğin formlar, tablolar, imajlar doğrudan JSP içerisindeyer alırlar. JSP'ler, servletlere göre görselliği daha ön plana çıkaran yapılar sunar.

Java Servlet, JSP, JSF Historyt

Şimdi asıl konu olan JSF'lere dönelim. Servler'ler ilk ortaya çıktığı gün, günün ihtiyaçlarını karşılıyorlardı. Bir süre sonra görselliği ön plana alan JSP teknolojisi ortaya çıkıverdi. JSP bir nebze olsun görsellik konusunu ileriye taşıdı ama aranan kan halen bulunamamıştı aslında. JSF'nin duyurulması ile birlikte hem kod katmanına hem de görsel katmana hitap eden bir yapı ortaya çıktı. C#, C++ ya da java gibi dillerle masaüstü uygulaması geliştirenler bilirler, form üzerine yerleştirdiğiniz nesnelere aksiyonlar atayabilirsiniz. Örneğin forma bir buton yeteştirdiniz üzerine çift tıklarsanız butona tıklandığında çalışacak olan listener'a ulaşmış olursunuz. Bu listener, kod bloğu, içerisine buton tıklandığında yapılması istenen işlere ait dilediğiniz gibi kod yazabilirsiniz. İşte JSF ile birlikte masaüstü programlamanın bu güzel görsel yapısı bir nebze olsun WEB ile de buluşmuş oldu. JSF ile birlikte artık hem HTML kod tarafında bir kaynak kodumuz, hem de pure java tarafında bir kaynak kodumuz bulunuyor, ve de framework sayesinde bu ikisi arasında bir etkileşim de mevcut.
Fazlası...

Java Memory Yönetimi

by Cem Kefeli 3. Şubat 2016 02:39

En sıkıntılı konulardan birisidir bir uygulamayı geliştirirken ve de canlıya alınması sonrasında karışılaşılan memory problemleri. Eğer geliştirme aşamasında tecrübelerinizden de faydalanarak olası memory problemlerini öngörebilirseniz canlıya çıkış sonrası oluşabilecek problemleri azaltabilirsiniz. Ya da daha geliştime ve test aşamasında bir memory problemi ile karşılaşırsanız, ki genelde uygulama gerçek yük altında çalışmaya başladığında açığa çıkarlar, fix etme imkanınız olur ve şanlısınız demektir.

C/C++ ile uygulama geliştirdiyseniz bilirsiniz ki bellek yönetimini tamamen geliştiriciye bırakır. Geliştirici istediği adresteki istediği bellek gözüne kadar herşeye hakimdir. Örneğin işaretçiler yardımıyla bellek gözlerini dilediği gibi yönetebilirler. Bu durum iyi kodlanmış yazılımlar için daha optimal memory kullanımlarını birlikte getirir. Düşünsenize tasarladığınız yazılımın her bir byte seviyesinde her bir bellek gözüne hakimsiniz ve nerede ne var tamamen biliyorsunuz, işlerinizi ona göre planlıyorsunuz. Ama ya iyi kodlanmamış bir yazılım varsa elinizde? Belki de iyi bir uygulama geliştirici değilsinizdir... Bellek yönetiminin esnekliği yerini bir anda bir kaos ortamına bırakıverir. Belki erişmemeniz gereken, sizin olmayan bir bellek gözlerine erişirmişsiniz ve hata alırsınız. Belki de ayırdığınız bellek alanlarının dışına çıkarsınız çalışma anında ve de yine hata alırsınız...

Bununla birlikte eğer nesle yönelimli (Object Oriented Programming - OOP) bir yazılım dili kullanarak uygulama geliştiriyorsanız sevindirici haberler de vardır. OOP konsepti herşeyi birer nesne olarak ele almak istediği için, nesnelerin varlığından ve de yokluğundan haberdar olmak isterler. Nesneleri doğduğu andan öleceği ana kadar takip ederler. Nesne doğduğu anda ona bir yuvacık sunarlar. Biraz ergenleştiği zaman onu yuvacıktan alıp yeni bir yuvaya nakleder ki yeni doğanlara yer açılsın. Nihayetinde zaman gelip de nesnenin ömrü dolduğunda kalıcı olarak yuvayı bozarlar ve nesne de artık yok olur. Bu yuva ve yuvacıkları bellek bölümleri olarak düşünebilirsiniz. Yuvaların tahsisi konusunu yöneten bir birim de vardır tabiki ve örneğin java için bu işi üstenen Garbage Collector (GC)'dür. GC, neslerin ömrü boyunca bellek işlerinden sorumlu müdürlüktür. Yeri geldiğinde kullanılmayan nesneleri de temizleyerek ilgili belleğin tekrar kullanılabilmesi amacıyla geliştiricinin hizmetine sunar. Geliştirici bu konseptte bellek işleri ile ilgilenmez.

Java Memory Management
Fazlası...

JAVA - Çok kanallı (Multi-Threaded) programlama

by Cem Kefeli 16. Haziran 2014 00:00

Tüm java makalelerime buradan ulaşabilirsiniz...Java

Yazdığım 15 kadar Java makalesinden sonra düşündüm ki Java'da çok kanallı programlamadan bahsetmemek büyük bir eksiklik olmuş bu yazı dizisi için. Şu sıralar üzerinde uğraştığım bir proje de bu durumu biraz tetikledi açıkçası. Hazır çok kanallı programlamaya (ki bundan sonra multi-threading diyeceğim...) derinlemesine inmişken bu konuya da yüzelsel olarak bir değinmek istedim.

Programlama dillerini iş yapan bir işçiye benzetirsek, tıpkı bir işçi gibi işlerini belirli bir sırayla yaptığını görürürüz. Yani bir program parçacığı çalışır, bir işi yapar, bititir, sonra bir diğer işe başlar, onu bititir, sonra bir yenisine başlar. Süreç bu şekilde kendisine verilen işler bitene kadar devam eder. Eğer yalnızca bir işçiniz varsa burada işçi için değil de iş süreci için bir çıkmaz oluşacağını hissetmişsinizdir. Tabi ki burada işin niteliği de önemlidir. Çünkü bir işçi yalnızca ve yalnızca kendisine verilen bir işi yerine getirir, işi bitmeden de bir diğer işi yapamaz. Peki ya bizim senkron bir şekilde yapılması gereken işlerimiz varsa ne olacak? Cevap basit aslında yeni işçiler almalıyız. İşte programlamada çoklu-işçiliği sağlayan multi-threaded yapılardır. Bu arada "Ne kadar senkron?" sorusunu aklınızın bir kenarına şimdilik not edin, ilerleyen dakikalarda inceleyeceğiz...

Programlama hayatından daha gerçekçi bir örnek vererek ilerleyelim;

Örneğin bir uygulama yazmak istiyoruz. Bu uygulama hem sürekli ekrana birşeyler yazacak hem de bir yandan ben klavyeden hangi metni girersem onu alıp aynen ekrana basacak. Yani iki iş parçacığından oluşuyor. Eğer multi-threaded bir yapı kullanmazsanız böyle bir uygulamayı gerçek anlamda oluşturamazsınız. Yapılacak işler birbiri ile çakışır, senkron değil de birbirini beklemek zorunda kalan iş parçacıkları oluşur.

Multi-Threaded Example-1  |  Gizle  |  Göster
package multithreaded.sample1;

/**
 *
 * @author Cem Kefeli
 */
public class MultiThreadedEx1 {
    public static void main(String[] args) {
        Thread_Read threadRead=new Thread_Read();
        Thread_Write threadWrite=new Thread_Write();
        threadRead.start();
        threadWrite.start();
    }
}
package multithreaded.sample1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 *
 * @author Cem Kefeli
 */
public class Thread_Read extends Thread {
    @Override
    public void run() {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String text="";
        
        while(true) {
            try {
                text = bufferedReader.readLine();
            } 
            catch (IOException Exc) {
                System.out.println(Exc);
            }
            System.out.println("Echo: "+text);
        }
    }
}
package multithreaded.sample1;

/**
 *
 * @author Cem Kefeli
 */
public class Thread_Write extends Thread {
    String text = "Thread example-1";
    
    @Override
    public void run() {
        while(true) {
            try {
                System.out.println(text);
                Thread.sleep(5000);
            } 
            catch (InterruptedException Exc) {
                System.out.println(Exc);
            }
        }
    }
}

Thread example-1
test
Echo: test
Thread example-1
deneme
Echo: deneme
Thread example-1
Thread example-1

Yukarıdaki örnek çok basit bir örnek, fakat görülüyor ki farklı işleri aynı anda yapabiliyoruz artık. Bu mantıkla yalnızca iki adet değil onlarca işi senkron bir şekilde yürütebiliriz. Bir işe başlamak için bir diğer işin bitmesini beklemek zorunda da değiliz böylece.

Yazının başında "Ne kadar senkron?" sorusunu park etmiştik hatırlarsanız, şimdi oraya geri dönelim. Elinizde 1 işçinin 3 saatte bitirebileceği bir iş ve 1 işçinin 5 saatte bitirebileceği ikinci bir iş var. Soru şu; eğer multi-threaded bir yapı kullanırsanız bu iki iş ne kadar zamanda biter, kullanmazsanız ne kadar zamanda biter? Bu arada yeri gelmişken de söylemek lazım Java'da her uygulama en az bir thread'den oluşur ki onun adı da main thread'dir. Yani thread'siz uygulama diye birşey yoktur, "single-thread" ve "multi-thread" kavramları vardır.

İkinci sorunun cevabı daha kolay. Bu iki işin toplam süresi yaklaşık 8 saat sürer diyebiliriz. Yani (toplam süre~=8 saat) denkliği bize gereken cevabı verir.

Ama birinci sorunun cevabı o kadar net değil. Şöyle düşünebiliriz; Bu işler eş zamanlı yapıldığına göre ikisine aynı anda başlasak ilki 3 saat sonra biter, birinci işçi boşa çıkar. İkinci iş ise 5 saatte biter ikinci işçi boşa çıkar. Toplamda da yaklaşık 5 saatte her iki iş de bitmiş olur. Bu söylem göreceli olarak doğru bir mantığa dayanıyor fakat programlama dünyasında eğer her işi bir CPU çekirdeğine yaptırabiliyorsanız geçerli. Eğer bizim tüm işlerimizi aynı CPU çekirdeği yapıyorsa geçersiz. Çünkü ortada toplam belirli miktarda iş var ve bu iş için harcanacak enerji var. Olmayan bir enerjiyi işe dönüştüremeyiz. Dolayısıyla ilk sorunun cevabı (5 saat<toplam süre<8 saat) şeklinde karşımıza çıkar. Örneğin 6 saat olabilir ama asla ve asla 5 saat olamayacaktır. Örneğin 5 saat 1 saniye olabilir ama asla ve asla 5 saat olmayacaktır!

Threadless vs. Multi ThreadingBu durumu daha net ortaya koyabilmek için yüklü matematiksel hesaplamalar yapan bir method (iş) yazdım. Bu işten CPU'ya 1 den başlayarak 50 defaya kadar yaptırdım, her bir iş sayısı için toplam işin ne kadar sürdüğünü hesaplattım. Grafikteki yatay eksen işten kaç defa yapıldığını adet cinsinden gösteriyor. Kırmızı bölüm multi-threaded yapı olmadan, yani aslında single-threaded, toplam işin 1 ile 50 arasında değişen sayısı için milisaniye cinsinden ne kadar sürdüğünü gösteriyor. Burada bizi şaşırtan bir durum yok. İşler peşpeşe yapılıyor ve bir iş yaklaşık 1,450 milisaniye (ms) sürüyor 50 defa yapılması da yaklaşık 72,750 ms sürüyor. Beklenen değer ve gerçekleşen değerler neredeyse birbirinin aynısı. Grafikten de görüleceği gibi kızmızı taralı alan çok belirgin ortaya çıkmıyor.

Fakat multi-threaded yapıda, yani mavi alan, yukarıda bahsettiğim sonuç çok net ortaya çıkıyor. normalde 50 işin aynı anda başlayıp eş zamanlı yapılması sonrasında 50 işin de 1450 ms sonra bitmesi beklenir. Fakat öyle olmuyor, 50 iş senkron bir şekilde toplam 28,500 ms'de bitiyor. Yani aslında her bir iş 28,500 ms saniye sürüyor ve her iş de aynı zamanda bitiyor. İşleri senkron yaptırmamız birim işin süresini uzatıyor. Çünkü her işi bir CPU çekildeğine yaptırmıyoruz, tek bir CPU çekirdeğiyle 50 işi aynı anda yapmaya çalışıyoruz. Grafikten de görüleceği gibi mavi taralı alan çok belirgin bir şekilde ortaya çıkıyor. Peki neden değer arada bir yerde kalıyor? Yani neden single-thread'den yine de az bir süre alıyor işlerin bitmesi. Çünkü multi-threaded yapı kullanarak CPU'nun idle-time değerini azaltıyoruz. Yani CPU'yu daha fazla yüklüyoruz.

Çok çekirdekli CPU'lar biliyorsunuz uzun zamandır kullanımda. Fakat eğer sizin uygulamanız çok çekirdekli bir mimariye uygun bir ortamda çalışmıyorsa çekirdeklerinizin sayısının bir anlamı yok demektir! Buraya çok fazla girmiyorum ama şunu bilmek gerekir ki ve bir başka söylemle çok çekirdekli bir işlemci ancak çok çekirdek üzerinde çalışmaya uygun bir yazılım ortamı ile anlam bulabilir.

Sonuç olarak; bu yazıda işin mantığını anlatmaya çalıştım, bir sonraki yazımda ise multi-threaed yapıların biraz daha detayına inmeyi bekliyorum. Faydalı olması dileğiyle...

Tüm java makalelerime buradan ulaşabilirsiniz...

JAVA - Nested (Gömülü), Inner (Dahili), Local (Lokal) ve Anonymous (İsimsiz) sınıflar

by Cem Kefeli 1. Kasım 2012 13:35

Tüm java makalelerime buradan ulaşabilirsiniz...Java

Java'da her şey sınıflardan oluşuyor demiştim.Sınıf tanımlamak kolay, sınıfların örneklerinden nesneler oluşturmak da kolay. Fakat işin özüne inecek ulursanız bazı trig'ler ile karşılaşmaya başlayacaksınız. Bu yazının başlığında geçen sınıf türleri de işte bu tirg'lere birer örnek. Olmasalar ne olurdu? Çok net bir şekilde, İsimsiz Sınıflar hariç hiç bir şey olmazdı diyebilirim aslında. Dedim ya birkaç trig. Dilin esnekliği ve sunduğu olanaklar ile ilgili tamamen. Zaten bu kavramlar Java'ya özgü birşey de değiller. OOP dilleri için genel bir konsepttir. Türkçe'ye çevrilmiş halleri ise bana hep oldukça karışık gelir, ama yazı boyunca aşağıdaki anlamları ifade ettiğini bilerek okuyunuz lütfen, her ne kadar ben hep Türkçe isimleri kullanacak olsam da;

Nested Classes <--> Gömülü (İç içe geçmiş) sınıflar
Inner Classes <--> Dahili sınıflar

"Peki işe yararlar?" sorusuna gelirsek, Gömülü Sınıflar benzer görevi yapan sınfları daha okunaklı ve anlamlı bir şekilde kullanılabilir hale getirmek için uygundurlar mesela. 'Biz bu işi zaten paketler (packages) ile yapmıyor muyduk?' derseniz hiç bir şey diyemem, çünkü aynen öyle. Dahili Sınıf dediğimiz ise Gömülü Sınıfın bir türüdür. Statik olarak tanımlanmayan Gömülü Sınıfa, Dahili Sınıf denir. Statik olarak tanımlanan Gömülü Sınıflara ise Statik Gömülü Sınıflar denir. Yani aslında Gömülü Sınıf dedigimiz şey yalnızca özel bir isimlendirmedir. Çorba oldu değil mi? Yok yok çok karışık degil, örnek yapalim...

Nested Classes example  |  Gizle  |  Göster
class HerhangiBirSinif {
    ...
    class GomuluSinif {
        ...
    }
}
class HerhangiBirSinif {
    class DahiliSinif {
        void Yaziyaz(){
            System.out.println("HerhangiBirSinif.DahiliSinif");
        }
    }
    static class StatikGomuluSinif {
        void Yaziyaz(){
            System.out.println("HerhangiBirSinif.StatikGomuluSinif");
        }        
    }
}

Fakat her kadar 'Dahili Sınıf ve Statik Gömülü Sınıf aslında Gömülü Sınıfların türleridir.' desek de bu türlerden oluşturulan nesne örneklerinin oluşturulma şekillleri farklıdır. Statik Gömülü Sınıflardan nesne örneği oluştururken önce kendilerini çevreleyen sınıfların nesne örneği oluşturulmaz (Satır-3). Fakat Dahili sınıfların nesne örneklerini oluştururken mutlaka ve mutlaka ilk önce kendilerini çevreleyen nesnelerin birer nesne örneğinin oluşturulması gereklidir (Satır-6). Fazlası...

Hakkımda...

Cem KEFELİ

Electronics and
Telecommunication Eng.
devamı...


Son yapılan yorumlar...

Comment RSS

Yasal bir uyarı...

Disclaimer"Bu web sitesinde görmüş olduğunuz bilgilerin, dokümanların ve diğer materyallerin kullanılmasından doğabilecek hiç bir sorumluluktan site sahibi sorumlu tutulamaz. Web sitesi içerisinde yer alan yazılar, yorumlar, resimler ve diğer tüm içerikler yalnızca sahibinin görüşünü yansıtmakta olup içeriğin sahibi kişilerin çalıştığı kurumları bağlayıcı hiç bir nitelik taşımamaktadır. Yapılan tüm alıntılar mutlaka kaynak gösterilerek verilmeye çalışılmaktadır. Web sitesi içerisinde bulunan ilgili materyaller, ilgili yasal kurumlar tarafından uygun görülmemesi durumda kaldırılacaktır."
General