JEE, Android, Seam ve Dahası

Tab oluşturmak bir ekrandan diğerine geçerken kullanıcıya oldukça hoş bir görüntü sunar. Android de bunu yapabilmek için ise Tabhost ve Tabspec nesneleri kullanılır. Tab içindeki her bir ekranı Tabspec nesnesi tutar. Tabhost ise bunları bir arada tutan nesnedir. Şimdi aşağıdaki örnekde 2 sayfalık bir tab ekranı oluşturacağım. İlk başta aşağıdaki layout xml içinde bizim tab penceremiz olucak ve tüm tab ekranları bunun içine yerleşecek.

<?xml version="1.0" encoding="utf-8"?>
<TabHost xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@android:id/tabhost"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent" >

    <RelativeLayout
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" >

        <FrameLayout
            android:id="@android:id/tabcontent"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:layout_above="@android:id/tabs"
            android:layout_alignParentTop="true" />

        <TabWidget
            android:id="@android:id/tabs"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_alignParentBottom="true" />
    </RelativeLayout>

</TabHost>

Şimdi Activity nesnemizi aşadaki gibi ayarlayalım. Yanlız yukarıdaki xml i kullanacak olan activity için extend olarak TabActivity alıcaz.

public class MainTabActivity extends TabActivity {

	private TabHost tabHost;
	private TabSpec groups;
	private TabSpec friends;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.maintab);

		tabHost=(TabHost) findViewById(android.R.id.tabhost);

		initalizeTabs();

		createTabs();

		addTabs();

	}

	//tab specler oluşturuluyor
	private void initalizeTabs() {
		groups = tabHost.newTabSpec("Groups");
		friends=tabHost.newTabSpec("Friends");
	}

	//tabların etiketi ve hangi activity çağıracağı ayarlanıyor
	private void createTabs() {
		groups.setIndicator("Groups").setContent(new Intent(this,GroupsActivity.class));
		friends.setIndicator("Friends").setContent(new Intent(this,FriendsActivity.class));
	}

	//tabspecler tabhostlara aktarılıyor
	private void addTabs() {
		tabHost.addTab(groups);
		tabHost.addTab(friends);

		//ilk hangi tabın açılağı ayarlanıyor
		tabHost.setCurrentTab(0);

	}

}

Şimdi projemizi çalıştırıp sonuca bakalım.

Android kurulumuna başlamadan önce bilgisayarınızda aşağıdaki araçların kurulu olması gerekir.

1. Java Development Kit (JDK) : Öncelikle bilgisayarınıza bunu indirip kurmanız gerekme. Alt tarafdaki kısımdan işletim sisteminize uygun olanı indiriniz.

2. Eclipse Kurulumu : Eğer bilgisayarınızda mevcut değil ise eclipse idelerinden birini yükleyiniz. Benim kişisel tercihim helios sürümüdür. Ama diğerlerinden birini de seçebilirsiniz.

3. Android SDK Kurulumu : Şimdi sırada bilgisarınıza android sdk kurulumunu yapmanız gerekmekte. Buradan kendi sisteminize uygun olanı seçip indiriniz.

4.Developer Tools Yüklemesi :  Eclipse idenizde Help>>Install New Software kısmına https://dl-ssl.google.com/android/eclipse bu adresi yapıştırarak yapılan arama sonucunda  ekranınıza gelen Developer Tools paketini yükleyin. Yükleme bittikten sonra eclipse idesini yeniden başlatın.

5.Android Librarylerini Yükleme : Eclipse yeniden başladıktan sonra Window>>AVD Manager kısmını açın ve istediğiniz android sürümlerini seçip install butonuna tıklayınız. Bu işlem seçtiniz sürüm sayısına göre uzun sürebilir.

Bütün işlemler bittikten sonra artık Android sistemler için projeler geliştirmeye başlayabilirsiniz. Kolay gelsin:)

Bu uyarı ant’ın 1.8 sürümünde gözükmektedir. Uyarının sebebi build.xml dosyasından kaynaklanmaktadır. Sorunu çözmeniz için sadece aşağıdaki attiribute’ü javac tagına ekleyin;

<javac includeantruntime="false" ...>

gibi yaptığınızda uyarı kaybolacaktır.

JEE eski adıyla J2EE anılan Java’nın Enterprise Edition versiyonu bu adı Java 1.6′dan sonra almıştır. Adı içerisinde geçen 2 kalkmış JEE olmuştur. Aynı şekilde J2SE’te Java SE olmuştur. JEE , Java SE’den farklı olarak bir çok kütüphaneye (api) sahiptir. Server taraflı programlama olarak geçmektedir. Genelde web uygulamaları için kullanılmaktadır. JEE ile yazılan bir uygulamanın şemasını görelim;

