Pazartesi, Mart 11, 2013

Android Emülatör'ünü Hızlandırın

Android için uygulama geliştiren herkes emülatör’ün yavaşlığından şikayet etmiştir.
Henüz bir kaç yıllık bir Intel işlemciniz varsa HAXM(Hardware Accelerated Execution Manager) ile emülatör’ü inanılmaz hızlarda çalıştırmak mümkün olabiliyor.

Ben denedim sonuç mükemmel olunca paylaşmadan edemedim.

Gerekli Malzemeler:

1) Intel Virtualization Technology(VT) destekleyen bir CPU ( Buradan CPU’nuzun VT destekleyip desteklemediğini öğrenmeniz gerekecek. Benim 3 yıllık Core i5’im destekliyor, işlemciniz çok eski değilse sorun olmayacaktır muhtemelen)

2) HAXM Software –> http://software.intel.com/en-us/articles/intel-hardware-accelerated-execution-manager Buradan işletim sisteminize uygun versiyonu indirin.

3) Android SDK tabiki.

Kurulum:

HAXM kurulumu ile işe başlıyoruz. 2.adımda indirdiğimiz dosyayı çalıştırıp kuruyoruz.

Daha sonra SDK Manager’ı açıp Extras kısmından HAXM’i seçiyoruz.



HAXM tüm sistem imajlarında kullanılabilen bir uygulama değil maalesef, eğer sistem imajlarınız arasında yoksa Intel tabanlı bir imaj’da seçiyoruz.



Bu iki paketi “Install packages” seçeneğiyle yükledikten sonra Intel CPU'lu yeni bir virtual device yaratıp HAXM’in keyfini sürmeye başlayabilirsiniz.



* Eğer grafik işlemci gücü gerektirecek (opengl tabanlı özellikle) uygulamalar tasarlıyorsanuz “Use Host GPU” seçeneği ile de ciddi performans artışı sağlayabilirsiniz.

HAXM'in devreye girdiğini emülatör'ü başlattığınızda logları takip ederek görebilirsiniz.



Herkese iyi eğlenceler.

Pazar, Kasım 25, 2012

Sık Kullanılan JSF Tag Kütüphaneleri

JSF 2 ile birlikte hayatımızda standart 6 tane tag kütüphanesi var. Bu kütüphanelerin namespace’leri bazen unutulabiliyor.

Bu yüzden, işe yarabileyeceğini düşünerek, namespaceleri ve prefix’lerini içeren tabloyu paylaşmak istedim.

Kütüphane Prefix Namespace
Core f: http://java.sun.com/jsf/core
HTML h: http://java.sun.com/jsf/html
Facelets ui: http://java.sun.com/jsf/facelets
Composite Components cc: http://java.sun.com/jsf/composite
JSTL Core c: http://java.sun.com/jsp/jstl/core
JSTL Functions fn: http://java.sun.com/jsp/jstl/functions

Pazar, Mayıs 06, 2012

Spring Enabled Web App Template


Hızlı bir başlangıç için Spring entegre edilmiş bir Eclipse Dynamic Web Project.

Proje aşağıdaki Maven bağımlılıklarını içeriyor.

-Spring 3.1 Context
-Slf4j,Log4j
-Servlet API
-JUnit

Proje içerisinde Spring Web Application Context'i ayağa kaldıracak temel konfigürasyonu barındırıyor.

Pazar, Nisan 15, 2012

AndTutorial-2: Bir Android projesinin yapısı, Android uygulamasının yaşam döngüsü, İlk Eclipse projesi.

Android uygulaması geliştirebilmek için Android SDK ve Android Plugin’i eklenmiş bir Eclipse kurulumu ile işe başlıyoruz.

Öncelikle http://developer.android.com/sdk/index.html adresinden Android SDK installer’ını indirip kurmaya başlıyoruz.


SDK installer’dan kurulum yeri belirledikten sonra  en az yukarıdaki seçenekleri işaretleyerek “Install .. packages” seçeneği ile Android SDK kurulumunu tamamlıyoruz. İsterseniz daha sonra kurulum dizininden “SDK Manager” programı ile Android SDK’sını güncelleyebilir yada yeni Android versiyonlarını ekleyebilirsiniz.

