Struts 2 Hello World Örneği: Annotasyonlarla ve struts.xml Olmadan
Struts 2 Hello World Örneği: Annotasyonlarla ve struts.xml Olmadan
Giriş
Java tabanlı web uygulaması geliştirme dünyasında, Model-View-Contro
Struts 2 Hello World Örneği: Annotasyonlarla ve struts.xml Olmadan
Giriş
Java tabanlı web uygulaması geliştirme dünyasında, Model-View-Controller (MVC) mimarisi, uygulamanın farklı katmanlarını ayırarak geliştirme ve bakımı kolaylaştıran standart bir yaklaşımdır. Struts 2, Apache Software Foundation tarafından geliştirilen güçlü ve esnek bir MVC çerçevesidir. Geliştiricilere, web uygulamaları oluşturmak için sağlam bir yapı, zengin özellikler ve genişletilebilir bir mimari sunar. Geleneksel olarak, Struts 2 uygulamalarının yapılandırması struts.xml adı verilen XML tabanlı bir dosya aracılığıyla yapılırdı. Bu dosya, hangi URL’lerin hangi Action sınıflarına eşleneceğini, Action’ların hangi Interceptor’ları kullanacağını ve sonuç olarak hangi görünüm dosyalarının (JSP gibi) döndürüleceğini tanımlardı. Ancak, modern Java geliştirme pratikleri, XML tabanlı yapılandırmaların getirdiği ek yükü azaltma ve yapılandırmayı kodun yanına taşıma eğilimindedir. Bu noktada, Java Annotasyonları devreye girer.
Struts 2, 2.1 sürümünden itibaren, struts2-convention-plugin sayesinde annotasyon tabanlı yapılandırmayı desteklemeye başlamıştır. Bu eklenti, Action sınıflarındaki özel annotasyonları okuyarak ve belirli adlandırma kurallarını (convention over configuration) izleyerek, struts.xml dosyasına ihtiyaç duymadan uygulamanın büyük bir kısmını yapılandırma yeteneği sunar. Bu yaklaşım, geliştirme sürecini hızlandırır, kod tabanını temizler ve XML karmaşasını önemli ölçüde azaltır.
Bu makalede, Struts 2’nin annotasyon tabanlı yapılandırma yeteneklerini kullanarak, geleneksel struts.xml dosyasına hiç dokunmadan basit bir “Hello World” uygulaması oluşturmayı adım adım inceleyeceğiz. Amacımız, Struts 2’nin temel akışını anlamakla kalmayıp, aynı zamanda modern geliştirme yaklaşımlarının sunduğu esneklik ve sadeliği deneyimlemektir. Maven kullanarak proje kurulumundan başlayarak, Action sınıfı oluşturmaya, görünüm katmanını tasarlamaya ve uygulamayı çalıştırmaya kadar tüm süreci detaylandıracağız.
Struts 2’nin Temelleri
Struts 2, Servlet API üzerine inşa edilmiş bir çerçevedir ve bir web isteğinin yaşam döngüsünü yönetmek için bir dizi bileşen kullanır. Temel bileşenleri şunlardır:
* FilterDispatcher (veya StrutsPrepareAndExecuteFilter): Tüm Struts 2 isteklerini yakalayan ve işleyen ana servlet filtresidir. İstekleri Struts 2 çerçevesine yönlendirir.
* Interceptors: Action’lar çağrılmadan önce veya çağrıldıktan sonra belirli görevleri gerçekleştiren modüllerdir. Örneğin, doğrulama, dosya yükleme, modelden veri alma gibi işlemler Interceptor’lar aracılığıyla yapılır.
* Actions: İş mantığını içeren sınıflardır. Bir web isteğine yanıt olarak çağrılırlar ve genellikle execute() gibi bir metotları vardır. Action’lar, isteği işler, modelle etkileşime girer ve bir sonuç kodu döndürür.
* Results: Action tarafından döndürülen sonuç koduna göre hangi görünümün (JSP, FreeMarker, Velocity vb.) görüntüleneceğini veya hangi HTTP yönlendirmesinin yapılacağını belirler.
Geleneksel Struts 2’de, tüm bu bileşenlerin nasıl bir araya geleceği struts.xml dosyasında tanımlanırdı. Örneğin, bir Action’ın adı, sınıfı, kullandığı Interceptor’lar ve farklı sonuç kodlarına karşılık gelen görünüm dosyaları bu XML’de belirtilirdi. Ancak annotasyonlarla, bu yapılandırma bilgileri doğrudan Action sınıflarının içine taşınır.
Neden struts.xml Olmadan Annotasyonları Kullanmalıyız?
struts.xml dosyasının olmaması, geliştirme sürecine bir dizi önemli avantaj getirir:
1. Daha Az XML Yapılandırması: XML dosyaları, özellikle büyük projelerde, oldukça karmaşık ve yönetilmesi zor hale gelebilir. Annotasyonlar, bu karmaşayı azaltır ve yapılandırmayı daha okunabilir hale getirir.
2. Kod ve Yapılandırmanın Birlikteliği: Action sınıfının işlevselliği ile ilgili yapılandırma bilgileri (örneğin, hangi URL’ye yanıt verdiği veya hangi JSP’yi döndürdüğü) doğrudan sınıfın içinde bulunur. Bu, ilgili bilgileri tek bir yerde tutarak kodun okunabilirliğini ve bakımını kolaylaştırır.
3. Geliştirme Hızında Artış: Daha az XML yazmak ve yönetmek, özellikle küçük ve orta ölçekli projelerde geliştirme hızını artırır. Geliştiriciler, yapılandırma dosyaları arasında gidip gelmek yerine doğrudan iş mantığına odaklanabilirler.
4. Convention Over Configuration:struts2-convention-plugin, belirli adlandırma kurallarına uyulduğunda otomatik olarak yapılandırma yapar. Bu, geliştiricinin her şeyi manuel olarak tanımlama ihtiyacını ortadan kaldırır ve standart bir proje yapısını teşvik eder.
5. Modern Geliştirme Yaklaşımlarıyla Uyum: Spring Boot, JAX-RS gibi modern Java çerçeveleri de annotasyon tabanlı yapılandırmayı yaygın olarak kullanır. Struts 2’nin bu yaklaşımı benimsemesi, ekosistemdeki genel trendlerle uyum sağlar.
Elbette, büyük ve karmaşık projelerde, merkezi bir struts.xml dosyasının genel bir bakış sunma potansiyeli olabilir. Ancak struts2-convention-plugin, bu tür senaryolar için de esneklik sunar ve gerektiğinde belirli annotasyonları veya adlandırma kurallarını geçersiz kılma imkanı tanır.
Proje Kurulumu ve Gerekli Bağımlılıklar
Struts 2 projemizi Maven kullanarak kuracağız. Maven, bağımlılık yönetimini ve proje derleme süreçlerini otomatikleştiren güçlü bir araçtır.
İlk olarak, yeni bir Maven web projesi oluşturalım:
Bu komut, Struts2AnnotationHelloWorld adında bir web uygulaması iskeleti oluşturacaktır. Proje dizinine girdikten sonra (cd Struts2AnnotationHelloWorld), pom.xml dosyasını düzenlememiz gerekecek.
pom.xml dosyasını açın ve aşağıdaki bağımlılıkları ekleyin:
Önemli Notlar:
* struts2-core: Struts 2’nin temel işlevselliğini sağlar.
* struts2-convention-plugin: Bu eklenti, annotasyon tabanlı yapılandırmayı ve “convention over configuration” prensibini mümkün kılar. struts.xml kullanmadan Action’ları ve sonuçları yapılandırmanın anahtarıdır.
* javax.servlet-api ve javax.servlet.jsp-api: Bu API’ler, uygulamanın bir Servlet kapsayıcısında (örneğin, Tomcat) çalışırken zaten mevcut olduğundan provided kapsamıyla eklenir.
* log4j-core ve log4j-api: Struts 2, dahili olarak Log4j gibi bir günlükleme mekanizması kullanır. Bu bağımlılıklar, uygulamanızda günlükleme yapabilmenizi sağlar.
Web Uygulaması Yapılandırması: web.xml
Tüm Struts 2 uygulamalarında olduğu gibi, web uygulamamızın ana yapılandırma dosyası olan web.xml‘i düzenlememiz gerekiyor. Bu dosya, Struts 2’nin ana filtresi olan StrutsPrepareAndExecuteFilter‘ı tanımlar ve tüm istekleri bu filtreye yönlendirir.
src/main/webapp/WEB-INF/web.xml dosyasını aşağıdaki gibi güncelleyin:
Bu web.xml yapılandırması, gelen tüm web isteklerinin (/*) struts2 filtresi tarafından işlenmesini sağlar. StrutsPrepareAndExecuteFilter, Struts 2 çerçevesinin kalbidir ve gelen isteği uygun Action’a yönlendirmekten, Interceptor’ları uygulamaktan ve sonucu işlemeye kadar tüm süreci yönetir.
Action Sınıfı Oluşturma: Annotasyonların Gücü
Şimdi, “Hello World” mesajını üretecek olan Action sınıfımızı oluşturalım. Bu sınıfı src/main/java/com/example/action dizini altında HelloAction.java olarak kaydedeceğiz.
package com.example.action;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Namespace;
// @Namespace("/") annotation'ı, bu Action'ın kök namespace altında olduğunu belirtir.
// Eğer belirtilmezse, paket adına göre otomatik bir namespace atanabilir.
@Namespace("/")
public class HelloAction extends ActionSupport {
// Action'dan JSP'ye gönderilecek veri için bir özellik tanımlıyoruz.
private String userName;
// Getter metodu, Struts 2'nin OGNL (Object-Graph Navigation Language) kullanarak
// JSP'den bu özelliğe erişmesini sağlar.
public String getUserName() {
return userName;
}
// Setter metodu, formdan veya URL parametresinden gelen veriyi
// bu özelliğe set etmesini sağlar.
public void setUserName(String userName) {
this.userName = userName;
}
/
* @Action annotasyonu, bu metodun bir Struts 2 Action'ı olduğunu belirtir.
* value = "hello" Action'ın URL'deki adını tanımlar (örn: /hello).
* @Result annotasyonu, Action başarılı olduğunda (varsayılan "success" sonucu için)
* hangi JSP dosyasının görüntüleneceğini belirtir.
* name = "success" varsayılan ActionSupport.SUCCESS sonucunu ifade eder.
* location = "/WEB-INF/content/hello.jsp" görüntülenecek JSP dosyasının yolunu belirtir.
* Convention plugin varsayılan olarak sonuç dosyalarını WEB-INF/content altında arar.
*/
@Action(value = "hello", results = {
@Result(name = "success", location = "/WEB-INF/content/hello.jsp")
})
public String execute() {
// Eğer userName boşsa veya null ise, varsayılan bir değer atayalım.
if (userName == null || userName.trim().isEmpty()) {
userName = "Dünya";
}
// İş mantığı burada yürütülür.
// Başarılı bir şekilde tamamlandığını belirten "success" döndürüyoruz.
return SUCCESS;
}
}
Bu Action sınıfındaki annotasyonları detaylıca inceleyelim:
* @Namespace("/"): Bu annotasyon, HelloAction sınıfının kök namespace altında çalıştığını belirtir. Yani, bu Action’a /hello URL’si ile erişilebilir. Eğer bu annotasyon olmasaydı, struts2-convention-plugin varsayılan olarak paketin adına göre bir namespace oluşturabilirdi (örneğin, com.example.action paketi için /example/action).
* @Action(value = "hello", results = { ... }): Bu, en kritik annotasyondur.
* value = "hello": Bu Action’a erişmek için kullanılacak URL yolunu tanımlar. Yani, web uygulamasının kök dizininden sonra /hello yazıldığında bu Action tetiklenecektir.
* results = { ... }: Action’ın farklı sonuç kodlarına karşılık gelen görünüm dosyalarını tanımlar. Burada sadece bir Result tanımladık:
* @Result(name = "success", location = "/WEB-INF/content/hello.jsp"): execute() metodu SUCCESS (ki bu ActionSupport sınıfından gelen bir sabittir ve değeri “success” dizesidir) döndürdüğünde, /WEB-INF/content/hello.jsp dosyasının görüntüleneceğini belirtir. struts2-convention-plugin varsayılan olarak JSP dosyalarını WEB-INF/content dizininde arar.
* userName özelliği ve Getter/Setter Metotları: Struts 2, Action sınıfındaki public getter ve setter metotlarını kullanarak form verilerini veya URL parametrelerini Action özelliklerine otomatik olarak bağlar (model driven design). Bu örnekte, URL’den ?userName=Ali şeklinde bir parametre gelirse, setUserName("Ali") metodu çağrılacak ve userName özelliği “Ali” değerini alacaktır. Getter metodu ise JSP’de bu özelliğe erişmek için kullanılır.
execute() metodu, Action’ın ana iş mantığını içerir. Bu örnekte, userName boşsa “Dünya” olarak ayarlar ve her zaman SUCCESS dizesini döndürür.
Görünüm Katmanı: JSP Dosyası
Action sınıfımızdan dönen SUCCESS sonucuna karşılık gelen JSP dosyasını oluşturalım. struts2-convention-plugin varsayılan olarak görünüm dosyalarını WEB-INF/content dizininde aradığı için, bu dizini oluşturup içine hello.jsp dosyamızı yerleştireceğiz.
src/main/webapp/WEB-INF/content/hello.jsp dosyasını aşağıdaki gibi oluşturun:
Bu mesaj, Struts 2 Action sınıfınızdan annotasyonlar kullanılarak dinamik olarak üretildi.
struts.xml dosyasına ihtiyaç duymadan yapılandırmanın ne kadar kolay olduğunu gösterir.
URL'ye ?userName=Adınız ekleyerek farklı bir isimle deneyin!
JSP Dosyasındaki Önemli Noktalar:
* <%@ taglib prefix="s" uri="/struts-tags"%>: Bu satır, Struts 2’nin özel etiket kütüphanesini (tag library) JSP’ye dahil eder. Bu kütüphane, Action özelliklerine erişmek, form öğeleri oluşturmak ve diğer Struts 2 özelliklerini kullanmak için s: önekli etiketler sağlar.
* : Bu Struts 2 etiketi, HelloAction sınıfındaki userName özelliğinin değerini alır ve JSP’de görüntüler. Struts 2’nin OGNL (Object-Graph Navigation Language) yeteneği sayesinde Action’ın özelliklerine doğrudan erişebiliriz.
Uygulamanın Çalıştırılması ve Test Edilmesi
Projemizi bir Servlet kapsayıcısında (örneğin Apache Tomcat) çalıştırmak için Maven’ı kullanabiliriz. pom.xml dosyamıza eklediğimiz tomcat7-maven-plugin sayesinde bu işlem oldukça basittir.
Proje kök dizininde aşağıdaki komutu çalıştırın:
mvn clean install tomcat7:run
Bu komut, projenizi derleyecek, .war dosyasını oluşturacak ve gömülü Tomcat sunucusunu başlatacaktır. Sunucu başarıyla başlatıldığında, tarayıcınızı açın ve aşağıdaki URL’leri ziyaret edin:
1. Varsayılan Hello World:http://localhost:8080/Struts2AnnotationHelloWorld/hello
* Bu URL’yi ziyaret ettiğinizde, HelloAction sınıfının execute() metodu çalışacak ve userName özelliği varsayılan olarak “Dünya” değerini alacaktır. JSP, “Merhaba, Dünya!” mesajını gösterecektir.
2. Kişiselleştirilmiş Hello World:http://localhost:8080/Struts2AnnotationHelloWorld/hello?userName=Ali
* Bu URL’yi ziyaret ettiğinizde, URL’deki userName parametresi HelloAction sınıfındaki setUserName() metodunu tetikleyecek ve userName özelliğini “Ali” olarak ayarlayacaktır. JSP, “Merhaba, Ali!” mesajını gösterecektir.
Akışın Özeti:
1. Kullanıcı http://localhost:8080/Struts2AnnotationHelloWorld/hello URL’sine bir istek gönderir.
2. web.xml‘de yapılandırılan StrutsPrepareAndExecuteFilter, bu isteği yakalar.
3. Filtre, struts2-convention-plugin‘i tetikler. Convention plugin, Action sınıflarını tarar ve @Action(value="hello") annotasyonuna sahip HelloAction sınıfını bulur.
4. Struts 2, HelloAction sınıfının bir örneğini oluşturur. Eğer URL’de userName parametresi varsa, setUserName() metodu çağrılarak bu özellik set edilir.
5. execute() metodu çağrılır.
6. execute() metodu SUCCESS dizesini döndürür.
7. @Result(name="success", location="/WEB-INF/content/hello.jsp") annotasyonu sayesinde, Struts 2 /WEB-INF/content/hello.jsp dosyasını görüntüler.
8. JSP içinde etiketi, HelloAction nesnesindeki userName özelliğinin değerini alır ve ekranda gösterir.
Convention Plugin’in Derinlikleri
struts2-convention-plugin, Struts 2’nin annotasyon tabanlı yapılandırmasının kalbinde yer alır. Bu eklenti, belirli adlandırma kurallarına (“convention”) uyulduğunda, geliştiricinin manuel yapılandırma (“configuration”) yapma ihtiyacını ortadan kaldırır. İşte bazı temel kurallar:
* Action Sınıfı Konumu: Varsayılan olarak, eklenti action veya actions gibi paketlerdeki sınıfları Action olarak kabul eder. Ancak @Action annotasyonu kullanıldığında bu kural geçersiz kılınabilir.
* Action Adları: Eğer bir sınıf Action ile bitiyorsa (örneğin HelloAction), varsayılan olarak Action adı sınıf adının küçük harfli ve “Action” kısmı atılmış hali olur (yani hello). @Action(value="...") ile bu da geçersiz kılınabilir.
* Namespace’ler:@Namespace annotasyonu kullanılmazsa, eklenti Action sınıfının paket yolunu (örneğin com.example.action için /example/action) bir namespace olarak kullanır.
* Sonuç (Result) Konumları:struts2-convention-plugin varsayılan olarak JSP dosyalarını WEB-INF/content, WEB-INF/pages veya WEB-INF/views gibi dizinlerde arar. @Result(location="...") ile bu da özelleştirilebilir.
* Varsayılan Sonuç Adları:execute() metodu gibi bir Action metodunun döndürdüğü string (örneğin “success”, “input”, “error”) doğrudan bir sonuç adıyla eşleştirilir. Eğer @Result annotasyonu kullanılmazsa, eklenti döndürülen string ile aynı ada sahip bir JSP dosyasını (/WEB-INF/content/success.jsp gibi) otomatik olarak bulmaya çalışır.
Bu kurallar, projenin standart bir yapıda kalmasını teşvik eder ve yeni geliştiricilerin projeye adaptasyonunu kolaylaştırır. Aynı zamanda, hızlı prototipleme ve geliştirme için büyük kolaylık sağlar.
Gelişmiş Annotasyon Kullanımları
struts2-convention-plugin, temel Action ve Result tanımlamalarının ötesinde daha gelişmiş yapılandırmalar için de annotasyonlar sunar:
* @Actions: Birden fazla @Action annotasyonunu aynı sınıf veya metot üzerinde kullanmak için bir kapsayıcı annotasyondur. Bir Action sınıfının birden fazla URL’ye yanıt vermesini sağlayabilir.
* @Results: Birden fazla @Result annotasyonunu aynı Action üzerinde kullanmak için bir kapsayıcı annotasyondur. Örneğin, success, input, error gibi farklı sonuçlara farklı JSP’ler atamak için kullanılır.
* @ResultPath: Eğer Action’larınız için varsayılan sonuç dosya yolunu (örn. /WEB-INF/content/) değiştirmek isterseniz, bu annotasyonu Action sınıfının üzerine koyabilirsiniz.
* @ExceptionMapping: Belirli istisnalar (exceptions) meydana geldiğinde hangi görünüm dosyasının gösterileceğini veya hangi Action’a yönlendirileceğini tanımlamak için kullanılır. Bu, hata yönetimini Action sınıfının içine taşımaya olanak tanır.
* @InterceptorRef: Bir Action’a veya bir Action metoduna belirli Interceptor’ları uygulamak için kullanılır. Bu, struts.xml‘deki etiketinin annotasyon karşılığıdır. Örneğin, params veya validation Interceptor’larını uygulamak için kullanılabilir.
* @ParentPackage: Bir Action’ın hangi Struts paketini (ve dolayısıyla o pakette tanımlı olan Interceptor stack’lerini) miras alacağını belirtmek için kullanılır.
Bu annotasyonlar, struts.xml dosyasının sunduğu esnekliği büyük ölçüde annotasyon tabanlı yapılandırmaya taşır ve çoğu senaryoda XML’e olan ihtiyacı tamamen ortadan kaldırır.
Annotasyon Yaklaşımının Avantajları ve Dezavantajları
1. Daha Az XML Karmaşası: En belirgin avantaj, XML yapılandırma dosyalarının sayısının ve karmaşıklığının azalmasıdır. Bu, proje boyutunu küçültür ve geliştiricinin daha az “yapılandırma dili” ile uğraşmasını sağlar.
2. Geliştirme Hızı: Convention over configuration prensibi sayesinde, birçok standart yapılandırma otomatik olarak yapılır. Bu, özellikle yeni bir proje başlatırken veya basit Action’lar eklerken geliştirme süresini önemli ölçüde kısaltır.
3. Kodun Okunabilirliği ve Bakımı: Yapılandırma bilgileri doğrudan Action sınıfının içinde veya üzerinde yer aldığı için, bir Action’ın ne yaptığını, hangi URL’ye yanıt verdiğini ve hangi sonuçları döndürdüğünü anlamak daha kolaydır. İlgili bilgiler tek bir yerde toplanmıştır.
4. Modern Geliştirme Pratikleriyle Uyum: Annotasyonlar, Spring, JAX-RS gibi diğer modern Java çerçevelerinde de yaygın olarak kullanılır. Struts 2’nin bu yaklaşımı benimsemesi, Java geliştiricileri için öğrenme eğrisini azaltabilir ve ekosistemdeki genel trendlere uyum sağlar.
5. Refactoring Kolaylığı: IDE’ler, annotasyonları daha iyi anlayabilir ve Action sınıflarını veya metotlarını yeniden düzenlerken (refactor) ilgili annotasyonları da güncelleyebilir.
Dezavantajlar:
1. Dağılmış Yapılandırma: Çok büyük ve karmaşık projelerde, tüm yapılandırma bilgilerinin Action sınıflarına dağılması, projenin genel yapısını anlamayı zorlaştırabilir. Merkezi bir XML dosyasının sunduğu “büyük resim” bazen eksik kalabilir.
2. Convention Kurallarını Anlama İhtiyacı:struts2-convention-plugin‘in “sihirli” yapısı, yani hangi adlandırma kurallarının hangi otomatik yapılandırmayı tetiklediğini anlamak, yeni başlayanlar için başlangıçta biraz zorlayıcı olabilir. Ne zaman bir annotasyon kullanmak gerektiğini, ne zaman convention’a güvenebileceğini bilmek pratik gerektirir.
3. Çakışma Potansiyeli: Hem annotasyonları hem de geleneksel struts.xml‘i aynı projede kullanmak mümkündür, ancak bu durum yapılandırma çakışmalarına ve beklenmedik davranışlara yol açabilir. Genellikle tek bir yaklaşımı benimsemek daha iyidir.
4. Sürüm Bağımlılığı: Annotasyonlar ve Convention Plugin, Struts 2’nin belirli sürümlerinden itibaren tam olarak desteklenmektedir. Eski projeleri yükseltirken veya farklı sürümlerle çalışırken uyumluluk sorunları yaşanabilir.
Genel olarak, annotasyon tabanlı yaklaşım, modern Struts 2 projeleri için önerilen ve tercih edilen bir yöntemdir. Dezavantajları, genellikle dikkatli tasarım ve iyi dokümantasyon ile yönetilebilir.
Sonuç
Bu makalede, Struts 2 çerçevesini kullanarak annotasyonlar aracılığıyla ve geleneksel struts.xml dosyasına ihtiyaç duymadan basit bir “Hello World” web uygulaması oluşturmayı adım adım inceledik. Maven ile proje kurulumundan başlayarak, pom.xml‘e gerekli bağımlılıkları eklemeyi, web.xml‘i yapılandırmayı, @Action ve @Result annotasyonlarını kullanarak Action sınıfımızı yazmayı ve son olarak JSP görünümümüzü oluşturmayı gösterdik.
struts2-convention-plugin sayesinde, Struts 2’nin ne kadar esnek ve modern geliştirme pratikleriyle uyumlu olduğunu görmüş olduk. Annotasyonlar, XML tabanlı yapılandırmanın getirdiği ek yükü azaltarak, geliştiricilerin daha temiz, daha okunabilir kod yazmalarına ve geliştirme süreçlerini hızlandırmalarına olanak tanır. Özellikle yeni projeler için veya XML karmaşasından kaçınmak isteyenler için annotasyon tabanlı yaklaşım güçlü bir alternatiftir.
Uygulamamızı çalıştırarak, bir web isteğinin Struts 2 filtresi tarafından nasıl yakalandığını, Convention Plugin’in Action sınıfımızı nasıl bulduğunu, Action’ın iş mantığını nasıl yürüttüğünü ve son olarak uygun JSP’yi nasıl görüntülediğini deneyimledik. Bu temel “Hello World” örneği, Struts 2’nin annotasyonlarla nasıl çalıştığına dair sağlam bir temel sunmaktadır. Buradan hareketle, form işleme, veritabanı entegrasyonu, doğrulama ve daha karmaşık iş akışları gibi Struts 2’nin diğer güçlü özelliklerini keşfetmek için bir başlangıç noktası olarak kullanılabilir. Struts 2, hala güçlü ve aktif olarak geliştirilen bir çerçeve olup, web uygulamaları geliştirmek için geçerli bir seçenektir.
Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