Java Enterprise Edition (JEE)

Java EE 6 Api Listesi

Kaynaklar

http://en.wikipedia.org/wiki/Java_EE

http://download.oracle.com/javaee/6/api/overview-summary.html

Aom, runtime esnasında yapıda değişiklik yapılmasına izin veren,  bir çok tasarım deseninden meydana gelen bir modeldir. Kullanım amacını şu örnek ile daha iyi anlayacağınızı umuyorum;

Bir proje üretmeniz gerekiyor ve projede ki bilgileri tutmak için bir veritabanına ihtiyacınız oluyor. Örneğin personel tablosuna ihtiyacınız oldu. Bu tabloda id, name, tckimlikno, birthdate gibi alanların olduğunu varsayalım. Fakat zamanla gelen talepler doğrultusunda personele daha fazla özellik eklemeniz isteniyor. Örneğin kızlık soyadı daha sonra askerlik durumu, kan grubu gibi alanları eklemeniz istendi. Kızlık soyadı sadece bayanlar için gerekliyken askerlikte sadece erkekler için geçerli. Bu alanları tabloya eklediğinizde zamanla veritabanınız şişecek ve zamanla tablolardaki alan adediniz artıcak. Aynı zamanda bayanlarda askerlik gibi alanlar, baylarda da kızlık soyadı gibi alanlar boş kalacak. Bu tamamen kötü bir tasarım örneğidir.

Aom burada devreye girip daha yapısal bir tasarım sunar. Aom der ki; properties(alanlarınız) ayrı bir tablo olmalı, kişileriniz ayrı bir tablo ve bunları birleştirende ayrı bir tablo olmalı. Eski tasarıma alternatif olarak resimdekini inceleyelim;

Adaptive Object Model

Resimde görülen tasarım çok basit bir olmasına karşın Aom’i anlamanız açısından önemlidir.

Adaptive Object Model temelde 4 tasarım deseninden oluşur;

• TypeObject Pattern
• Property Pattern
• Strategy Pattern
• RuleObject Pattern

TypeObject Pattern

Nesne tabanlı dillerde hep bir çok sınıf tanımlanır. Birbirlerine kalıtım verilir polimorfizm uygulanır vs. Bu şekilde tasarlanan sistemlerde proje büyüdükçe tanımlanan sınıf sayısı artmaktadır. Bir süre sonra içinden çıkılamaz hal alacaktır. TypeObject deseni bu soruna bir nevi çare olmaktadır. Resimdeki örnekle devam edelim;

Adaptive Object Model

Resimde görüldüğü gibi TypeObject uygulanmadan önce Car sınıfımızdan Caravan, Explorer, Ferrari gibi sınıflar türemekte. Bu yöntemle sayısız sınıf eklenmekte modelimiz karışık hale gelmektedir. Daha sonrasında ise TypeObject uygulandığını görüyoruz. TypeObject Entity ile EntityType’ı birbirinden ayırır ve birbirinden olabildiğince bağımsız olmasını sağlamaktadır. Bu sayede gerek veritabanındaki tablo sayımız gerekse uygulama tarafındaki sınıf sayımız büyük ölçüde azalacaktır. Nesneler, TypeObject sayesinde generic şekilde runtime esnasında oluşturulabilir hale gelecektir.

Property Pattern

Entity’lerin özellikleri (attiributes) genelde direk sınıf içerisinde belirtilir. Fakat Property Pattern der ki, entity’ler ve özellikleri birbirinden ayrılmalıdır. Resimde görelim;

Adaptive Object Model

Görüldüğü gibi bu şekilde tanımlandığında birden fazla entity’nin bir property’i kullanmasına izin vermiş oluyoruz.

Bu yapıda TypeObject iki kere uygulanır. Birincisinde Entity ve EntityObject’i ayırırken, ikincisinde ise Property ve PropertyType’ı ayırırken kullanılır. Property’ler de kendi arasında TypeObject uygular. Çünkü her property’nin bir type’ı vardır. Böylelikle her Entity kendi Property’sini kullanabilir. Resimde TypeSquare dediğimiz yapı gösterilmektedir.

Adaptive Object Model

Resimdeki yapı TypeObject ve Property’nin nasıl uygulanması gerektiğini gösterir. TypeSquare ben buna muhteşem dörtlü diyorum J Her bir Entity’nin türü ve o türe ait property’leri var. Farklı türdeki objeler farklı türde ilişkilere ve davranışlara sahip olabilirler. Örneğin bazı kayıtların veritabanına eklenmeden önce kontrol edilmesi yada düzenlenmesi gerekebilir. Bu gibi durumlarda Property Pattern yeterli gelmeyecektir.  Bu durumda AOM’un bir şekilde ilişkileri tanımlaması ve değiştirmesi gerekmektedir.