Daha sonra işe temiz bir Eclipse (http://developer.android.com/sdk/index.html) kurulumu devam ediyoruz.

Eclipse kurulumunu tamamladıktan sonra Help –> Install New Software menüsünden Android plugin’inin (https://dl-ssl.google.com/android/eclipse/ )  adresini ekleyip, tüm bileşenleri kuruyoruz.


Plugin kurulumu tamamlandıktan sonra Android SDK’sının kurulum path’ini göstermek üzere Window –> Preferences menüsünden Android sekmesini açıp “SDK Location” alanına Android SDK dizinimizin bulunduğu yeri ekliyoruz.


Böylece Android uygulaması geliştirmek için gerekli ortama kavuşmuş olduk.
Şimdi ilk uygulamamızı yapalım. Öncelikle File –> New –> Android Project menüsünden Android projesi wizard’ını açıyoruz.



Projemizi “HelloAndroid” olarak isimlendirdikten sonra SDK versiyonunu seçiyoruz. Güncel versiyon 4.0.3 ile devam edelim.



Sonraki ekranda paket ismini ve uygulamamızın destekleyeceği minimum Android versiyonunu seçerek proje wizard’ını tamamlıyoruz. (CreateActivity checkbox’ını seçmek bizim için temel bir Android activity’si oluşturacak, bunu Java projelerindeki main sınıfı gibi düşünebiliriz)



Proje yapısı:



project.properties : Android Tools tarafından otomatik olarak yaratılır ve projenin hangi Android versiyonu ile build edileceği bilgisini içerir.

proguard*.txt : Yayınlanma öncesi kodların obfustucation’ını sağlayan ve decompile edilmesini bir nebze olsun zorlaştıran proguard aracının konfigürasyonunu içerir.

AndroidManifest.xml : Uygulamanın hangi componentlere ( service, activity, contentprovider vs) sahip olduğu, çalışmak için hangi izinlere ihtiyaç duyduğu ( internet izni, sd card erişim izni vs) ve uygulama ilgili genel bilgileri (versiyon, paket yapısı, minimum android versiyonu vs) içerir.

res : res klasörü imaj ve layoutlar gibi uygulama ile birlikte derlenecek dosyaları içerir.

bin: Uygulamanın derlenmiş halini içerir.

assets: Uygulama dahil edilecek, derleme gerektirmeyen statik dosyaları içerir.

src: Uygulama kaynak kodunu içerir.

gen: Source kodlardan res klasörü altındaki kaynaklara erişimi sağlayan R dosyasını içerir.

Proje’yi Android projesi olarak çalıştırdığımızda emülatör ya da telefonumuzda aşağıdakine benzer bir görüntü olmalı.



Android activity yaşam döngüsü



Bir Android activity’si yaşadığı süre boyunca farklı durumlarda bulunabilir bunlar;

Starting: Uygulamanın çalışmak için tetiklendiği, hafızada hiç bulunmadığı haldir. Bu aşamada uygulamanın çalışması yani running durumuna geçmesi ve gerekli initialization’ı yapabilmek için gerekli methodlar çağrılır.

Running (Active): Activity’inin başladığı ve kullanıcı ile etkileşimde olduğu durumdur.

Paused: Activity’inin görünür olduğu ama kullanıcı etkileşiminin olmadığı durumdur. Örneğin bir dialog yada bildirim sebebiyle uygulama arkaplan’a geçmiş olabilir.

Stopped: Activity’inin artık görünür olmadığı durumdur. Bu durumda activity memory’de tutulmaya devam edilir ve kullanıcı geri döndüğünde hızlı bir şekilde yeniden active duruma geçebilir.

Destroyed: Activity’inin memory’den de kaldırılarak tamamen bitirildiği durumdur. Bu durum kullanıcı tarafından tetiklenebileceği gibi, kaynak yetersizliği sebebiyle Android uygulama yöneticisi tarafından da tetiklenebilir. Bu durumda kullanıcı uygulamaya geri dönmek istediğinde uygulamanın ilk kez açılmasındaki yol takip edilir.

Önceki tutorial: http://emrahkocaman.blogspot.com/2012/04/andtutorial-1-android-nedir-androidi.html
Tutorial index: http://emrahkocaman.blogspot.com/2012/04/android-tutorials.html

Çarşamba, Nisan 11, 2012

AndTutorial-1: Android nedir? Android’i oluşturan parçalar nelerdir?

Android kısaca, cep telefonları, tablet pc’ler, saatler, eğlence sistemleri, navigasyon sistemleri, ev otomasyonları gibi sistemlerin tümünde kullanılabilen Linux tabanlı açık kaynak kodlu ve ücretsiz bir mobil platformdur.

Android’in en büyük artısı yazılımı üzerinde çalıştığı donanımdan tamamen soyutlamasıdır. Bu sayede ucuz, pahalı, herhangi bir marka mobil cihazda çalışabilir.

Evet sunduğu kullanıcı deneyimi tüm cihazlarda aynı değildir ama büyük bir kitlenin “"Akıllı telefon” ile tanışmasını sağladığı ve sağlamaya devam ettiği gerçektir.

Android platformu ile ilgili detaylar için http://www.android.com/about/ adresini ziyaret edebilirsiniz.

Gelelim bizi ilgilendiren kısma yani Android uygulamalarına;
Android uygulamaları temelde 4 kısımdan oluşur.

1) Activity : Activity, bir masaüstü uygulamasındaki pencerenin karşılığı olan, kullanıcı arayüzüne ev sahipliği yapan yapıdır.

2) Content Provider: Android uygulamaları hem güvenlik hem de uygulamaların birbirinden soyutlanabilmesi için doğrudan birbirlerinin verilerine ulaşamazlar. Bir veri birden fazla uygulama tarafından kullanılmak isteniyorsa erişim “Content Provider” yapısı ile sağlanır. Böylece content provider’ın sahibi veriyi paylaşırken hangi veriye nasıl ulaşılacağını belirlemiş olur.

3) Intent : Intent yapısı sistem bazlı bir mesajlaşma altyapısı olarak düşünülebilir. Uygulamalar arası iletişim, sistem bazlı uyarılar (GPS konum değişimi, Çağrı gelişi, SMS gelişi vb) intent’ler üzerinden tüm sisteme duyrulur. Bu duyuruyla ilgilenen uygulamalarda böylece mesajla ilgili aksiyon alabilirler.

4) Service : Activity’ler kullanıcı tarafından doğrudan ya da arka plan’da iken ihtiyaç olması tarafında sistem tarafından kapatılabilirler ve uzun süreli işler yapmak için tasarlanmamışlardır. Örneğin telefonunuzda müzik dinlediğinizi düşünün. Müzik uygulaması müzik çalma işini bir servis yaratıp işi ona delege ederek yapar. Böylece müzik uygulaması arkaplanda olsa dahi müzik çalmaya, kullanıcının input’larına tepki vermeye (Volume +/- tuşlarına cevap verme) devam eder.

Bir çok konuda olduğu gibi bu konu içinde http://developer.android.com/index.html adresini ziyaret etmenizi şiddetle tavsiye ederim.

Bir sonraki yazıda Android uygulamamız üzerinde bir Android projesinin yapısını inceliyor olacağız.

Sonraki Tutorial: http://emrahkocaman.blogspot.com/2012/04/andtutorial-2-bir-android-projesinin.html
Tutorial Index: http://emrahkocaman.blogspot.com/2012/04/android-tutorials.html

Salı, Nisan 10, 2012

Android Tutorials

Bugün’den itibaren sıfırdan başlayıp en ince detaylarına kadar Android platformunu öğreneceğimiz yazı dizimize başlıyoruz.

Bir aksilik olmazsa konular şöyle olacak.

1) Android nedir? Android’i oluşturan parçalar nelerdir?
2) Bir Android projesinin yapısı, Android uygulamasının yaşam döngüsü,  İlk Eclipse projesi.
3) Temel layout kavramları
4) Temel widgetlar
5) Widget containerlar (Linear, Relative, Table layout)
6) Complex widgetlar-1 ve ArrayAdapter kavramı
7) ListView ve performans optimizasyonları
8) Complex widgetlar-2 (Tab, ViewFlipper, ProgressBar, TimePicker)
9) Menü kavramı
10) Webkit tarayıcısının uygulama içine gömülmesi
11) Android bildirimlerine giriş (Toast, Alert, Notifications)
12) Multithreading – Mobil uygulamalar çabuk tepki vermelidir.
13) Preferences – Kullanıcı tercihlerine saygı
14) SQLite – Veritabanı yaratma ve yönetme
15) Networking – Android ve REST mükemmel uyum
16) Intent Filters – Uygulamalar arası iletişim
17) Content Providers 1 – Varolan content provider kullanımı
18) Content Providers 2 – Kendi content provider’ımızı yaratma
19) Android Service yapısı
20) Cihaz konum bilgisine erişim
21) Google Maps entegrasyonu
22) Bonus: Telefon çağrılarına erişim
23) Bonus: SearchManager API kullanımı
24) Bonus: Custom font kullanımı