Entity-RelationShip

Adaptive Object Model’de ilişkileri belirlemenin 3 yolu vardır;

1)      İlişkilerden attiribute’leri ayırarak. Bunu da Property Pattern’i iki kere uygulayacak yapabiliriz. Birincisi Attiributes (özellikler) için, ikincisi ise Associations(İlişkiler) için.

İkinci yolu ise Property için Attiributes ve Associations adında iki adet alt sınıf oluşturmak. Resimde inceleyebilirsiniz;

Adaptive Object Model

1)      Attiribute’lerden Association’ları ayırmanın son yolu ise Property’lerin değerleridir. Value adında alt sınıfları kalıcı değişmeyen bir sınıfımız olduğunu düşünelim. Property’nin tipik olarak int, String, Long gibi türlerde değişkenleri olacaktır. Eğer Property’nin Entity türünde bir değişkeni varsa işte bu değişken ilişkiyi temsil edecektir.

Strategy Pattern ve RuleObject Pattern

Nesne tabanlı programlamada iş kuralları çeşitli şekillerde tanımlanabilir. Bazı kurallar entity’lere tanımlanırken bazıları attiribute’lere tanımlanır. Bazı kurallar da entity’ler arasındaki ilişkilere tanımlanır. Fakat bazı kurallarla karşılaşırız ki normal şekilde tanımlayamıyoruz.

Örneğin öyle bir kurala ihtiyacımız oluyor ki belirlenen entity’nin sadece belirlenen türde attiribute’leri olacak. Ya da bazı kurallar oluyor ki eğer entity’ler belirli değerlere sahipse ve belirli entity’ler arasındaki kısıtlamalar varsa diğer entity’ler arasındaki ilişkileri belirliyor. Biliyorum biraz karışık oldu ama birazdan resimde daha iyi anlaşılacaktır J

Bu iş modelleri zamanla çok karışık hale gelebiliyor. Bu durumda AOM Strategy ve RuleObject desenlerini kullanır. Strategy tasarım deseni standart bir interface tanımlayıp alt sınıfların onunla çalışmasını sağlar. Eğer Objenin davranışı bir yada daha fazla strategy ile tanımlanmışsa bu davranışın değiştirilmesi çok daha kolaylaşır. Bu bize tasarımda esneklik sağlar. Kodu ufak değişikliklerle istediğimiz hale sokabiliriz ya da yeni bir kural tanımlamak istediğimizde yapıya hiç müdahale etmeden tanımlayabiliriz. RuleObject tasarım deseni de bununla aynıdır. Tek farkı ise çok karışık hale gelmiş kurallar RuleObject ile ifade edilir. Strategy’lerin bir araya gelmesinden oluşmaktadır. Şimdide Strategy’nin resmini inceleyelim;

Adaptive Object Model

Solda gördüğünüz TypeObject ve Property desenleri sağ tarafta ise Composite tasarım deseniyle entegre edilmiş Strategy ve RuleObject desenleri.

Umarım başlangıç için faydalı bir yazı olmuştur.

Konu ile ilgili daha fazla detay alttaki linkten bulabilirsiniz.

Kaynaklar : http://adaptiveobjectmodel.com/writings/

Junit java için yapılmış bir test framework üdür. Bizim yazdığımız kodların doğru çalışıp çalışmadığını kontrol eder. Test Driven Programming () için büyük önem taşır. Test Driven Programming basitce kodlarımızı yazmadan önce test classlarını yazmak olarak tanımlayabiliriz.

Şimdi basit bir uygulama yapalım.  Javada 2 sayıyı bölmek için bir uygulama yapalım. Şimdi yeni bir java projesi oluşturalım ve projemize Test isimli yeni bir source folder oluşturalım.

Şimdi test klasörüne sağ tıklayıp aşağıdaki gibi yeni bir JunitTestCase hazırlayalım.

JUnit Test Case

Yukarıdaki pencereye Next dedikten sonra aşağıdaki pencere gelecektir. Burada bazı seçenekler var bunları açıklamak gerekirse

setUpBeforeClass() : Bu method  Test classımız  çalıştığı zaman ilk çalışacak method tur.

tearDownAfterClass() : Bu method Test classımız çalıştığı zaman en son çalışacak method tur.

setUp(): setUp ise yazdığımız her Test methodu için test metodu çalışmadan önce bir kere çalışır

tearDown():  son olarak tearDown ise her Test methodu çalışmasını bitirdiği zaman bir kere çalışır

JUnit Class Oluşturma

Yukarıdaki pencere finish dedikten sonra aşağıdaki JUnit kütüpanesini de projeye ekleyiniz.

	public class CalculatorTest{

		@Test  //her test metodu için @Test annotationu oluşturulmalıdır
		public void checkDividerTest(){
		//test methodları public tanımlamalıdır.

		}
	}

public class myCalculator{

		public static Integer divide(int number,int divisor){
		return 0;
	}

}

	public static Integer divide(int number, int divisor) {

			return number / divisor;			

	}

Yukarıdaki değiştirdikten sonra Test classındaki ifademizi Assert.assertTrue(5==myCalculator.divide(10, 2)); şeklinde değiştirelim ve run a basalım. Bu sefer daha önceki kırmızı olan bar şimdi yeşil yanacak. Çünkü sonucumuz doğru. Ama şimdi bu methoda bakınca bazı eksikler olduğu göze çarpıyor. Mesela ondalık sayılar işlemde olmaması gibi şimdi bunu da divide methoduna ekleyelim ve methoduzumu şu şekilde değiştirelim.

	public static Double divide(double number, double divisor) {

			return number / divisor;

	}

Artık herşey tamam gibi gözüküyor o zaman test methodumuz içine bu fonksiyonu test etmek başka assert ifadeleri de ekleyelim.

		@Test  //her test metodu için @Test annotationu oluşturulmalıdır
		public void checkDividerTest(){
			Assert.assertTrue(1==myCalculator.divide(7, 7));
			Assert.assertTrue(2.5==myCalculator.divide(10, 4));
			Assert.assertTrue(0==myCalculator.divide(0, 4));
			Assert.assertTrue(null==myCalculator.divide(5, 0));

		}

Şimdi tekrar run diyelim. Assert ifadelerinin hepsi çalışır fakat son ifade hariç çünkü bir sayı 0 a bölünmez ama biz bu kontrolü yapmayı atladık. Şimdi methodu şu şekilde değiştirelim.

	public static Double divide(double number, double divisor) {
		if (divisor != 0) {
			return number / divisor;
		} else
			return null;
	}

Ve tekrar Junit testimizi çalıştıralım. Gördüğünüz gibi methodumuz tüm ihtimallerden başarıyla geçti. Junitte önemli olan olabilecek tüm ihtimallere göre kodu hazırlamaktır. Bizde bu bölme methodunda bunu yaptık ve artık bu sayede ileride kodlarımızda bir sorun çıktığında düzeltme işlemlerimiz daha hızlı ve kolay olacaktır.

Bu yazımızda jsf’in commandButton bileşenini detaylı bir şekilde göreceğiz. commandButton bileşeni html’deki <input type=”submit”/> ile temelde aynı görevi yapmaktadır. Bundan farklı olarak bir çok özelliği bulunmaktadır.

Kullanım şekli

<h:commandButton value="Tıkla" action=""/>

Temelde böyle kullanılmaktadır. Fakat kullanırken bir çok etiketine ihtiyaç duymaktayız. Yukarıdaki action özelliği sayesinde butona görevler atayarak, tıklandığı anda belirli işler yapmasını sağlarız.

Butona action vermek için ManagedBean’leri kullanılır. ManagedBean ne olduğu ve nasıl kullanıldığı kısmına bir önceki makaleden ulaşabilirsiniz.

Basit bir sayaç örneği yaparak hem commandButton’ı görelim hem de managedBean’i uygulayalım. Yeni bir jsf projesi oluşturun. index.xhtml adında bir sayfamız olsun ve içeriği şöyle olacaktır;

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:h="http://java.sun.com/jsf/html">
<h:head>
	<title>Javai.Net commandButton Örneği</title>
</h:head>
<body>
	<h:form id="form1">
		<h:outputText id="sayacText" value="Sayaç :" />
		<h:outputText id="sayacResult" value="#{managedBeanTest.counter}" />
		<h:commandButton id="sayacButton" value="Sayacı Arttır"	action="#{managedBeanTest.sayaciArttir}" />
	</h:form>
</body>
</html>

Sonra bir adet Java sınıfı oluşturalım, içeriğide şu şekildedir;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

@ManagedBean(name = "managedBeanTest")
@SessionScoped
public class ManagedBeanTest {

	private int sayac = 0;

	public void sayaciArttir() {
		sayac++;
	}

	public int getCounter() {
		return sayac;
	}

	public void setCounter(int counter) {
		this.sayac = counter;
	}
}

Projemizi derleyip çalıştırdığımızda ekran görüntüsü şöyle olacaktır;

Jsf commandButton Etiketi

Butona her tıklayışımızda sayaç değerinin arttığını göreceksiniz. Şimdi kodu inceleyelim;