Pazar, Nisan 01, 2012

JSF 2 Implicit EL Objects

 JSF Expression Language içerisinde sık kullanılan implicit nesne listesi:

Implicit Object Tip Açıklama
applicationScope Map Uygulama seviyesinde tutulan nesneleri içerir. (@ApplicationScoped)
cookie Map Http cookie header’ında bulunan nesneleri içerir
facesContext FacesContext İşlem anındaki FacesContext nesnesi
flash Map Bir sonraki request’e kadar yaşayacak nesnelerin tutulabileceği map.
header Map İlgili request’in tüm header’ları
param Map İlgili request’in URL parametrelerinin saklandığı map
requestScope Map RequestScoped bean’lerin de tutulduğu, request bazlı veri saklamak için kullanılan map
sessionScope Map SessionScoped bean’lerin de tutulduğu, session bazlı veri saklamak için kullanılan map

Örnek kullanım:
JSF EL ile gelen Implicit nesneler’den managed bean’lerle aynı syntax kullanılarak faydalanılabilir.
<h:outputText value=”#{param[‘selectedItem’]}”/>
yada
<h:outputText value=”#{sessionScope[param[‘selectedItem’]]}”/>

Pazar, Ağustos 14, 2011

RESTful Web Servis Client–Android

Geçen haftaki yazımda Jersey kullanarak JSON üreten oldukça basit bir RESTful Web servis hazırlamıştık. Bu hafta bu web servisi kullanacak Android uygulamasını yazacağız.

Kısaca hatırlamak gerekirse geçen haftaki web servisimiz çıktı olarak aşağıdaki sınıfın JSON karşılığını üretiyordu.

RSOutputDTO.java
package com.blogspot.emrahkocaman.restfulws.json;
public class RSOutputDTO {
	
	private String userName;
	private int userAge;
	
	public void setUserName(String userName) {
		this.userName = userName;
	}
	
	public String getUserName() {
		return userName;
	}
	
	public void setUserAge(int userAge) {
		this.userAge = userAge;
	}
	
	public int getUserAge() {
		return userAge;
	}
	
}

Sadece userName ve userAge alanlarına sahip olan sınıfımızın örnek JSON karşılığı ise aşağıdaki satırdan ibaret.


{"userName":"Kamil","userAge":30}


Projemizin tek amacı bu web servisi çağırmak, dönen JSON string’ini parse ederek ekranda göstermekten ibaret olacak.


İşe önce ADT plugin’i kurulmuş bir Eclipse’te Android projesi oluşturarak başlıyoruz.


File –> New –> Android Project menüsüni kullanarak bir Android projesi oluşturuyoruz.





Daha sonra ADT plugin’i yardımı ile web servisten dönen bilgilerin gösterileceği basit bir arayüz hazırlıyoruz.



main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<RelativeLayout android:id="@+id/relativeLayout1" android:layout_height="fill_parent" android:layout_width="fill_parent" android:layout_marginTop="10dip">
<EditText android:layout_toRightOf="@+id/textView1" android:layout_height="wrap_content" android:layout_width="fill_parent" android:id="@+id/txtUserName">
<requestFocus></requestFocus>
</EditText>
<EditText android:layout_height="wrap_content" android:layout_below="@+id/txtUserName" android:layout_width="wrap_content" android:layout_alignLeft="@+id/txtUserName" android:layout_alignRight="@+id/txtUserName" android:id="@+id/txtUserAge"></EditText>
<Button android:text="WS Çağır" android:id="@+id/btnCall" android:layout_height="wrap_content" android:layout_width="wrap_content" android:layout_below="@+id/txtUserAge" android:layout_alignLeft="@+id/txtUserAge" android:layout_alignRight="@+id/txtUserAge"></Button>
<TextView android:text="Kullanıcı Adı" android:paddingRight="10dip" android:layout_height="wrap_content" android:id="@+id/textView1" android:layout_width="wrap_content" android:layout_alignParentLeft="true" android:paddingTop="10dip" android:paddingBottom="10dip"></TextView>
<TextView android:text="Kullanıcı Yaşı" android:layout_height="wrap_content" android:id="@+id/textView2" android:layout_width="wrap_content" android:layout_below="@+id/textView1" android:layout_alignLeft="@+id/textView1" android:layout_alignRight="@+id/textView1" android:paddingTop="10dip"></TextView>
</RelativeLayout>
</LinearLayout>