Oluşturmuş olduğumuz managedBean içerisindeki sayac değişkenini jsf sayfasında outputText’imize bind ediyoruz. Böylece ondaki değeri direkt olarak göstermesini sağlıyoruz. sayacArttir() metodu her butona tıklandığında tetikleniyor. Böylece sayac değerini arttırmış oluyoruz. ManagedBean’in scope’u session olduğundan dolayı sayfa yenilendiğinde değer gitmiyor. Session boyunca o değer tutuluyor. Jsf sayfasında dikkat ettiyseniz iş yapacak kodumuzu <h:form> </h:form> tagları arasına koyduk. Bu sayede server’a gidip gelmesini sağlıyoruz. Eğer sayfamız server’la çalışacaksa, veri yollayacaksak mutlaka <h:form> etiketi olmalıdır.

Not : Her bileşenimize id vermeye özen gösterelim. Bizim için daha iyi olacaktır.

commandButton’ın diğer özellikleriyle devam edelim;

action : Action ve ActionListener arasındaki farkı bir makale de anlatacağız. Action özelliği sayesinde butona görev atayabiliyoruz. Bu aslında bir değer tutar ve ona göre yönlendirme yapar.
actionListener : ActionListener özelliğinde ise managedBean’e parametre gönderebiliyoruz.
rendered : true ve false değerleri alacak bileşenin render edilip edilmeyeceğini yani tarayıcıya yüklenip ekrana gösterilip gösterilmeyeceğini belirler. Güzel ve çok fazla kullanılan bir özelliktir.
value : Butonun üzerindeki yazıdır. Bunu istediğimiz gibi düzenleyebiliriz. Eğer istersek managedBean’den gelmesini sağlayabiliriz.
accesskey : Bir tuş atanarak kısayoldan bileşene erişilmesini sağlar. Bir örnekle daha iyi anlayalım;

<h:commandButton value="" accesskey="A" id="buton1"/>
<h:commandButton value="" accesskey="B" id="buton2"/>

gibi 2 adet bileşenimiz olsun. Sayfa açıkken klavyeden ALT+A tuşuna bastığımızda buton1 isimli butona focus olacağız. ALT+B kısayolunu uyguladığımızda buton2 alanı aktif olacaktır.
alt : Bu özellik ise tarayıcı commandButton’ı gösteremediği zaman commandButton yerine alternatif gelecek yazıyı gösterir.
dir : Yazının yönünü belirler. LTR ve RTL değerlerini alır.
disabled : true ve false değerleri alarak bileşenin aktif yada kapalı olmasını sağlar. rendered özelliğinden farklı olarak bileşeni ekranda gösterir.
image :  Butona resim vermek için kullanılır.
id : Eşsiz bir isim verilmesi gerekir. Bu isim içinde bulunduğu form’da ona ulaşılmasını sağlar. Eğer id verilmezse jsf otomatik olarak bir id üretecektir.
lang : Yazılacak yazının dil seçeneğini belirtmek için kullanılır.
onblur : Verilen javascript kodunu focus özelliğini kaybettikten sonra çalıştırır.
onclick : Verilen javascript kodunu bileşene tıkladıktan sonra çalıştırır.
ondblclick : Verilen javascript kodunu bileşene çift tıkladıktan sonra çalıştırır.
onfocus : Verilen javascript kodunu bileşene focus’lanıldığında çalıştırır.
onkeydown : Verilen javascript kodunu bileşendeyken herhangi bir tuşa basılırken çalıştırır.
onkeypress : Verilen javascript kodunu bileşendeyken herhangi bir tuşa basıldığında çalıştırır.
onkeyup : Verilen javascript kodunu bileşendeyken tuşa basım işlemi gittikten sonra çalıştırır.
onmousedown : Verilen javascript kodunu mouse bileşenin altına geçtikten sonra çalıştırır.
onmouseout : Verilen javascript kodunu mouse bileşenin üzerinden ayrıldıktan sonra çalıştırır.
onmouseover : Verilen javascript kodunu mouse bileşenin üstüne geldiğinde çalıştırır.
onmouseup : Verilen javascript kodunu mouse bileşenin üstüne çıktıktan sonra çalıştırır.
onselect : Verilen javascript kodunu bileşendeki herhangi bir yazı seçildiğinde çalıştırır.
style : İstersek css kodu yazarak butonu şekillendirebiliriz.
styleClass : Css sınıf ismi alarak daha önce oluşturulmuş bit css sınıfının özelliklerini yazımıza uygular.
tabindex : Tab tuşu yardımıyla bileşenler arasında dolaşırken bu index yardımıyla bileşenlere öncelik veririz. index’i küçük olan daima önceliğe sahiptir. Daha önce focus alır.
title : Bu özellik sayesinde yazımızın üzerine geldiğimizde ufak bir bilgi baloncuğu çıkar. Bunun diğer adı tooltip’tir. title=”yazımızın açıklaması” olarak şekilde yazmalıyız.
type : Butonun submit mi yoksa reset buton mu olacağına karar verir. submit ve reset değerlerini alır.
binding : ManagedBean tarafında  kendi sınıfı ile bağlamamızı sağlar.