Arayüzü hazırladığımıza göre web servis çağırmak için hazırız. RESTful web servislerin HTTP protokolü ile (GET, PUT, POST vb…) çalıştığından bahsetmiştik. Yani RESTful bir web servis çağırmak için ihtiyacımız olan tek şey bir http istemcisi ve bu istemciyi Android kendi bünyesinde barındırıyor (org.apache.http.impl.client.DefaultHttpClient) bu sayede 3.parti bir kütüphaneye gerek kalmadan HTTP istekleri yapmamız mümkün.

Bundan sonrasını kod üzerinde anlatarak devam edeyim.

package com.blogspot.emrahkocaman;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONException;
import org.json.JSONObject;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;
public class RestClientActivity extends Activity {
	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
	
super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
	Button btnCallWS = (Button) findViewById(R.id.btnCall);
	btnCallWS.setOnClickListener(new OnClickListener() {
			@Override
	public void onClick(View arg0) {
//HTTP protokolüne ulaşmak için kullanılan sınıf
	 DefaultHttpClient httpclient = new DefaultHttpClient();
	 //Hazırladığımız web srvis GET isteklerine cevap veriyordu
	 HttpGet httpget = new HttpGet(
	 "http://192.168.37.1:8080/restfulwssample/rest/examples/getUserInfo");
	//IP olarak bilgisayarınızın local ip'sini vermeniz gerekiyor. 
//Aksi halde android uygulaması kendi 
	//localhost'una ulaşmaya çalışacaktır.
	HttpResponse response;
	try {
	//İsteği gönder
	  response = httpclient.execute(httpget);
	  StatusLine requestSuccess = response.getStatusLine();
	//İstek başarılı
	if (requestSuccess.getStatusCode() == 200) {
	  HttpEntity entity = response.getEntity();
	  if (entity != null) {
	   InputStream instream = entity.getContent();
	   //Stream olarak dönen cevabı anlaşılır bir hale getirmemiz gerekiyor
String requestResult = convertStreamToString(instream);
try {
	   //Android kendi içerisinde JSON stack'ini barındırıyor.
//Gelen string'i JSON objesine dönüştürüyoruz
	   JSONObject jsonResult = new JSONObject(requestResult);
	   Toast.makeText(RestClientActivity.this, jsonResult.toString(), Toast.LENGTH_LONG).show();
} catch (JSONException e) {
	    Toast.makeText(RestClientActivity.this, "JSON Exception", Toast.LENGTH_SHORT).show();
	   }
instream.close();
	}
	}
	} catch (Exception ex) {
	Log.e("REST_ERR", ex.getMessage());
	Toast.makeText(RestClientActivity.this, "Houston we have a problem", Toast.LENGTH_SHORT).show();
			
	}
	}
});
}
	private static String convertStreamToString(InputStream is) {
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder sb = new StringBuilder();
		String line = null;
		try {
			while ((line = reader.readLine()) != null) {
				sb.append(line + "\n");
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return sb.toString();
	}
}

Uygulamayı çalıştırıp “WS Çağır” butonuna bastığımızda bize ulaşan JSON nesnesini görmeliyiz.



Bize ulaşan JSON nesnesini parse ederek içinde “Kullanıcı Adı” ve “Kullanıcı Yaşı” bilgilerini çıkarmamız gerekiyor. Android içerisinde bulunan JSON stack’i bu işlemi yapmak mümkün.

userName.setText(jsonResult.getString("userName"));
userAge.setText(jsonResult.getString("userAge"));

Örneğimizdeki response’da sadece iki alan olduğu için zorlanmadık ama gerçek hayatta web servisler bu kadar basit değil tabiki. Çok fazla alan içeren JSON nesnelerini bu şekilde parse etmek hem hataya açık hemde çok zahmetli bir hal alacaktır. Bu sebeple JSON nesnelerini bizim içip parse edip istediğimiz nesnelere dönüştürecek kütüphaneler kullanabiliriz. Bu için tavsiyem Jackson ve Gson kütüphaneleri. 

Bunları arasındaki seçim konusunda ise tavsiyem, öncelik hız ise Jackson, öncelik uygulama boyutu ise (mobil uygulamaların boyutları büyük olduğunda fazlaca eleştiriliyorlar) GSON kullanmanız.

Şimdi örneğimize Gson’uda ekleyerek projeyi tamamlayalım.

Öncelik Gson kütüphanesi http://code.google.com/p/google-gson/ adresinden indiriyor ve projemizin classpath’ine ekliyoruz..

Hatırlayacağımız üzere dönen JSON nesnesi server tarafında RSOutputDTO.java sınıfına karşılık geliyor. Aynı sınıfı Android projemizede kopyalarak ilerliyoruz.


Gson sınıfı yardımıyla dönen JSON nesnesini RSOutputDTO nesnesine dönüştürerek örneği tamamlıyoruz.

Gson gson = new GsonBuilder().create();
RSOutputDTO result = gson.fromJson(jsonResult.toString(), RSOutputDTO.class);
userName.setText(result.getUserName());
userAge.setText(Integer.toString(result.getUserAge()));

Herkese kolay gelsin.

Eclipse projesi : http://db.tt/NoHiJ30

Pazar, Ağustos 07, 2011

Hızlı Bir Başlangıç - RESTful Web Servisler (JAX-RS)

Önce biraz teori;
Kısaca REST,  tüm bilgilerin kendilerine has birer adrese yani URI (Uniform Resource Idetifier) ‘ye sahip olmasını öngören mimari yaklaşımdır. (Web üzerindeki linkleri buna örnek olarak verebiliriz).
RESTful Web servisler ise REST mimarisini temel alarak geliştirilen web servislerdir yani SOAP yaklaşımı ile web’den uzaklaşan web servislerin tekrar web ile buluşmasıdır. RESTful tasarlanan web servisler web üzerindeki linklere dönüşmüşlerdir ve client ile server arasındaki iletişim stateless bir iletişim protokolü (genellikle HTTP) üzerinden sağlanır.
RESTful Web servislerin Java dünyasındaki standartları JAX-RS spesifikasyonu ile çizilmiştir.
Bu kadar teoriden sonra RESTful Web servislerin nasıl çalıştığını bir örnek üzerinden inceleyelim.
Not: Örnek için geliştirme ortamı olarak Eclipse (mümkünse Maven plugin’i kurulmuş) ile devam edeceğim. Maven kullanmak istemeyenler gerekli kütüphaneleri kendileri eklemek durumunda.

1) Proje oluşturulması

Öncelikle işe bir maven web projesi oluşturarak başlıyoruz. Projemizin adı “restfulwssample” olsun.
Bunun için File –> New –> Others –> Maven Project yolunu izliyoruz. Bu aşamada Maven kullanmak istemiyorsanız yada daha sonra aktif hale getirmek isterseniz “Dynamic Web Project” seçeneği ile ilerleyebilirsiniz.




Sonraki ekranda “Maven Project” seçeneği ile devam ediyoruz.




Sonrasında “Next” tuşlarıyla ilerleyip archetype seçim ekranı geldiğinde “maven-archetype-webapp” seçeneği ile ilerliyoruz.




Sonraki ekrandaki bilgiler tamamen size kalmış, bu bilgileride doldurduktan sonra “Finish” butonu ile web projemizin taslağını oluşturmuş oluyoruz.




Projemizin aşağıdaki gibi görünmesi gerekiyor.




Projemiz hazır. RESTful web servisler hazırlamamız için önmüzdeki tek engel RESTful Web servis için kullanılacak kütüphaneyi bulmamız. Ben bu örnekte Jersey kütüphanesi kullanacağım. JAX-RS spesifikasyonu için referans implementasyon olmasının yanı sıra production ortamlarında da kullanılabilecek olgunluğa sahip olduğu için Jersey’i tercih ettim. Projemizde Jersey kullanabilmek için pom.xml’e aşağıdaki satırları eklememiz yeterli olacaktır.

<repositories> 
<repository>
<id>maven2-repository.java.net</id>
<name>Java.net Repository for Maven</name>
<url>http://download.java.net/maven/2/</url>
<layout>default</layout>
</repository> 
<repository>
<id>maven-repository.java.net</id>
<name>Java.net Maven 1 Repository (legacy)</name>
<url>http://download.java.net/maven/1</url>
<layout>legacy</layout>
</repository>
<repositories>
<dependencies>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-server</artifactId>
<version>1.6</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-json</artifactId>
<version>1.6</version>
</dependency>
<dependencies>