Eşsiz bir isim verilmesi gerekir. Bu isim içinde bulunduğu form’da ona ulaşılmasını sağlar. Eğer id verilmezse jsf otomatik olarak bir id üretecektir.

Merhabalar, geçen gün arkadaşımla iki değişkenin içeriğini 3. bir değişken kullanmadan nasıl değiştirebileceğimizi düşünmüştük. Bizden önce bu defalarca tartışılmış hatta algoritması geliştirilmiş. Bende bunu sizinle paylaşmak istedim. Normal şartlarda 3. bir değişken ( temp değişken ) kullanmadan bunu yapmak imkasız. Aslında 2 yöntemle yapılabiliniyor.

1. Yöntem +, -, *, / operatörlerini kullanarak 4 işlem yaparak,

2. Yöntem ise bitwise operatörü olan XOR’u kullanarak yapmak.

Biz ikinci yöntemi göreceğiz. Örnek kodu inceleyerek devam edelim;

public class Main {

	public static void main(String[] args) {

		int x = 5;
		int y = 4;

		System.out.println("Yer değiştirmeden önce x : " + x);
		System.out.println("Yer değiştirmeden önce y : " + y);

		x ^= y;
		y ^= x;
		x ^= y;

		System.out.println("Yer değiştirdikten sonra x : " + x);
		System.out.println("Yer değiştirdikten sonra y : " + y);
	}
}

Bu kodu çalıştırdığımızda konsol çıktısı şu şekilde olaraktır;

Yer değiştirmeden önce x : 5
Yer değiştirmeden önce y : 4
Yer değiştirdikten sonra x : 4
Yer değiştirdikten sonra y : 5

Java’da Xor operatörü ^ olarak kullanılmaktadır. Bit bazında işlem yapmaktadır. Adım adım başka bir örnekte görmek gerekirse;

Java XOR Swap Algoritması

Resimde de görüldüğü gibi karşılıklı bitler aynı olduğunda değer 0 oluyor. Farklı olduğunda 1 oluyor. Programcı arkadaşlar bunun nedenini daha iyi kavrayacaklardır Bu yöntemin adı XOR Swap algoritmasıdır.

Merhabalar, bu yazımızda managed bean kavramından söz edeceğiz. Managed Bean kelime olarak yönetilmiş fasülye anlamına gelmektedir. Jsp kullanan arkadaşlar bu yapıyı daha önce zaten kullandıklarından zorluk çekmeyeceklerdir. Managed Bean temelde bir java sınıfıdır. Farklı olarak bir pojo, ejb olabilir. İçerisine property’ler (özellikler) yazarak sayfanın burayla konuşmasını sağlayabiliriz.

Managed Bean’lerin yaşam sürelerini scope’lar ile ifade ederiz. Scope dediğimiz kavram bir managed Bean’in ne kadar süre hafızada kalacağını, değerleri ne kadar süre hafızasında tutacağını söyler.

Bir java sınıfının managed bean olduğunu belirtmek için sınıfın başına @ManagedBean özelliğini koyması gerekir.

Managed Bean Scope’ları şunlardır:

ApplicationScoped : Application başlatıldığı andan itibaren bellekten silinmeyen hafızada tutulan scope türüdür. Server yeniden başlatıldığında ya da server kapatıldığında bu scope’a sahip sınıfta bellekten silinir.
NoneScoped :  View istediği zaman 3 kere çağrıldığını ve hafızada asla tutulmadığını biliyorum.
RequestScoped : Sayfaya request yapıldığı zaman kullanılan scope türüdür. Her bir request yapıldığında yeni bir örnek oluşturulur ve sonrasında hafızadan silinir.
SessionScoped : Session boyunca hafızada kalır. Session süresince bellekten istenildiği ulaşılabilir. Kullanıcının oturumu bittiğinde bellekten silinir. Bu session süresini web.xml dosyasından aşağıdaki etiketler ile ayarlayabilirsiniz.

 <session-config>
      <session-timeout>50</session-timeout>
 </session-config>

ViewScoped : Sayfa bazlı scope olarak anlandırılır. Sayfa değişmediği sürece scope hafızada saklanır. Sayfa değiştiğinde scope bellekten silinir.

Ayrıca

@ManagedProperty : Özelliği sayesinde Dependecy Injection kullanabiliriz. Bunu daha ileride detaylı bir şekilde anlatacağız.