Not: Jersey kullanarak text/html, xml, json gibi farklı yöntemler kullanarak haberleşen web servisler tasarlanması mümkün. Ben örnekte JSON kullanacağım için onunla ilgili dependency’i ekledim. Detalı bilgi için http://jersey.java.net/nonav/documentation/latest/user-guide.html adresine göz atmanızda fayda var.


2) Biraz kod görelim


Örneğimiz için iki sınıf kullacağız. Bunlardan biri RESTful web servisi barındıran sınıf (RSWebServices.java) diğeri ise bu servisin çıktısını temsil eden veri transfer sınıfı (RSOutputDTO.java)

Sınıfları aşağıdaki paket yapısında oluşturalım.





RSOutputDTO.java
package com.blogspot.emrahkocaman.restfulws.json;
public class RSOutputDTO {
private String userName;
private int userAge;
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserName() {
return userName;
}
public void setUserAge(int userAge) {
this.userAge = userAge;
}
public int getUserAge() {
return userAge;
}
}

Bu sınıf web servisimizin üreteceği çıktıyı temsil eden basit bir java sınıfı namı diğer POJO.


RSWebServices.java
package com.blogspot.emrahkocaman.restfulws.ws;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import com.blogspot.emrahkocaman.restfulws.json.RSOutputDTO;
@Path("/examples")
public class RSWebServices {
@GET
@Path("/getUserInfo")
@Produces(MediaType.APPLICATION_JSON)
public RSOutputDTO getUserInfo() {
RSOutputDTO out = new RSOutputDTO();
out.setUserAge(30);
out.setUserName("Kamil");
return out;
}
}

Web servisimiz bu sınıftan ibaret. SOAP mimarisindekinin aksine xml konfigürasyonları ve xsd’ler ile boğuşmak zorunda değiliz. Doğrudan hedefe yapılan bir atış.

@Path: Sınıf tanımının üzerindeki annotation, web servise ulaşacağımız kök tanımı. Method üzerindeki ise methoda ulaşacağımız tanım. Yani web servis adresimiz http://server:port/examples/getUserInfo gibi bir adres olacak.

@GET: RESTful web servisler HTTP protokülü üzerinden haberleşirler sonuç olarak HTTP operasyonlarına karşılık gelecek annotationlar ile kullanılırlar (@GET, @PUT, @POST, @DELETE and @HEAD gibi). Bizim servisimizin GET isteklerine cevap vereceğini işaretliyoruz.

@Produces: RESTful web servisin çıktısının hangi türde olacağı bu annotation ile belirtilir. Biz örneğimizde JSON kullanıyoruz.


3) Son rötüşlar


RESTful web servisimizi dünyaya açmanın zamanı geldi. Öncelikle Jersey servletini ayağa kaldırmamız gerekiyor.

Bunun için web.xml’e aşağıdaki satırları ekyelim.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>restfulwssample</display-name>
<servlet>
<servlet-name>Jersey Web Application</servlet-name>
<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>com.blogspot.emrahkocaman.restfulws.ws</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Jersey Web Application</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
</web-app>

Servlet’in aldığı parametrelerden com.sun.jersey.config.property.packages parametresi hangi paketin altındaki sınıfların web servis olarak açılacağını belirtiyor.

com.sun.jersey.api.json.POJOMappingFeature parametresini “true” olarak set ederek ise POJO’larımız jackson kütüphanesi kullanılarak Jersey tarafından otomatik olarak JSON’a dönüştürülüyor.

Web projemizi sunucumuza deploy ettikten sonra,

http://localhost:8080/restfulwssample/rest/examples/getUserInfo adresini browser’a girdiğimiz zaman restful web servisimize ulaşmış olacağız. Bize dönen JSON nesnesini bir text editör ile açtığımızda içeriğinin aşağıdaki gibi olması gerekiyor.

{"userName":"Kamil","userAge":30}

Bundan sonra RESTful ile yapabilecekleriniz size kalmış. Ama bence web servis yazmak hiç bu kadar kolay olmamıştı.

Bir sonraki yazımda hazırladığımız RESTful web servis için bir Android istemci yazıyor olacağız.

Herkese iyi çalışmalar.

Eclipse Projesi : http://db.tt/PCS4UrX