Ufak bir örnekle kullanımını daha iyi anlamaya çalışalım.

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

@ManagedBean(name="indexBean")
@SessionScoped
public class IndexBean {

	private int id;
	private String yazi;

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getYazi() {
		return yazi;
	}
	public void setYazi(String yazi) {
		this.yazi = yazi;
	}
}

Yukarıki kodda gördüğünüz gibi sınıfın başında @ManagedBean annotation’ını kullanıyoruz. Bunun sayesinde bunun bir managedbean olduğunu ifade ediyoruz. parantez içindeki (name=”indexBean”) sayesinde managedbean’imize jsf tarafından o isimle erişilmesini sağlıyoruz. Şöyle bir örnek verebiliriz. Bir jsf sayfamız olduğunu farzedelim. Sayfamızda outputText olsun ve kullanımı şöyle olacak;

<h:outputText value=”#{indexBean.yazi}”/> buradaki value kısmında görüldüğü gibi indexBean olarak isimlendirilen managedBean’imizin yazi alanına bu sayede erişebildik. Bir managed bean’in içerisindeki herhangi bir alana ulaşabilmek için. O alan için set ve get metodlarını oluşturmamız gerekmektedir. Bu sayede o alana erişebiliriz. Buna encupsilation denilmektedir.

Java tarafından herhangi bir şeye ulaşabilmek için jsf tarafında şunu yazmalıyız.

#{managedbean.ulasilmakIstenenAlan} ve ${managedbean.ulasilmakIstenenAlan} şeklinde kullanılabilir.

Managed Bean dosyaları @ManagedBean annotation’ı kullanılarak oluşturulduğu gibi Jsf 1.2′de faces-config.xml dosyasına tanımlanarakta oluşturulabilir.  Faces-config.xml dosyasına şu şekilde tanımlıyoruz;

<managed-bean>
		<managed-bean-name>indexBean</managed-bean-name>
		<managed-bean-class>IndexBean</managed-bean-class>
		<managed-bean-scope>session</managed-bean-scope>
	</managed-bean>

<managed-bean-name>..</managed-bean-name> etiketleri arasına jsf sayfalarında kullanacağımız ismi veriyoruz. Sınıfa bu isim sayesinde erişeceğiz.
<managed-bean-class>..</managed-bean-class> etikerleri arasına ManagedBean dosyamızın tam olarak yolunu ve adını veriyoruz.
<managed-bean-scope>..</managed-bean-scope> etikerleri arasına ise managed bean’imizin yaşam süresini belirtiyoruz. request,session,view,none,application değerlerini verebiliriz.

Scope’ları ileride daha detaylı anlatacağız

Bu yazımızda inputText etiketini daha yakından ve detaylı bir şekilde inceleyeceğiz. inputText bileşeni html’deki textbox gibidir. Kullanılışı şu şekildedir;

<h:inputText value=""/>

Bir örnekle açıklamak gerekirse;

<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:h="http://java.sun.com/jsf/html">
<head>
<title>Javai.net outputText Etiketi</title>
</head>
<body>
	<h:inputText value="#{myBean.yazi}" id="text1" title="Javai"/>
</body>
</html>

Kodunu yazdığımızda şuna dikkat etmeliyiz. value kısmında kullandığımız #{myBean.yazi} ifadesi arka tarafta bir managed Bean bulunduğunu ve onun yazi özelliğine burada yazılan yazının atanacağını söylüyor. Bu sayede java sınıflarıyla iletişimi sağlayıp veri yollayabiliyoruz. Fakat bu örneği direk yazıp çalıştırdığınızda öyle bir bean olmadığı için hata verecektir. O alanı boş bırakarak denediğinizde şu çıktıyı alacaksınız.

Jsf inputText Etiketi

Html çıktısı ise şöyle olacaktır;

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Javai.net inputText Etiketi</title>
</head>
<body><input id="text1" type="text" name="text1" value="" title="Javai" />
</body>
</html>

Görüldüğü gibi yazdığımız etiketler çok sade bir şekilde derlenip ekrana sunuluyor. Şuan için temel bileşenleri gördüğümüzden örnek yapmıyoruz. Bir kaç bileşen daha öğrendikten sonra örneklere geçeceğiz

Şimdi de inputText etiketinin özelliklerini görelim

id : Eşsiz bir isim verilmesi gerekir. Bu isim içinde bulunduğu form’da ona ulaşılmasını sağlar. Eğer id verilmezse jsf otomatik olarak bir id üretecektir.
rendered :  true ve false değerleri alacak bileşenin render edilip edilmeyeceğini yani tarayıcıya yüklenip ekrana gösterilip gösterilmeyeceğini belirler. Güzel ve çok fazla kullanılan bir özelliktir.
binding : ManagedBean ile (bunu daha sonra göreceğiz) ui tarafındaki bileşeni bağlamamızı sağlar. Böylece bileşenin özelliklerine java sınıfı içerisinden erişebiliriz.
dir : Yazının yönünü belirler. LTR ve RTL değerlerini alır.
lang : Yazılacak yazının dil seçeneğini belirtmek için kullanılır.
style : Css kodları yazarak yazımızın daha güzel görüntülenmesini sağlar. Kullanışlı bir özelliktir.
accesskey : Bir tuş atanarak kısayoldan bileşene erişilmesini sağlar. Bir örnekle daha iyi anlayalım;

<h:inputText value="" accesskey="A" id="text1"/>
<h:inputText value="" accesskey="B" id="text2"/>

gibi 2 adet bileşenimiz olsun. Sayfa açıkken klavyeden ALT+A tuşuna bastığımızda text1 isimli inputtext’e focus olacağız. ALT+B kısayolunu uyguladığımızda text2 alanı aktif olacaktır.

alt : Bu özellik ise tarayıcı inputText’i gösteremediği zaman inputText yerine alternatif gelecek yazıyı gösterir.
converter : inputText bileşeni için bir adet converter atar.
disabled : true ve false değerleri alarak bileşenin aktif yada kapalı olmasını sağlar. rendered özelliğinden farklı olarak bileşeni ekranda gösterir.
immediate : true ve false değerleri alarak validasyon sırasında bu alanın validasyona tabi olup olmayacağına karar verir. Kullanışlı bir özelliktir.
maxlength : Maksimum karakter uzunluğunu belirtir.
onblur : Verilen javascript kodunu focus özelliğini kaybettikten sonra çalıştırır.
onchange : Verilen javascript kodunu içerisindeki yazı değiştikten sonra çalıştırır.
size : Bileşenin uzunluğunu belirtmek için kullanılır.
title : Bu özellik sayesinde yazımızın üzerine geldiğimizde ufak bir bilgi baloncuğu çıkar. Bunun diğer adı tooltip’tir. title=”yazımızın açıklaması” olarak şekilde yazmalıyız.
styleClass : Css sınıf ismi alarak daha önce oluşturulmuş bit css sınıfının özelliklerini yazımıza uygular.
onclick : Verilen javascript kodunu bileşene tıkladıktan sonra çalıştırır.
ondblclick : Verilen javascript kodunu bileşene çift tıkladıktan sonra çalıştırır.
onmousedown : Verilen javascript kodunu mouse bileşenin altına geçtikten sonra çalıştırır.
onmouseup : Verilen javascript kodunu mouse bileşenin üstüne çıktıktan sonra çalıştırır.
onmouseover : Verilen javascript kodunu mouse bileşenin üstüne geldiğinde çalıştırır.
onmousemove : Verilen javascript kodunu mouse bileşenin üzerinde hareket ettirirken çalıştırır.
onmouseout : Verilen javascript kodunu mouse bileşenin üzerinden ayrıldıktan sonra çalıştırır.
onkeypress : Verilen javascript kodunu bileşendeyken herhangi bir tuşa basıldığında çalıştırır.
onfocus : Verilen javascript kodunu bileşene focus’lanıldığında çalıştırır.
onkeydown : Verilen javascript kodunu bileşendeyken herhangi bir tuşa basılırken çalıştırır.
onkeyup : Verilen javascript kodunu bileşendeyken tuşa basım işlemi gittikten sonra çalıştırır.
onselect : Verilen javascript kodunu bileşendeki herhangi bir yazı seçildiğinde çalıştırır.
readonly : Bileşenin değerini sadece okunabilir yapmak için kullanılır.
required : true ve false değerlerini alır. true değerini aldığında boş bırakılamayacağını söyler. Form sunucuya gitmeden önce validasyonu yapar ve boş bırakıldıysa form gönderilmeden uyarı verir.
tabindex : Tab tuşu yardımıyla bileşenler arasında dolaşırken bu index yardımıyla bileşenlere öncelik veririz. index’i küçük olan daima önceliğe sahiptir. Daha önce focus alır.
validator : Validasyon sınıfını göstermemize yarar.
value : inputText’in değerini managedBean’de saklamamızı sağlar. Bu sayede java dosyalarıyla iletişime geçebiliriz.
valueChangeListener : Bu özellik sayesinde bileşenin değeri değiştiğinde biz herhangi bir metodu tetikleyebiliriz. ManagedBean’e yazılmış herhangi bir valueChangeListener metoduyla yeni yazılan değeri yakalar ve üzerinde istediğimiz işlemi yapabiliriz.

Kaynak :

http://www.roseindia.net/jsf/inputText.shtml