Payandalar 2 - Hızlı Kılavuz
MOdel View Cdenetleyici veya MVCpopüler olarak adlandırıldığı gibi, web uygulamaları geliştirmek için bir yazılım tasarım modelidir. Model Görünüm Denetleyici kalıbı aşağıdaki üç bölümden oluşur -
Model - Verilerin korunmasından sorumlu olan modelin en düşük seviyesi.
View - Bu, verilerin tamamının veya bir kısmının kullanıcıya gösterilmesinden sorumludur.
Controller - Model ve Görünüm arasındaki etkileşimleri kontrol eden Yazılım Kodu.
MVC, uygulama mantığını kullanıcı arabirimi katmanından ayırdığı ve endişelerin ayrılmasını desteklediği için popülerdir. Burada Kontrolör, uygulamaya yönelik tüm talepleri alır ve ardından Model ile birlikte Görünüm için ihtiyaç duyulan verileri hazırlamak için çalışır. Görünüm daha sonra Kontrolör tarafından hazırlanan verileri kullanarak nihai bir sunulabilir yanıt oluşturur. MVC soyutlaması aşağıdaki gibi grafiksel olarak temsil edilebilir.
Model
Model, uygulamanın verilerini yönetmekten sorumludur. Görünümden gelen talebe yanıt verir ve ayrıca kontrolörün kendisini güncellemesi için gelen talimatlara yanıt verir.
Görünüm
Verilerin, bir kontrolörün verileri sunma kararıyla tetiklenen belirli bir formatta sunulması anlamına gelir. JSP, ASP, PHP gibi komut dosyası tabanlı şablonlama sistemleridir ve AJAX teknolojisi ile entegrasyonu çok kolaydır.
Kontrol eden, denetleyici
Denetleyici, kullanıcı girdisine yanıt vermekten ve veri modeli nesneleri üzerinde etkileşimler gerçekleştirmekten sorumludur. Kontrolör girişi alır, girişi doğrular ve ardından veri modelinin durumunu değiştiren iş operasyonunu gerçekleştirir.
Struts2MVC tabanlı bir çerçevedir. Önümüzdeki bölümlerde, Struts2 içinde MVC metodolojisini nasıl kullanabileceğimizi görelim.
Struts2MVC tasarım modeline dayalı popüler ve olgun bir web uygulama çerçevesidir. Struts2, Struts 1'in sadece yeni bir versiyonu değil, aynı zamanda Struts mimarisinin tamamen yeniden yazılmasıdır.
Webwork çerçevesi başlangıçta temel olarak Struts çerçevesi ile başladı ve amacı, geliştiriciler için web geliştirmeyi kolaylaştırmak için Struts üzerine inşa edilmiş gelişmiş ve iyileştirilmiş bir çerçeve sunmaktı.
Bir süre sonra, Webwork çerçevesi ve Struts topluluğu, ünlü Struts2 çerçevesini oluşturmak için el ele verdi.
Struts 2 Çerçeve Özellikleri
İşte sizi Struts2'yi düşünmeye zorlayabilecek harika özelliklerden bazıları -
POJO Forms and POJO Actions- Struts2, Struts çerçevesinin ayrılmaz bir parçası olan Eylem Formlarını ortadan kaldırdı. Struts2 ile form girdisini almak için herhangi bir POJO kullanabilirsiniz. Benzer şekilde, artık herhangi bir POJO'yu Action sınıfı olarak görebilirsiniz.
Tag Support - Struts2, geliştiricilerin daha az kod yazmasını sağlayan form etiketlerini ve yeni etiketleri geliştirdi.
AJAX Support - Struts2, Web2.0 teknolojilerinin devraldığını fark etmiş ve AJAX etiketleri oluşturarak ürüne AJAX desteğini entegre etmiştir, bu işlev standart Struts2 etiketlerine çok benzer.
Easy Integration - Spring, Tiles ve SiteMesh gibi diğer çerçevelerle entegrasyon, Struts2 ile mevcut olan çeşitli entegrasyon sayesinde artık daha kolay.
Template Support - Şablonları kullanarak görünümler oluşturma desteği.
Plugin Support- Temel Struts2 davranışı eklentilerin kullanımıyla geliştirilebilir ve artırılabilir. Struts2 için bir dizi eklenti mevcuttur.
Profiling- Struts2, uygulamada hata ayıklamak ve profil oluşturmak için entegre profilleme sunar. Buna ek olarak, Struts ayrıca yerleşik hata ayıklama araçlarının yardımıyla entegre hata ayıklama sunar.
Easy to Modify Tags- Struts2'deki etiket işaretlemeleri Freemarker şablonları kullanılarak değiştirilebilir. Bu, JSP veya java bilgisi gerektirmez. Etiketleri değiştirmek için temel HTML, XML ve CSS bilgisi yeterlidir.
Promote Less configuration- Struts2, çeşitli ayarlar için varsayılan değerleri kullanarak daha az konfigürasyonu destekler. Struts2 tarafından belirlenen varsayılan ayarlardan sapmadığı sürece bir şeyi yapılandırmanız gerekmez.
View Technologies - Struts2, çoklu görüntüleme seçenekleri için harika bir desteğe sahiptir (JSP, Freemarker, Velocity ve XSLT)
Yukarıda listelenen En İyi 10 özelliği Struts 2 bu da onu Kurumsal kullanıma hazır bir çerçeve haline getirir.
Dikmeler 2 Dezavantajları
Struts 2 harika özelliklerin bir listesi ile gelse de, mevcut sürümün bazı sınırlamaları vardır - daha fazla iyileştirme gerektiren Struts 2. Ana noktalardan bazıları listelenmiştir -
Bigger Learning Curve - MVC'yi Struts ile kullanmak için, standart JSP, Servlet API'leri ve geniş ve ayrıntılı bir çerçeve ile rahat olmanız gerekir.
Poor Documentation - Standart sunucu uygulaması ve JSP API'leri ile karşılaştırıldığında, Struts daha az çevrimiçi kaynağa sahiptir ve ilk kez kullananların çoğu çevrimiçi Apache belgelerini kafa karıştırıcı ve kötü organize edilmiş bulmaktadır.
Less Transparent - Struts uygulamalarıyla, çerçevenin anlaşılmasını zorlaştıran normal Java tabanlı Web uygulamalarından çok daha fazlası perde arkasında oluyor.
Son not, iyi bir çerçeve, birçok farklı türdeki uygulamanın kullanabileceği genel davranış sağlamalıdır.
Struts 2 en iyi web çerçevelerinden biridir ve Zengin İnternet Uygulamalarının (RIA) geliştirilmesi için oldukça kullanılmaktadır.
İlk görevimiz minimal bir Struts 2 uygulamasını çalıştırmaktır. Bu bölüm, Struts 2 ile çalışmanıza başlamak için bir geliştirme ortamını nasıl hazırlayacağınız konusunda size rehberlik edecektir.
Makinenizde zaten JDK (5+), Tomcat ve Eclipse'in kurulu olduğunu varsayıyorum. Bu bileşenleri yüklemediyseniz, hızlı yol için verilen adımları izleyin -
Adım 1 - Java Geliştirme Kitini (JDK) Kurun
En son SDK sürümünü Oracle'ın Java sitesinden indirebilirsiniz - Java SE İndirmeleri . İndirilen dosyalara JDK kurulumu için talimatlar bulacaksınız, kurulumu kurmak ve yapılandırmak için verilen talimatları izleyin. Son olarak, PATH ve JAVA_HOME ortam değişkenlerini java ve javac içeren dizine, tipik olarak sırasıyla java_install_dir / bin ve java_install_dir'e başvuracak şekilde ayarlayın.
Windows çalıştırıyorsanız ve SDK'yı C: \ jdk1.5.0_20 konumuna yüklediyseniz, aşağıdaki satırı C: \ autoexec.bat dosyanıza girmelisiniz.
set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20Alternatif olarak, Windows NT / 2000 / XP'de -
Bilgisayarım'a sağ tıklayıp Özellikler'i, ardından Gelişmiş'i ve ardından Ortam Değişkenleri'ni tıklayabilirsiniz. Ardından, PATH değerini güncellersiniz ve OK düğmesine basarsınız.
Unix'te (Solaris, Linux, vb.), SDK /usr/local/jdk1.5.0_20'de kuruluysa ve C kabuğunu kullanıyorsanız, aşağıdakileri .cshrc dosyanıza koyarsınız.
Unix'te (Solaris, Linux, vb.), SDK /usr/local/jdk1.5.0_20'de kuruluysa ve C kabuğunu kullanıyorsanız, aşağıdakileri .cshrc dosyanıza koyarsınız.
setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20Alternatif olarak, Borland JBuilder, Eclipse, IntelliJ IDEA veya Sun ONE Studio gibi bir Entegre Geliştirme Ortamı (IDE) kullanıyorsanız, IDE'nin Java'yı nereye yüklediğinizi bildiğini doğrulamak için basit bir program derleyin ve çalıştırın; aksi takdirde, verilen IDE belgesi.
Adım 2 - Apache Tomcat'i Kurun
Tomcat'in son sürümünü şu adresten indirebilirsiniz: https://tomcat.apache.org/. Kurulumu indirdikten sonra, ikili dağıtımı uygun bir konuma açın.
Örneğin, Windows'ta C: \ apache-tomcat-6.0.33'te veya Linux / Unix'te /usr/local/apachetomcat-6.0.33'te ve bu konumlara işaret eden CATALINA_HOME ortam değişkenini oluşturun.
Windows makinesinde aşağıdaki komutları uygulayarak Tomcat'i başlatabilir veya sadece startup.bat üzerine çift tıklayabilirsiniz.
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-6.0.33\bin\startup.batTomcat, Unix (Solaris, Linux, vb.) Makinesinde aşağıdaki komutlar çalıştırılarak başlatılabilir -
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-6.0.33/bin/startup.shBaşarılı bir başlangıçtan sonra, Tomcat ile birlikte gelen varsayılan web uygulamaları şu adrese ziyaret edilerek kullanılabilir olacaktır: http://localhost:8080/. Her şey yolundaysa, aşağıdaki sonucu göstermelidir -
Tomcat'in yapılandırılması ve çalıştırılması hakkında daha fazla bilgi, burada yer alan belgelerde ve Tomcat web sitesinde bulunabilir: https://tomcat.apache.org/
Tomcat, Windows makinesinde aşağıdaki komutlar çalıştırılarak durdurulabilir -
%CATALINA_HOME%\bin\shutdown
or
C:\apache-tomcat-5.5.29\bin\shutdownTomcat, Unix (Solaris, Linux, vb.) Makinesinde aşağıdaki komutlar çalıştırılarak durdurulabilir -
$CATALINA_HOME/bin/shutdown.sh
or
/usr/local/apache-tomcat-5.5.29/bin/shutdown.shAdım 3 - Eclipse'i (IDE) Kurun
Bu eğitimdeki tüm örnekler Eclipse IDE kullanılarak yazılmıştır. Makinenizde Eclipse'in son sürümünün kurulu olmasını öneririm.
Eclipse'i yüklemek için En son Eclipse ikili dosyalarını indirin https://www.eclipse.org/downloads/. Kurulumu indirdikten sonra, ikili dağıtımı uygun bir konuma açın.
Örneğin, Windows'ta C: \ eclipse'de veya Linux / Unix'te / usr / local / eclipse'de ve son olarak PATH değişkenini uygun şekilde ayarlayın. Eclipse, Windows makinesinde aşağıdaki komutları çalıştırarak başlatılabilir veya eclipse.exe dosyasına çift tıklayabilirsiniz.
%C:\eclipse\eclipse.exeEclipse, Unix (Solaris, Linux, vb.) Makinesinde aşağıdaki komutlar çalıştırılarak başlatılabilir -
$/usr/local/eclipse/eclipseBaşarılı bir başlangıçtan sonra, her şey yolundaysa, aşağıdaki sonucu göstermelidir -
Adım 4 - Struts2 Kitaplıklarının Kurulumu
Şimdi her şey yolundaysa, Struts2 çerçevenizi kurmaya devam edebilirsiniz. Aşağıda, makinenize Struts2'yi indirip kurmak için basit adımlar verilmiştir.
Struts2'yi Windows'a mı yoksa Unix'e mi yüklemek istediğinizi seçin ve ardından Windows için .zip dosyasını ve Unix için .tz dosyasını indirmek için bir sonraki adıma geçin.
Struts2 ikili dosyalarının en son sürümünü şuradan indirin: https://struts.apache.org/download.cgi.
Bu öğreticiyi yazarken, indirdim struts-2.0.14-all.zip ve indirilen dosyayı açtığınızda, size aşağıdaki gibi C: \ struts-2.2.3 içinde dizin yapısını verecektir.
İkinci adım, zip dosyasını herhangi bir konuma çıkarmak, indirdim ve çıkardım struts-2.2.3-all.zip içinde c:\ Windows 7 makinemdeki klasör, böylece tüm jar dosyalarına sahibim C:\struts-2.2.3\lib. CLASSPATH değişkeninizi doğru şekilde ayarladığınızdan emin olun, aksi takdirde uygulamanızı çalıştırırken sorun yaşarsınız.
Yüksek bir seviyeden, Struts2 bir çekme MVC (veya MVC2) çerçevesidir. Struts2'deki Model-ViewController modeli aşağıdaki beş temel bileşenle uygulanmaktadır -
- Actions
- Interceptors
- Değer Yığını / OGNL
- Sonuçlar / Sonuç türleri
- Teknolojileri görüntüleyin
Struts 2 bazı örtüşmeler olsa da, eylemin kontrolör yerine model rolünü üstlendiği geleneksel bir MVC çerçevesinden biraz farklıdır.
Yukarıdaki şema, Model View ve CStruts2 üst düzey mimarisine denetleyici. Kontrolör birStruts2sunucu uygulaması filtresinin yanı sıra durdurucular da, bu model eylemlerle uygulanır ve görünüm, sonuç türleri ve sonuçların bir kombinasyonudur. Değer yığını ve OGNL, ortak iş parçacığı, bağlantı ve diğer bileşenler arasında entegrasyon sağlar.
Yukarıdaki bileşenlerin yanı sıra, konfigürasyonla ilgili birçok bilgi olacaktır. Web uygulaması için konfigürasyonun yanı sıra eylemler, önleyiciler, sonuçlar vb. İçin konfigürasyon.
Bu, Struts 2 MVC modelinin mimari genel görünümüdür. Sonraki bölümlerde her bir bileşeni daha ayrıntılı olarak inceleyeceğiz.
Yaşam Döngüsü İste
Yukarıdaki diyagrama dayanarak, iş akışını kullanıcının talep yaşam döngüsü boyunca anlayabilirsiniz. Struts 2 aşağıdaki gibi -
Kullanıcı, bazı kaynakların (yani sayfalar) talep edilmesi için sunucuya bir istek gönderir.
Filtre Dağıtıcı isteğe bakar ve ardından uygun Eylemi belirler.
Doğrulama, dosya yükleme vb. Gibi yapılandırılmış durdurucu işlevleri geçerlidir.
Seçilen işlem, istenen işleme göre gerçekleştirilir.
Yine, gerekirse herhangi bir son işlem yapmak için yapılandırılmış durdurucular uygulanır.
Son olarak sonuç görünüm tarafından hazırlanır ve sonucu kullanıcıya döndürür.
Struts 2 mimarisinden zaten öğrendiğiniz gibi, bir hiperlinke tıkladığınızda veya bir Struts 2 web uygulamasında bir HTML formu gönderdiğinizde, girdi Denetleyici tarafından toplanır ve bu da Eylemler adı verilen bir Java sınıfına gönderilir. Eylem yürütüldükten sonra, bir sonuç, yanıtı oluşturmak için bir kaynak seçer. Kaynak genellikle bir JSP'dir, ancak aynı zamanda bir PDF dosyası, bir Excel elektronik tablosu veya bir Java uygulama penceresi de olabilir.
Geliştirme ortamınızı zaten oluşturduğunuzu varsayarsak. Şimdi, ilkimizi oluşturmaya devam edelimHello World Struts2proje. Bu projenin amacı, kullanıcının adını toplayan ve "Merhaba Dünya" ve ardından kullanıcı adını görüntüleyen bir web uygulaması oluşturmaktır.
Herhangi bir Struts 2 projesi için aşağıdaki dört bileşeni oluşturmamız gerekir -
| Sr.No | Bileşenler ve Açıklama |
|---|---|
| 1 | Action Tam iş mantığını içerecek ve kullanıcı, model ve görünüm arasındaki etkileşimi kontrol edecek bir eylem sınıfı oluşturun. |
| 2 | Interceptors Gerekirse durdurucular oluşturun veya mevcut engelleyicileri kullanın. Bu, Controller'ın bir parçasıdır. |
| 3 | View Girdi almak ve son mesajları sunmak için kullanıcıyla etkileşim kurmak için bir JSP oluşturun. |
| 4 | Configuration Files Eylem, Görünüm ve Denetleyicileri birleştirmek için yapılandırma dosyaları oluşturun. Bu dosyalar struts.xml, web.xml, struts.properties'dir. |
Eclipse IDE'yi kullanacağım, böylece gerekli tüm bileşenler Dinamik Web Projesi altında oluşturulacak. Şimdi Dinamik Web Projesi oluşturmaya başlayalım.
Dinamik Web Projesi Oluşturun
Eclipse'inizi başlatın ve ardından gidin File > New > Dynamic Web Project ve proje adını şu şekilde girin: HelloWorldStruts2 ve aşağıdaki ekranda verilen seçeneklerin geri kalanını ayarlayın -
Sonraki ekranlarda tüm varsayılan seçenekleri seçin ve son olarak kontrol edin Generate Web.xml deployment descriptorseçeneği. Bu, Eclipse'de sizin için dinamik bir web projesi oluşturacaktır. Şimdi ile gitWindows > Show View > Project Explorerve proje pencerenizi aşağıdaki gibi göreceksiniz -
Şimdi aşağıdaki dosyaları struts 2 lib klasöründen kopyalayın C:\struts-2.2.3\lib projemize WEB-INF\libKlasör. Bunu yapmak için, aşağıdaki tüm dosyaları WEB-INF \ lib klasörüne sürükleyip bırakmanız yeterlidir.
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
Eylem Sınıfı Oluşturun
Eylem sınıfı, Struts 2 uygulamasının anahtarıdır ve iş mantığının çoğunu eylem sınıfında uygularız. Öyleyse HelloWorldAction.java altında bir java dosyası oluşturalım.Java Resources > src paket adı ile com.tutorialspoint.struts2 aşağıda verilen içeriklerle.
Action sınıfı, kullanıcı bir URL'yi tıkladığında bir kullanıcı eylemine yanıt verir. Action sınıfının yöntemlerinden biri veya daha fazlası çalıştırılır ve bir String sonucu döndürülür. Sonucun değerine bağlı olarak, belirli bir JSP sayfası oluşturulur.
package com.tutorialspoint.struts2;
public class HelloWorldAction {
private String name;
public String execute() throws Exception {
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Bu, "ad" adlı bir özelliği olan çok basit bir sınıftır. "Name" özelliği için standart alıcılara ve ayarlayıcı yöntemlere ve "başarı" dizesini döndüren bir yürütme yöntemine sahibiz.
Struts 2 çerçevesi, HelloWorldActionsınıf ve bir kullanıcının eylemine yanıt olarak yürütülen yöntemi çağırın. İş mantığınızı, sonunda String sabitini döndüren bu yöntemin içine koyarsınız. Diğer bir deyişle, her URL için bir eylem sınıfı uygulamanız gerekir ve bu sınıf adını doğrudan eylem adınız olarak kullanabilir veya aşağıda gösterildiği gibi struts.xml dosyasını kullanarak başka bir adla eşleyebilirsiniz.
Görünüm Oluşturun
Son mesajı sunmak için bir JSP'ye ihtiyacımız var, bu sayfa önceden tanımlanmış bir eylem gerçekleştiğinde Struts 2 çerçevesi tarafından çağrılacak ve bu eşleme struts.xml dosyasında tanımlanacak. Öyleyse aşağıdaki jsp dosyasını oluşturalımHelloWorld.jsptutulma projenizdeki WebContent klasöründe. Bunu yapmak için proje gezgininde WebContent klasörüne sağ tıklayın veNew >JSP File.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>Taglib yönergesi, Servlet kapsayıcısına bu sayfanın Struts 2 etiketleri ve bu etiketlerin önünde s.
S: özellik etiketi, yöntem tarafından döndürülen "name> eylem sınıfı özelliğinin değerini görüntüler getName() HelloWorldAction sınıfının.
Ana Sayfa Oluştur
Ayrıca yaratmalıyız index.jspWebContent klasöründe. Bu dosya, bir kullanıcının Struts 2 çerçevesine HelloWorldAction sınıfının tanımlanmış bir yöntemini çağırmasını ve HelloWorld.jsp görünümünü oluşturmasını söylemek için tıklatabileceği ilk eylem URL'si olarak hizmet edecektir.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>helloYukarıdaki görünüm dosyasında tanımlanan eylem, struts.xml dosyası kullanılarak HelloWorldAction sınıfına ve yürütme yöntemine eşlenecektir. Bir kullanıcı Gönder düğmesine tıkladığında, Struts 2 çerçevesinin HelloWorldAction sınıfında tanımlanan yürütme yöntemini çalıştırmasına neden olur ve yöntemin döndürülen değerine bağlı olarak, uygun bir görünüm seçilecek ve yanıt olarak işlenecektir.
Yapılandırma Dosyaları
URL'yi, HelloWorldAction sınıfını (Model) ve HelloWorld.jsp'yi (görünüm) birbirine bağlamak için bir eşlemeye ihtiyacımız var. Eşleme, Struts 2 çerçevesine hangi sınıfın kullanıcının eylemine (URL) yanıt vereceğini, bu sınıfın hangi yönteminin çalıştırılacağını ve yöntemin döndürdüğü String sonucuna göre hangi görünümün oluşturulacağını söyler.
Öyleyse adlı bir dosya oluşturalım struts.xml. Struts 2, sınıflar klasöründe struts.xml'nin bulunmasını gerektirdiğinden. Bu nedenle, WebContent / WEB-INF / classes klasörü altında struts.xml dosyası oluşturun. Eclipse varsayılan olarak "sınıflar" klasörünü oluşturmaz, bu nedenle bunu kendiniz yapmanız gerekir. Bunu yapmak için proje gezgininde WEB-INF klasörüne sağ tıklayın veNew > Folder. Struts.xml dosyanız şöyle görünmelidir -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Yukarıdaki konfigürasyon dosyası ile ilgili anlaşılması gereken birkaç kelime. Burada sabiti belirliyoruzstruts.devMode -e trueçünkü geliştirme ortamında çalışıyoruz ve bazı yararlı günlük mesajları görmemiz gerekiyor. Ardından adında bir paket tanımlıyoruzhelloworld.
Bir paket oluşturmak, eylemlerinizi birlikte gruplamak istediğinizde kullanışlıdır. Örneğimizde, URL'ye karşılık gelen eylemimizi "merhaba" olarak adlandırdık/hello.action ve tarafından yedeklenirHelloWorldAction.class. execute yöntemi HelloWorldAction.class URL olduğunda çalıştırılan yöntemdir /hello.actionçağrılır. Yürütme yönteminin sonucu "başarılı" döndürürse, kullanıcıyıHelloWorld.jsp.
Sonraki adım, bir web.xmlStruts 2'ye herhangi bir istek için bir giriş noktası olan dosya. Struts2 uygulamasının giriş noktası, dağıtım tanımlayıcısında (web.xml) tanımlanan bir filtre olacaktır. Bu nedenle, web.xml'de org.apache.struts2.dispatcher.FilterDispatcher sınıfı girişini tanımlayacağız. Web.xml dosyasının WebContent altındaki WEB-INF klasörü altında oluşturulması gerekir. Eclipse, projeyi oluşturduğunuzda sizin için zaten bir iskelet web.xml dosyası oluşturmuştu. Öyleyse, aşağıdaki gibi değiştirelim -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>İndex.jsp'yi hoş geldiniz dosyamız olarak belirledik. Ardından, Struts2 filtresini tüm url'lerde çalışacak şekilde yapılandırdık (yani / * kalıbıyla eşleşen herhangi bir url)
Ayrıntılı Günlüğü Etkinleştirmek İçin
Struts 2 ile çalışırken tam günlük tutma işlevini oluşturarak etkinleştirebilirsiniz. logging.properties altında dosya WEB-INF/classesKlasör. Mülk dosyanızda aşağıdaki iki satırı tutun -
org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = \
java.util.logging.ConsoleHandlerVarsayılan logging.properties, günlük kaydını stdout'a yönlendirmek için bir ConsoleHandler ve ayrıca bir FileHandler belirtir. Bir işleyicinin günlük seviyesi eşiği CİDDİ, UYARI, BİLGİ, YAPILANDIRMA, HASSAS, DAHA HASSAS, HASSAS veya TÜMÜ kullanılarak ayarlanabilir.
Bu kadar. Struts 2 çerçevesini kullanarak Hello World uygulamamızı çalıştırmaya hazırız.
Başvuruyu Yürütme Prosedürü
Proje adına sağ tıklayın ve tıklayın Export > WAR File Savaş dosyası oluşturmak için.
Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin.
Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyin http://localhost:8080/HelloWorldStruts2/index.jsp. Bu size aşağıdaki ekranı verecektir -
"Struts2" değerini girin ve sayfayı gönderin. Bir sonraki sayfayı görmelisin
Tanımlayabileceğinizi unutmayın index struts.xml dosyasında bir eylem olarak ve bu durumda dizin sayfasını şu şekilde çağırabilirsiniz: http://localhost:8080/HelloWorldStruts2/index.action. Aşağıda dizini bir eylem olarak nasıl tanımlayabileceğinizi kontrol edin -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "index">
<result >/index.jsp</result>
</action>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Bu bölüm sizi, bir güvenlik için gerekli olan temel yapılandırmaya götürecektir. Struts 2uygulama. Burada, birkaç önemli yapılandırma dosyası yardımıyla nelerin yapılandırılabileceğini göreceğiz.web.xml, struts.xml, strutsconfig.xml ve struts.properties
Dürüst olmak gerekirse, yalnızca kullanarak çalışmaya başlayabilirsiniz web.xml ve struts.xmlyapılandırma dosyaları (örneğimizin bu iki dosyayı kullanarak çalıştığı önceki bölümümüzde daha önce gördüğünüz gibi). Bununla birlikte, bilginiz için diğer dosyalar hakkında da açıklayacağız.
Web.xml Dosyası
Web.xml yapılandırma dosyası, HTTP isteği öğelerinin sunucu uygulaması konteyneri tarafından nasıl işleneceğini belirleyen bir J2EE yapılandırma dosyasıdır. Kesinlikle bir Struts2 yapılandırma dosyası değildir, ancak Struts2'nin çalışması için yapılandırılması gereken bir dosyadır.
Daha önce tartışıldığı gibi, bu dosya herhangi bir web uygulaması için bir giriş noktası sağlar. Struts2 uygulamasının giriş noktası, dağıtım tanımlayıcısında (web.xml) tanımlanan bir filtre olacaktır. Bu nedenle web.xml'de FilterDispatcher sınıfı için bir giriş tanımlayacağız . Web.xml dosyasının klasör altında oluşturulması gerekir.WebContent/WEB-INF.
Bu, onu oluşturan bir şablon veya aracın (Eclipse veya Maven2 gibi) yardımı olmadan başlıyorsanız, yapılandırmanız gereken ilk yapılandırma dosyasıdır.
Son örneğimizde kullandığımız web.xml dosyasının içeriği aşağıdadır.
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Struts 2 filtresini şu şekilde eşleştirdiğimize dikkat edin: /*ve değil /*.actionbu, tüm url'lerin dikmeler filtresi tarafından ayrıştırılacağı anlamına gelir. Ek Açıklamalar bölümüne geçerken bunu ele alacağız.
Struts.xml Dosyası
struts.xmldosyası, eylemler geliştirilirken değiştireceğiniz yapılandırma bilgilerini içerir. Bu dosya, bir uygulama için varsayılan ayarları geçersiz kılmak için kullanılabilir, örneğin struts.devMode = false ve özellik dosyasında tanımlanan diğer ayarlar. Bu dosya klasörün altında oluşturulabilirWEB-INF/classes.
Önceki bölümde açıklanan Merhaba Dünya örneğinde oluşturduğumuz struts.xml dosyasına bir göz atalım.
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
<-- more actions can be listed here -->
</package>
<-- more packages can be listed here -->
</struts>Dikkat edilmesi gereken ilk şey, DOCTYPE. Tüm struts yapılandırma dosyasının küçük örneğimizde gösterildiği gibi doğru belge türüne sahip olması gerekir. <struts>, altında <package> etiketleri kullanarak farklı paketleri açıkladığımız kök etiket öğesidir. Burada <package>, yapılandırmanın ayrılmasına ve modülerleştirilmesine izin verir. Bu, büyük bir projeniz olduğunda ve proje farklı modüllere bölündüğünde çok kullanışlıdır.
Örneğin, projenizde üç etki alanı varsa - business_application, customer_application ve staff_application, o zaman üç paket oluşturabilir ve ilişkili eylemleri uygun pakette depolayabilirsiniz.
Paket etiketi aşağıdaki özniteliklere sahiptir -
| Sr.No | Öznitelik ve Açıklama |
|---|---|
| 1 | name (required) Paket için benzersiz tanımlayıcı |
| 2 | extends Bu paket hangi paketten geliyor? Varsayılan olarak, temel paket olarak struts-default kullanırız. |
| 3 | abstract Doğru olarak işaretlenmişse, paket son kullanıcı tüketimi için mevcut değildir. |
| 4 | namespace Eylemler için benzersiz ad alanı |
constant ad ve değer nitelikleri ile birlikte etiket, aşağıdaki özelliklerden herhangi birini geçersiz kılmak için kullanılmalıdır: default.properties, az önce belirlediğimiz gibi struts.devModeEmlak. Ayarstruts.devMode özelliği, günlük dosyasında daha fazla hata ayıklama iletisi görmemizi sağlar.
Biz tanımlıyoruz action etiketler, erişmek istediğimiz her URL'ye karşılık gelir ve ilgili URL'ye her eriştiğimizde erişilecek olan execute () yöntemiyle bir sınıf tanımlarız.
Sonuçlar, bir eylem gerçekleştirildikten sonra tarayıcıya neyin döndürüleceğini belirler. Eylemden döndürülen dize, bir sonucun adı olmalıdır. Sonuçlar, yukarıdaki gibi eylem başına veya bir paketteki her eylem için mevcut olan "genel" sonuç olarak yapılandırılır. Sonuçlar isteğe bağlıdırname ve typeÖznitellikler. Varsayılan ad değeri "başarılı" dır.
Struts.xml dosyası zamanla büyüyebilir ve bu nedenle onu paketler halinde bölmek, onu modülerleştirmenin bir yoludur, ancak Strutsstruts.xml dosyasını modülerleştirmenin başka bir yolunu sunar. Dosyayı birden çok xml dosyasına bölebilir ve aşağıdaki şekilde içe aktarabilirsiniz.
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="my-struts1.xml"/>
<include file="my-struts2.xml"/>
</struts>Kapsanmadığımız diğer yapılandırma dosyası struts-default.xml'dir. Bu dosya, Struts için standart yapılandırma ayarlarını içerir ve projelerinizin% 99,99'u için bu ayarlara dokunmanız gerekmez. Bu nedenle bu dosya üzerinde çok fazla detaya girmiyoruz. Eğer ilgileniyorsanız, şuraya bir göz atın:default.properties dosya struts2-core-2.2.3.jar dosyasında mevcuttur.
Struts-config.xml Dosyası
Struts-config.xml yapılandırma dosyası, Web İstemcisindeki Görünüm ve Model bileşenleri arasında bir bağlantıdır, ancak projelerinizin% 99,99'u için bu ayarlara dokunmanız gerekmez.
Yapılandırma dosyası temel olarak aşağıdaki ana öğeleri içerir -
| Sr.No | Durdurucu ve Açıklama |
|---|---|
| 1 | struts-config Bu, yapılandırma dosyasının kök düğümüdür. |
| 2 | form-beans Burası, ActionForm alt sınıfınızı bir adla eşlediğiniz yerdir. Bu adı, strutsconfig.xml dosyasının geri kalanında ve hatta JSP sayfalarınızda ActionForm'unuz için bir takma ad olarak kullanırsınız. |
| 3 | global forwards Bu bölüm, web uygulamanızdaki bir sayfayı bir adla eşler. Gerçek sayfaya başvurmak için bu adı kullanabilirsiniz. Bu, web sayfalarınızda URL'lerin kodlanmasını önler. |
| 4 | action-mappings Bu, form işleyicilerini açıkladığınız yerdir ve bunlar aynı zamanda eylem eşlemeleri olarak da bilinir. |
| 5 | controller Bu bölüm, Struts iç kısımlarını yapılandırır ve pratik durumlarda nadiren kullanılır. |
| 6 | plug-in Bu bölüm Struts'a bilgi istemleri ve hata mesajları içeren özellikler dosyalarınızı nerede bulacağını söyler. |
Örnek struts-config.xml dosyası aşağıdadır -
<?xml version = "1.0" Encoding = "ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.0//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">
<struts-config>
<!-- ========== Form Bean Definitions ============ -->
<form-beans>
<form-bean name = "login" type = "test.struts.LoginForm" />
</form-beans>
<!-- ========== Global Forward Definitions ========= -->
<global-forwards>
</global-forwards>
<!-- ========== Action Mapping Definitions ======== -->
<action-mappings>
<action
path = "/login"
type = "test.struts.LoginAction" >
<forward name = "valid" path = "/jsp/MainMenu.jsp" />
<forward name = "invalid" path = "/jsp/LoginView.jsp" />
</action>
</action-mappings>
<!-- ========== Controller Definitions ======== -->
<controller contentType = "text/html;charset = UTF-8"
debug = "3" maxFileSize = "1.618M" locale = "true" nocache = "true"/>
</struts-config>Struts-config.xml dosyası hakkında daha fazla ayrıntı için lütfen struts belgelerinize bakın.
Struts.properties Dosyası
Bu yapılandırma dosyası, çerçevenin varsayılan davranışını değiştirmek için bir mekanizma sağlar. Aslında, içindeki tüm özelliklerstruts.properties yapılandırma dosyası da yapılandırılabilir web.xml kullanmak init-paramve sabit etiketini kullanarak struts.xmlyapılandırma dosyası. Ancak, her şeyi ayrı tutmak ve daha fazla özelliğe sahip olmak isterseniz, bu dosyayı klasörün altında oluşturabilirsiniz.WEB-INF/classes.
Bu dosyada yapılandırılan değerler, şurada yapılandırılan varsayılan değerleri geçersiz kılar: default.propertiesstruts2-core-xyzjar dağıtımında bulunan. Kullanarak değiştirmeyi düşünebileceğiniz birkaç özellik vardır.struts.properties dosya -
### When set to true, Struts will act much more friendly for developers
struts.devMode = true
### Enables reloading of internationalization files
struts.i18n.reload = true
### Enables reloading of XML configuration files
struts.configuration.xml.reload = true
### Sets the port that the server is run on
struts.url.http.port = 8080Burada ile başlayan herhangi bir satır hash (#) bir yorum olarak kabul edilecek ve tarafından yok sayılacaktır Struts 2.
Actionsherhangi bir MVC (Model View Controller) çerçevesi için olduğu gibi, Struts2 çerçevesinin çekirdeğidir. Her URL, kullanıcıdan gelen talebe hizmet vermek için gerekli olan işleme mantığını sağlayan belirli bir eylemle eşleştirilir.
Ancak eylem aynı zamanda iki önemli kapasiteye daha hizmet ediyor. İlk olarak, ister JSP isterse başka bir sonuç türü olsun, eylem, istekten görünüme veri aktarımında önemli bir rol oynar. İkinci olarak, işlem, isteğe yanıtta döndürülecek olan görünümü hangi sonucun oluşturması gerektiğini belirlemede çerçeveye yardımcı olmalıdır.
Eylem Oluştur
Eylemler için tek gereklilik Struts2String veya Result nesnesini döndüren ve POJO olması gereken tek bir noargument yöntemi olması gerektiğidir. Argüman yok yöntemi belirtilmezse, varsayılan davranış execute () yöntemini kullanmaktır.
İsteğe bağlı olarak uzatabilirsiniz ActionSupport dahil altı arabirimi uygulayan sınıf Actionarayüz. Eylem arayüzü aşağıdaki gibidir -
public interface Action {
public static final String SUCCESS = "success";
public static final String NONE = "none";
public static final String ERROR = "error";
public static final String INPUT = "input";
public static final String LOGIN = "login";
public String execute() throws Exception;
}Merhaba Dünya örneğindeki eylem yöntemine bir göz atalım -
package com.tutorialspoint.struts2;
public class HelloWorldAction {
private String name;
public String execute() throws Exception {
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Eylem yönteminin görünümü kontrol ettiği noktayı göstermek için, aşağıdaki değişikliği yapalım. execute yöntemini seçin ve ActionSupport sınıfını aşağıdaki gibi genişletin -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
if ("SECRET".equals(name)) {
return SUCCESS;
} else {
return ERROR;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Bu örnekte, execute yönteminde name özniteliğine bakmak için bazı mantığımız var. Öznitelik dizeye eşitse"SECRET", Geri döndük SUCCESS sonuç olarak aksi takdirde geri döneriz ERRORsonuç olarak. ActionSupport'u genişlettiğimiz için, String sabitlerini kullanabilirizSUCCESSve HATA. Şimdi struts.xml dosyamızı aşağıdaki gibi değiştirelim -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>Görünüm Oluşturun
Aşağıdaki jsp dosyasını oluşturalım HelloWorld.jsptutulma projenizdeki WebContent klasöründe. Bunu yapmak için proje gezgininde WebContent klasörüne sağ tıklayın veNew >JSP File. Bu dosya, dönüş sonucunun, Eylem arayüzünde tanımlandığı gibi bir String sabiti "başarı" olan BAŞARILI olması durumunda çağrılacaktır -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>Aşağıda, eylem sonucunun ERROR olması durumunda çerçeve tarafından çağrılacak olan dosya, String sabiti "error" a eşittir. Aşağıdakilerin içeriğiAccessDenied.jsp
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Access Denied</title>
</head>
<body>
You are not authorized to view this page.
</body>
</html>Ayrıca yaratmalıyız index.jspWebContent klasöründe. Bu dosya, kullanıcının Struts 2 çerçevesine şunu çağırmasını söylemek için tıklayabileceği ilk eylem URL'si olarak hizmet edecektir.executeHelloWorldAction sınıfının yöntemini ve HelloWorld.jsp görünümünü işleyin.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>İşte bu, web.xml dosyası için herhangi bir değişiklik gerekmiyor, öyleyse içinde oluşturduğumuz web.xml ile aynı kullanalım. Examplesbölüm. Şimdi, çalıştırmaya hazırızHello World Struts 2 çerçevesini kullanarak uygulama.
Uygulamayı yürütün
Proje adına sağ tıklayın ve tıklayın Export > WARSavaş dosyası oluşturmak için dosya. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu size aşağıdaki ekranı verecektir -
"GİZLİ" olarak bir kelime girelim ve aşağıdaki sayfayı görmelisiniz -
Şimdi "SECRET" dışında herhangi bir kelime girin ve aşağıdaki sayfayı görmelisiniz -
Birden Çok Eylem Oluşturun
Farklı istekleri ele almak ve kullanıcılara farklı URL'ler sağlamak için sıklıkla birden fazla eylem tanımlayacaksınız, buna göre aşağıda tanımlandığı gibi farklı sınıflar tanımlayacaksınız -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
class MyAction extends ActionSupport {
public static String GOOD = SUCCESS;
public static String BAD = ERROR;
}
public class HelloWorld extends ActionSupport {
...
public String execute() {
if ("SECRET".equals(name)) return MyAction.GOOD;
return MyAction.BAD;
}
...
}
public class SomeOtherClass extends ActionSupport {
...
public String execute() {
return MyAction.GOOD;
}
...
}Bu eylemleri struts.xml dosyasında aşağıdaki gibi yapılandıracaksınız -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorld"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
<action name = "something"
class = "com.tutorialspoint.struts2.SomeOtherClass"
method = "execute">
<result name = "success">/Something.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>Yukarıdaki varsayımsal örnekte görebileceğiniz gibi, eylem sonuçları SUCCESS ve ERROR’s kopyalanır.
Bu sorunu aşmak için, sonuç sonuçlarını içeren bir sınıf oluşturmanız önerilir.
Durdurucular kavramsal olarak sunucu uygulaması filtreleri veya JDKs Proxy sınıfıyla aynıdır. Durdurucular, çapraz kesim işlevinin hem eylemden hem de çerçeveden ayrı olarak uygulanmasına izin verir. Önleyiciler kullanarak aşağıdakileri elde edebilirsiniz -
Eylem çağrılmadan önce ön işleme mantığının sağlanması.
İşlem çağrıldıktan sonra son işlem mantığının sağlanması.
Alternatif işlemlerin gerçekleştirilebilmesi için istisnaların yakalanması.
Sağlanan özelliklerin çoğu Struts2 çerçeve, engelleyiciler kullanılarak uygulanır;
Examples istisna işleme, dosya yükleme, yaşam döngüsü geri aramaları, vb. içerir. Aslında, Struts2 işlevlerinin çoğunu önleyiciler üzerinde vurguladığından, eylem başına atanmış 7 veya 8 engelleyiciye sahip olma olasılığı düşüktür.
Struts2 Çerçeve Durdurucular
Struts 2 çerçevesi, önceden yapılandırılmış ve kullanıma hazır olarak gelen kullanıma hazır durdurucuların iyi bir listesini sağlar. Önemli engelleyicilerden birkaçı aşağıda listelenmiştir -
| Sr.No | Durdurucu ve Açıklama |
|---|---|
| 1 | alias Parametrelerin istekler arasında farklı ad takma adlarına sahip olmasına izin verir. |
| 2 | checkbox İşaretlenmemiş onay kutuları için bir parametre değeri false ekleyerek, onay kutularının yönetilmesine yardımcı olur. |
| 3 | conversionError Dizeleri parametre türlerine dönüştürmekten gelen hata bilgilerini eylemin alan hatalarına yerleştirir. |
| 4 | createSession Zaten mevcut değilse, otomatik olarak bir HTTP oturumu oluşturur. |
| 5 | debugging Geliştiriciye birkaç farklı hata ayıklama ekranı sağlar. |
| 6 | execAndWait Eylem arka planda yürütülürken kullanıcıyı bir ara bekleme sayfasına gönderir. |
| 7 | exception Bir eylemden bir sonuca atılan istisnaları eşler ve yönlendirme yoluyla otomatik istisna işlemeye izin verir. |
| 8 | fileUpload Kolay dosya yüklemeyi kolaylaştırır. |
| 9 | i18n Bir kullanıcının oturumu sırasında seçilen yerel ayarı takip eder. |
| 10 | logger Yürütülen eylemin adının çıktısını alarak basit günlük kaydı sağlar. |
| 11 | params Eylemdeki istek parametrelerini ayarlar. |
| 12 | prepare Bu, genellikle kurulum veritabanı bağlantıları gibi ön işleme çalışmaları yapmak için kullanılır. |
| 13 | profile Eylemler için basit profil bilgilerinin günlüğe kaydedilmesine izin verir. |
| 14 | scope Eylemin durumunu oturum veya uygulama kapsamında depolar ve alır. |
| 15 | ServletConfig Eyleme, çeşitli sunucu uygulaması tabanlı bilgilere erişim sağlar. |
| 16 | timer Eylemin yürütülmesinin ne kadar süreceği şeklinde basit profil bilgileri sağlar. |
| 17 | token Yinelenen form gönderimini önlemek için geçerli bir belirteç için eylemi denetler. |
| 18 | validation Eylemler için doğrulama desteği sağlar |
Yukarıda belirtilen durdurucularla ilgili tüm ayrıntılar için lütfen Struts 2 belgelerine bakın. Ancak size Struts uygulamanızda genel olarak bir durdurucuyu nasıl kullanacağınızı göstereceğim.
Durdurucular Nasıl Kullanılır?
"Merhaba Dünya" programımızda zaten var olan bir önleyiciyi nasıl kullanacağımızı görelim. KullanacağıztimerBir eylem yönteminin uygulanmasının ne kadar sürdüğünü ölçmeyi amaçlayan engelleyici. Aynı zamanda kullanıyorumparamseylemin amacı istek parametrelerini göndermek olan engelleyici. Örneğinizi bu kesiciyi kullanmadan deneyebilirsiniz ve bunu bulacaksınızname özellik, parametre eyleme erişemediği için ayarlanmıyor.
HelloWorldAction.java, web.xml, HelloWorld.jsp ve index.jsp dosyalarını oluşturulduğu gibi saklayacağız. Examples bölümü değiştirelim ama struts.xml aşağıdaki gibi bir engelleyici eklemek için dosya -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<interceptor-ref name = "params"/>
<interceptor-ref name = "timer" />
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Proje adına sağ tıklayın ve tıklayın Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Şimdi verilen metin kutusuna herhangi bir kelime girin ve tanımlanan eylemi yürütmek için Merhaba Deyin düğmesine tıklayın. Şimdi, oluşturulan günlüğü kontrol ederseniz, aşağıdaki metni bulacaksınız -
INFO: Server startup in 3539 ms
27/08/2011 8:40:53 PM
com.opensymphony.xwork2.util.logging.commons.CommonsLogger info
INFO: Executed action [//hello!execute] took 109 ms.Burada alt satır, çünkü timer Eylemin gerçekleştirilmesi için toplam 109 ms sürdüğünü söyleyen önleme görevlisi.
Özel Durdurucular Oluşturun
Uygulamanızda özel durdurucular kullanmak, enine kesen uygulama özellikleri sağlamanın zarif bir yoludur. Özel bir durdurucu oluşturmak kolaydır; genişletilmesi gereken arayüz aşağıdaki gibidirInterceptor arayüz -
public interface Interceptor extends Serializable {
void destroy();
void init();
String intercept(ActionInvocation invocation)
throws Exception;
}Adlardan da anlaşılacağı gibi, init () yöntemi, engelleyiciyi başlatmak için bir yol sağlar ve destroy () yöntemi, engelleyici temizliği için bir olanak sağlar. Eylemlerin aksine, durdurucular istekler arasında yeniden kullanılır ve özellikle intercept () yöntemi olmak üzere iş parçacığı açısından güvenli olmaları gerekir.
ActionInvocationnesne, çalışma zamanı ortamına erişim sağlar. Eylemin kendisine ve yöntemlere, eylemi çağırmak ve eylemin zaten çağrılıp çağrılmadığını belirlemek için erişim sağlar.
Başlatma veya temizleme koduna ihtiyacınız yoksa, AbstractInterceptorsınıf uzatılabilir. Bu, init () ve destroy () yöntemlerinin varsayılan işlemsiz uygulamasını sağlar.
Interceptor Sınıfı Oluşturun
Aşağıdaki MyInterceptor.java dosyasını oluşturalım Java Resources > src klasör -
package com.tutorialspoint.struts2;
import java.util.*;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
public class MyInterceptor extends AbstractInterceptor {
public String intercept(ActionInvocation invocation)throws Exception {
/* let us do some pre-processing */
String output = "Pre-Processing";
System.out.println(output);
/* let us call action or next interceptor */
String result = invocation.invoke();
/* let us do some post-processing */
output = "Post-Processing";
System.out.println(output);
return result;
}
}Fark ettiğiniz gibi, gerçek eylem durdurucu kullanılarak yürütülecektir. invocation.invoke()aramak. Böylece, ihtiyacınıza göre bazı ön işleme ve bazı son işlemler yapabilirsiniz.
Çerçeve, ActionInvocation nesnesinin invoke () öğesine ilk çağrıyı yaparak süreci başlatır. Her seferindeinvoke()çağrılır, ActionInvocation durumuna danışır ve daha sonra gelen engelleyiciyi yürütür. Yapılandırılan tüm durdurucular çağrıldığında, invoke () yöntemi eylemin kendisinin yürütülmesine neden olur.
Aşağıdaki şema, bir istek akışı aracılığıyla aynı kavramı göstermektedir -
Eylem Sınıfı Oluşturun
HelloWorldAction.java altında bir java dosyası oluşturalım Java Resources > src paket adı ile com.tutorialspoint.struts2 aşağıda verilen içeriklerle.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
System.out.println("Inside action....");
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Bu, önceki örneklerde gördüğümüzle aynı sınıftır. "Name" özelliği için standart alıcılara ve ayarlayıcı yöntemlere ve "başarı" dizesini döndüren bir yürütme yöntemine sahibiz.
Görünüm Oluşturun
Aşağıdaki jsp dosyasını oluşturalım HelloWorld.jsp tutulma projenizdeki WebContent klasöründe.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>Ana Sayfa Oluştur
Ayrıca yaratmalıyız index.jspWebContent klasöründe. Bu dosya, bir kullanıcının Struts 2 çerçevesine HelloWorldAction sınıfının tanımlı bir yöntemini çağırmasını ve HelloWorld.jsp görünümünü oluşturmasını söylemek için tıklatabileceği ilk eylem URL'si olarak hizmet edecektir.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>hello Yukarıdaki görünüm dosyasında tanımlanan eylem, struts.xml dosyası kullanılarak HelloWorldAction sınıfına ve yürütme yöntemine eşlenecektir.
Yapılandırma Dosyaları
Şimdi, önleyicimizi kaydetmemiz ve ardından önceki örnekte varsayılan engelleyici dediğimiz gibi çağırmamız gerekiyor. Yeni tanımlanmış bir engelleyiciyi kaydetmek için <interceptors> ... </interceptors> etiketleri doğrudan <package> etiketlerinin altına yerleştirilirstruts.xmldosya. Önceki örneğimizde yaptığımız gibi, varsayılan bir engelleyici için bu adımı atlayabilirsiniz. Ama burada kayıt olalım ve aşağıdaki gibi kullanalım -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<interceptors>
<interceptor name = "myinterceptor"
class = "com.tutorialspoint.struts2.MyInterceptor" />
</interceptors>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<interceptor-ref name = "params"/>
<interceptor-ref name = "myinterceptor" />
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>İçeride birden fazla durdurucu kaydedebileceğiniz unutulmamalıdır. <package> etiketleyin ve aynı anda birden fazla durdurucuyu çağırabilirsiniz. <action>etiket. Aynı durdurucuyu farklı eylemlerle çağırabilirsiniz.
Web.xml dosyasının WebContent altındaki WEB-INF klasörü altında aşağıdaki gibi oluşturulması gerekir -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Proje adına sağ tıklayın ve tıklayın Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Şimdi verilen metin kutusuna herhangi bir kelime girin ve tanımlanan eylemi yürütmek için Merhaba Deyin düğmesine tıklayın. Şimdi, oluşturulan günlüğü kontrol ederseniz, aşağıdaki metni altta bulacaksınız -
Pre-Processing
Inside action....
Post-ProcessingÇoklu Durdurucu İstifleme
Tahmin edebileceğiniz gibi, her eylem için birden fazla durdurucu yapılandırmak zorunda kalmak, hızla son derece yönetilemez hale gelir. Bu nedenle, durdurucular, önleme yığınları ile yönetilir. İşte doğrudan strutsdefault.xml dosyasından bir örnek -
<interceptor-stack name = "basicStack">
<interceptor-ref name = "exception"/>
<interceptor-ref name = "servlet-config"/>
<interceptor-ref name = "prepare"/>
<interceptor-ref name = "checkbox"/>
<interceptor-ref name = "params"/>
<interceptor-ref name = "conversionError"/>
</interceptor-stack>Yukarıdaki hisseye basicStackve aşağıda gösterildiği gibi yapılandırmanızda kullanılabilir. Bu yapılandırma düğümü, <paket ... /> düğümünün altına yerleştirilir. Her <interceptor-ref ... /> etiketi, bir durdurucuya veya geçerli engelleyici yığınından önce yapılandırılmış bir durdurucu yığınına başvurur. Bu nedenle, ilk durdurucuları ve durdurucu yığınlarını yapılandırırken adın tüm durdurucu ve durdurucu yığın yapılandırmalarında benzersiz olmasını sağlamak çok önemlidir.
Önleyiciyi eyleme nasıl uygulayacağımızı zaten görmüştük, durdurucu yığınları uygulamak farklı değil. Aslında, tamamen aynı etiketi kullanıyoruz -
<action name = "hello" class = "com.tutorialspoint.struts2.MyAction">
<interceptor-ref name = "basicStack"/>
<result>view.jsp</result>
</actionYukarıdaki "basicStack" kaydı, merhaba eylemi ile altı engelleyicinin tamamının hissesini kaydedecektir. Bu, durdurucuların yapılandırıldıkları sırayla yürütüldüğüne dikkat edilmelidir. Örneğin, yukarıdaki durumda, istisna ilk olarak yürütülecektir, ikincisi servlet-config vb. Olacaktır.
Daha önce bahsedildiği gibi, <results> etiketi bir viewStruts2 MVC çerçevesinde. Eylem, iş mantığını yürütmekten sorumludur. İş mantığını çalıştırdıktan sonraki adım, görünümü,<results> etiket.
Genellikle sonuçlara eklenmiş bazı gezinme kuralları vardır. Örneğin, eylem yöntemi bir kullanıcının kimliğini doğrulamaksa, üç olası sonuç vardır.
- Başarılı Giriş
- Başarısız Giriş - Yanlış kullanıcı adı veya şifre
- Hesap Kilitlendi
Bu senaryoda, eylem yöntemi, sonucu oluşturmak için üç olası sonuç dizesi ve üç farklı görünümle yapılandırılacaktır. Bunu daha önceki örneklerde görmüştük.
Ancak, Struts2 sizi JSP'yi görüntüleme teknolojisi olarak kullanmaya bağlamaz. Sonuçta, MVC paradigmasının tüm amacı, katmanları ayrı ve yüksek oranda yapılandırılabilir tutmaktır. Örneğin, bir Web2.0 istemcisi için çıktı olarak XML veya JSON döndürmek isteyebilirsiniz. Bu durumda, XML veya JSON için yeni bir sonuç türü oluşturabilir ve bunu başarabilirsiniz.
Dikmeler bir dizi önceden tanımlanmış result types ve daha önce gördüğümüz her ne ise, bu varsayılan sonuç tipiydi dispatcher, JSP sayfalarına göndermek için kullanılır. Struts, sonuçları sunmak için görünüm teknolojisinin diğer biçimlendirme dillerini kullanmanıza izin verir ve popüler seçenekler şunları içerir:Velocity, Freemaker, XSLT ve Tiles.
Dağıtıcı Sonuç Türü
dispatchersonuç türü varsayılan türdür ve başka bir sonuç türü belirtilmezse kullanılır. Sunucudaki bir sunucu uygulamasına, JSP'ye, HTML sayfasına vb. İletmek için kullanılır. RequestDispatcher.forward () yöntemini kullanır .
Sonuç etiketinin gövdesi olarak bir JSP yolu sağladığımız önceki örneklerimizde "steno" versiyonunu gördük.
<result name = "success">
/HelloWorld.jsp
</result>JSP dosyasını, <result ...> öğesi içinde bir <param name = "location"> etiketini kullanarak aşağıdaki gibi de belirtebiliriz -
<result name = "success" type = "dispatcher">
<param name = "location">
/HelloWorld.jsp
</param >
</result>Ayrıca bir parseparametresi, varsayılan olarak doğrudur. Ayrıştırma parametresi, konum parametresinin OGNL ifadeleri için ayrıştırılıp ayrıştırılmayacağını belirler.
FreeMaker Sonuç Türü
Bu örnekte, nasıl kullanabileceğimizi göreceğiz. FreeMakergörüntüleme teknolojisi olarak. Freemaker, önceden tanımlanmış şablonları kullanarak çıktı oluşturmak için kullanılan popüler bir şablon oluşturma motorudur. Şimdi bir Freemaker şablon dosyası oluşturalım.hello.fm aşağıdaki içeriklerle -
Hello World ${name}Yukarıdaki dosya bir şablondur. nametanımlanmış eylem kullanılarak dışarıdan iletilecek bir parametredir. Bu dosyayı CLASSPATH'inizde tutacaksınız.
Sonra, değiştirelim struts.xml sonucu aşağıdaki gibi belirtmek için -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "freemarker">
<param name = "location">/hello.fm</param>
</result>
</action>
</package>
</struts>HelloWorldAction.java, HelloWorldAction.jsp ve index.jsp dosyalarımızı örnekler bölümünde oluşturduğumuz gibi saklayalım.
Şimdi proje adına sağ tıklayın ve Export > WAR File Savaş dosyası oluşturmak için.
Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır.
"Struts2" değerini girin ve sayfayı gönderin. Bir sonraki sayfayı görmelisiniz.
Gördüğünüz gibi, bu, JSP görünümüyle tamamen aynı, tek fark biz görüntüleme teknolojisi olarak JSP'yi kullanmaya bağlı değiliz. Bu örnekte Freemaker'ı kullandık.
Yönlendirme Sonucu Türü
redirectsonuç türü, standart response.sendRedirect () yöntemini çağırarak tarayıcının verilen konuma yeni bir istek oluşturmasına neden olur.
Konumu <result ...> öğesinin gövdesinde veya <param name = "location"> öğesi olarak sağlayabiliriz. Yönlendirme ayrıcaparseparametre. İşte XML kullanılarak yapılandırılmış bir örnek -
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "redirect">
<param name = "location">
/NewWorld.jsp
</param >
</result>
</action>Bu nedenle, yukarıda belirtildiği gibi yönlendirme türünü tanımlamak için struts.xml dosyanızı değiştirin ve merhaba eylemi başarılı olduğunda yeniden yönlendirileceğiniz NewWorld.jpg adlı yeni bir dosya oluşturun. Daha iyi anlamak için Struts 2 Redirect Action örneğini inceleyebilirsiniz.
Değer Yığını
Değer yığını, aşağıdaki nesneleri verilen sırada tutan birkaç nesneden oluşan bir kümedir:
| Sr.No | Nesneler ve Açıklama |
|---|---|
| 1 | Temporary Objects Bir sayfanın yürütülmesi sırasında oluşturulan çeşitli geçici nesneler vardır. Örneğin, bir JSP etiketinde döngüye alınan bir koleksiyon için geçerli yineleme değeri. |
| 2 | The Model Object Struts uygulamanızda model nesneleri kullanıyorsanız, geçerli model nesnesi değer yığınındaki eylemden önce yerleştirilir. |
| 3 | The Action Object Bu, yürütülmekte olan mevcut eylem nesnesi olacaktır. |
| 4 | Named Objects Bu nesneler #application, #session, #request, #attr ve # parametrelerini içerir ve ilgili sunucu uygulaması kapsamlarına başvurur. |
Değer yığınına JSP, Velocity veya Freemarker için sağlanan etiketler aracılığıyla erişilebilir. Ayrı bölümlerde çalışacağımız, struts 2.0 değer yığınını elde etmek ve ayarlamak için kullanılan çeşitli etiketler vardır. Aşağıdaki gibi eyleminizin içinde valueStack nesnesi alabilirsiniz -
ActionContext.getContext().getValueStack()Bir ValueStack nesnesine sahip olduğunuzda, bu nesneyi değiştirmek için aşağıdaki yöntemleri kullanabilirsiniz -
| Sr.No | ValueStack Yöntemleri ve Açıklaması |
|---|---|
| 1 | Object findValue(String expr) Varsayılan arama düzeninde, verilen ifadeyi yığına göre değerlendirerek bir değer bulun. |
| 2 | CompoundRoot getRoot() Yığına itilen nesneleri tutan CompoundRoot'u alın. |
| 3 | Object peek() Yığını değiştirmeden nesneyi yığının en üstüne getirin. |
| 4 | Object pop() Yığının en üstündeki nesneyi alın ve yığından çıkarın. |
| 5 | void push(Object o) Bu nesneyi yığının üstüne koyun. |
| 6 | void set(String key, Object o) Yığın üzerindeki bir nesneyi verilen anahtarla ayarlar, böylece findValue (anahtar, ...) ile geri alınabilir. |
| 7 | void setDefaultType(Class defaultType) Bir değer alınırken tür sağlanmazsa dönüştürülecek varsayılan türü ayarlar. |
| 8 | void setValue(String expr, Object value) Varsayılan arama sırasını kullanarak verilen ifadeyle yığındaki bir çekirdek üzerinde bir özellik belirlemeye çalışır. |
| 9 | int size() Yığındaki nesnelerin sayısını öğrenin. |
OGNL
Object-Graph Navigation Language(OGNL), ValueStack'teki verilere referans vermek ve bunları işlemek için kullanılan güçlü bir ifade dilidir. OGNL ayrıca veri aktarımı ve tür dönüştürmeye yardımcı olur.
OGNL, JSP İfade Diline çok benzer. OGNL, bağlam içinde bir kök veya varsayılan nesneye sahip olma fikrine dayanır. Varsayılan veya kök nesnenin özelliklerine, pound sembolü olan biçimlendirme notasyonu kullanılarak başvurulabilir.
Daha önce belirtildiği gibi, OGNL bir bağlama dayanır ve Struts, OGNL ile kullanılmak üzere bir ActionContext haritası oluşturur. ActionContext haritası aşağıdakilerden oluşur -
Application - Uygulama kapsamlı değişkenler
Session - Oturum kapsamlı değişkenler
Root / value stack - Tüm eylem değişkenleriniz burada saklanır
Request - Kapsamlı değişkenler isteyin
Parameters - İstek parametreleri
Atributes - Sayfa, istek, oturum ve uygulama kapsamında depolanan özellikler
Action nesnesinin her zaman değer yığınında mevcut olduğunu anlamak önemlidir. Dolayısıyla, Action nesnenizin özellikleri varsa“x” ve “y” kullanıma hazırdır.
ActionContext'teki nesnelere pound sembolü kullanılarak başvurulur, ancak değer yığınındaki nesnelere doğrudan başvurulabilir.
Örneğin, eğer employee bir eylem sınıfının özelliğidir, bu durumda aşağıdaki gibi başvurulabilir -
<s:property value = "name"/>onun yerine
<s:property value = "#name"/>Oturumda "oturum açma" adlı bir özniteliğiniz varsa, bunu aşağıdaki şekilde alabilirsiniz -
<s:property value = "#session.login"/>OGNL ayrıca, Harita, Liste ve Küme koleksiyonlarıyla ilgilenmeyi de destekler. Örneğin, bir açılır renk listesi görüntülemek için şunları yapabilirsiniz:
<s:select name = "color" list = "{'red','yellow','green'}" />OGNL ifadesi, "kırmızı", "sarı", "yeşil" i renkler olarak yorumlamak ve buna göre bir liste oluşturmak için zekidir.
OGNL ifadeleri, farklı etiketleri inceleyeceğimiz sonraki bölümlerde yoğun bir şekilde kullanılacaktır. Dolayısıyla, bunlara ayrı ayrı bakmaktansa, Form Etiketleri / Kontrol Etiketleri / Veri Etiketleri ve Ajax Etiketleri bölümündeki bazı örnekleri kullanarak bakalım.
ValueStack / OGNL Örneği
Eylem Oluştur
ValueStack'e eriştiğimiz aşağıdaki eylem sınıfını ve ardından OGNL'yi kullanarak erişeceğimiz birkaç anahtarı, yani JSP sayfasını ayarlayalım.
package com.tutorialspoint.struts2;
import java.util.*;
import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
ValueStack stack = ActionContext.getContext().getValueStack();
Map<String, Object> context = new HashMap<String, Object>();
context.put("key1", new String("This is key1"));
context.put("key2", new String("This is key2"));
stack.push(context);
System.out.println("Size of the valueStack: " + stack.size());
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Aslında, Struts 2, çalıştırıldığında eyleminizi valueStack'in tepesine ekler. Dolayısıyla, Değer Yığını'na bir şeyler yerleştirmenin genel yolu, Action sınıfınıza değerler için alıcılar / ayarlayıcılar eklemek ve ardından değerlere erişmek için <s: property> etiketini kullanmaktır. Ama size ActionContext ve ValueStack'in desteklerde tam olarak nasıl çalıştığını gösteriyorum.
Görünümler Oluşturun
Aşağıdaki jsp dosyasını oluşturalım HelloWorld.jsptutulma projenizdeki WebContent klasöründe. İşlemin başarılı olması durumunda bu görünüm görüntülenecektir -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Entered value : <s:property value = "name"/><br/>
Value of key 1 : <s:property value = "key1" /><br/>
Value of key 2 : <s:property value = "key2" /> <br/>
</body>
</html>Ayrıca yaratmalıyız index.jsp içeriği aşağıdaki gibi olan WebContent klasöründe -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>Yapılandırma Dosyaları
Aşağıdakilerin içeriği struts.xml dosya -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Aşağıdakilerin içeriği web.xml dosya -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Proje adına sağ tıklayın ve tıklayın Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin.
Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyin http://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır
Şimdi verilen metin kutusuna herhangi bir kelime girin ve tanımlanan eylemi yürütmek için "Merhaba Deyin" düğmesini tıklayın. Şimdi, oluşturulan günlüğü kontrol ederseniz, aşağıdaki metni altta bulacaksınız -
Size of the valueStack: 3Bu, gireceğiniz değeri ve ValueStack'e koyduğumuz key1 ve key2'nin değerini gösteren aşağıdaki ekranı görüntüleyecektir.
Struts 2 çerçevesi, "HTML'de Form Tabanlı Dosya Yüklemesi" kullanılarak dosya yüklemesinin işlenmesi için yerleşik destek sağlar. Bir dosya karşıya yüklendiğinde, genellikle geçici bir dizinde depolanır ve verilerin kaybolmamasını sağlamak için Action sınıfınız tarafından işlenmeli veya kalıcı bir dizine taşınmalıdır.
Note - Sunucular, geçici dizin ve web uygulamanıza ait olan dizinler dışındaki dizinlere yazmanızı yasaklayan bir güvenlik politikasına sahip olabilir.
Struts'ta dosya yükleme, adı verilen önceden tanımlanmış bir engelleyici aracılığıyla mümkündür. FileUpload org.apache.struts2.interceptor.FileUploadInterceptor sınıfı aracılığıyla kullanılabilen vedefaultStack. Yine de, aşağıda göreceğimiz gibi çeşitli parametreleri ayarlamak için struts.xml dosyanızda kullanabilirsiniz.
Görünüm Dosyaları Oluşturun
Seçilen bir dosyaya göz atmak ve yüklemek için gerekli olacak görünümümüzü oluşturmaya başlayalım. Öyleyse bir yaratalımindex.jsp kullanıcının bir dosya yüklemesine olanak tanıyan düz HTML yükleme formu ile -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>File Upload</title>
</head>
<body>
<form action = "upload" method = "post" enctype = "multipart/form-data">
<label for = "myFile">Upload your file</label>
<input type = "file" name = "myFile" />
<input type = "submit" value = "Upload"/>
</form>
</body>
</html>Yukarıdaki örnekte kayda değer birkaç nokta var. İlk olarak, formun enctype değerimultipart/form-data. Bu, dosya yüklemelerinin dosya yükleme engelleyicisi tarafından başarılı bir şekilde işlenmesi için ayarlanmalıdır. Bir sonraki nokta, formun eylem yöntemidir.upload ve dosya yükleme alanının adı - myFile. Eylem yöntemini ve struts yapılandırmasını oluşturmak için bu bilgiye ihtiyacımız var.
Sonra, basit bir jsp dosyası oluşturalım success.jsp başarılı olması durumunda dosya yüklememizin sonucunu görüntülemek için.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Success</title>
</head>
<body>
You have successfully uploaded <s:property value = "myFileFileName"/>
</body>
</html>Sonuç dosyası aşağıdadır error.jsp dosyayı yüklerken bir hata olması durumunda -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Error</title>
</head>
<body>
There has been an error in uploading the file.
</body>
</html>Eylem Sınıfı Oluşturun
Sonra, adında bir Java sınıfı oluşturalım uploadFile.java bu, dosyanın yüklenmesini ve bu dosyanın güvenli bir konumda depolanmasını sağlar -
package com.tutorialspoint.struts2;
import java.io.File;
import org.apache.commons.io.FileUtils;
import java.io.IOException;
import com.opensymphony.xwork2.ActionSupport;
public class uploadFile extends ActionSupport {
private File myFile;
private String myFileContentType;
private String myFileFileName;
private String destPath;
public String execute() {
/* Copy file to a safe location */
destPath = "C:/apache-tomcat-6.0.33/work/";
try {
System.out.println("Src File name: " + myFile);
System.out.println("Dst File name: " + myFileFileName);
File destFile = new File(destPath, myFileFileName);
FileUtils.copyFile(myFile, destFile);
} catch(IOException e) {
e.printStackTrace();
return ERROR;
}
return SUCCESS;
}
public File getMyFile() {
return myFile;
}
public void setMyFile(File myFile) {
this.myFile = myFile;
}
public String getMyFileContentType() {
return myFileContentType;
}
public void setMyFileContentType(String myFileContentType) {
this.myFileContentType = myFileContentType;
}
public String getMyFileFileName() {
return myFileFileName;
}
public void setMyFileFileName(String myFileFileName) {
this.myFileFileName = myFileFileName;
}
}uploadFile.javaçok basit bir sınıftır. Unutulmaması gereken önemli nokta, FileUpload durdurucusunun Parameters Interceptor ile birlikte bizim için tüm ağır işi yapmasıdır.
FileUpload engelleyicisi, varsayılan olarak sizin için üç parametreyi kullanılabilir kılar. Aşağıdaki düzende adlandırılırlar -
[your file name parameter] - Bu, kullanıcının yüklediği gerçek dosyadır. Bu örnekte "MyFile" olacak
[your file name parameter]ContentType- Bu, yüklenen dosyanın içerik türüdür. Bu örnekte "myFileContentType" olacaktır
[your file name parameter]FileName- Bu, yüklenen dosyanın adıdır. Bu örnekte "myFileFileName" olacak
Struts Interceptors sayesinde üç parametre bizim için mevcuttur. Tek yapmamız gereken, Action sınıfımızda doğru adlarla üç parametre oluşturmak ve bu değişkenler otomatik olarak bizim için otomatik olarak kablolanır. Dolayısıyla, yukarıdaki örnekte, her şey yolunda giderse basitçe "başarı" döndüren, aksi takdirde "hata" döndüren üç parametremiz ve bir işlem yöntemimiz var.
Yapılandırma Dosyaları
Dosya yükleme sürecini kontrol eden Struts2 yapılandırma özellikleri aşağıdadır -
| Sr.No | Özellikler ve Açıklama |
|---|---|
| 1 | struts.multipart.maxSize Dosya yüklemesi olarak kabul edilecek bir dosyanın maksimum boyutu (bayt cinsinden). Varsayılan 250M'dir. |
| 2 | struts.multipart.parser Çok parçalı formu yüklemek için kullanılan kitaplık. Varsayılan olarakjakarta |
| 3 | struts.multipart.saveDir Geçici dosyanın saklanacağı konum. Varsayılan olarak javax.servlet.context.tempdir'dir. |
Bu ayarlardan herhangi birini değiştirmek için kullanabilirsiniz constant Yüklenecek bir dosyanın maksimum boyutunu değiştirmek için yaptığım gibi, uygulamalarınızın struts.xml dosyasındaki etiketi.
Bize sahip olalım struts.xml aşağıdaki gibi -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<constant name = "struts.multipart.maxSize" value = "1000000" />
<package name = "helloworld" extends = "struts-default">
<action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>Dan beri, FileUploadönleme, ön tanımlı durdurucu yığınının bir parçasıdır, açıklığını yapılandırmamıza gerek yoktur. Ancak, <action> içine <interceptor-ref> etiketi ekleyebilirsiniz. FileUpload engelleyicisi iki parametre alır(a) maximumSize ve (b) allowedTypes.
MaximumSize parametresi, izin verilen maksimum dosya boyutunu ayarlar (varsayılan yaklaşık 2MB'dir). AllowTypes parametresi, aşağıda gösterildiği gibi, kabul edilen içerik (MIME) türlerinin virgülle ayrılmış bir listesidir -
<action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
<interceptor-ref name = "basicStack">
<interceptor-ref name = "fileUpload">
<param name = "allowedTypes">image/jpeg,image/gif</param>
</interceptor-ref>
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>Aşağıdakilerin içeriği web.xml dosya -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Şimdi proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/upload.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Şimdi Gözat düğmesini kullanarak bir "Contacts.txt" dosyası seçin ve dosyayı sunucunuza yükleyecek olan yükle düğmesine tıklayın ve sonraki sayfayı görmelisiniz. Yüklenen dosyanın C: \ apache-tomcat-6.0.33 \ work'e kaydedilmesi gerektiğini kontrol edebilirsiniz.
FileUpload Interceptor'ın yüklenen dosyayı otomatik olarak sildiğini, bu nedenle yüklenen dosyayı silinmeden önce bir yere programlı olarak kaydetmeniz gerekeceğini unutmayın.
Hata mesajları
FileUplaod engelleyicisi birkaç varsayılan hata mesajı anahtarı kullanır -
| Sr.No | Hata Mesajı Anahtar ve Açıklama |
|---|---|
| 1 | struts.messages.error.uploading Dosya yüklenemediğinde ortaya çıkan genel bir hata. |
| 2 | struts.messages.error.file.too.large Yüklenen dosya maximumSize tarafından belirtildiği gibi çok büyük olduğunda gerçekleşir. |
| 3 | struts.messages.error.content.type.not.allowed Yüklenen dosya belirtilen beklenen içerik türleriyle eşleşmediğinde oluşur. |
Bu mesajların metnini şuradan geçersiz kılabilirsiniz: WebContent/WEB-INF/classes/messages.properties kaynak dosyaları.
Bu bölüm size basit adımlarla Struts 2 kullanarak bir veritabanına nasıl erişeceğinizi öğretecektir. Struts bir MVC çerçevesidir ve bir veritabanı çerçevesi değildir, ancak JPA / Hibernate entegrasyonu için mükemmel destek sağlar. Daha sonraki bir bölümde hazırda bekletme entegrasyonuna bakacağız, ancak bu bölümde veritabanına erişmek için eski düz JDBC'yi kullanacağız.
Bu bölümdeki ilk adım, veritabanımızı kurmak ve kullanıma hazırlamaktır. Bu örnek için veritabanım olarak MySQL kullanıyorum. Makinemde MySQL kurulu ve "struts_tutorial" adında yeni bir veritabanı oluşturdum. Adlı bir tablo oluşturdumloginve bazı değerlerle doldurdu. Tabloyu oluşturmak ve doldurmak için kullandığım komut dosyası aşağıdadır.
MYSQL veritabanımda varsayılan kullanıcı adı "root" ve "root123" şifresi var
CREATE TABLE `struts_tutorial`.`login` (
`user` VARCHAR( 10 ) NOT NULL ,
`password` VARCHAR( 10 ) NOT NULL ,
`name` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `user` )
) ENGINE = InnoDB;
INSERT INTO `struts_tutorial`.`login` (`user`, `password`, `name`)
VALUES ('scott', 'navy', 'Scott Burgemott');Sonraki adım MySQL Connector jar dosyasını indirmek ve bu dosyayı projenizin WEB-INF \ lib klasörüne yerleştirmektir. Bunu yaptıktan sonra, artık eylem sınıfını oluşturmaya hazırız.
Eylem Oluştur
Eylem sınıfı, veritabanı tablosundaki sütunlara karşılık gelen özelliklere sahiptir. Sahibizuser, password ve nameString nitelikleri olarak. Eylem yönteminde, kullanıcının var olup olmadığını kontrol etmek için kullanıcı ve şifre parametrelerini kullanırız, eğer varsa, bir sonraki ekranda kullanıcı adını görüntüleriz.
Kullanıcı yanlış bilgi girdiyse tekrar giriş ekranına gönderiyoruz.
Aşağıdakilerin içeriği LoginAction.java dosya -
package com.tutorialspoint.struts2;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String user;
private String password;
private String name;
public String execute() {
String ret = ERROR;
Connection conn = null;
try {
String URL = "jdbc:mysql://localhost/struts_tutorial";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(URL, "root", "root123");
String sql = "SELECT name FROM login WHERE";
sql+=" user = ? AND password = ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, user);
ps.setString(2, password);
ResultSet rs = ps.executeQuery();
while (rs.next()) {
name = rs.getString(1);
ret = SUCCESS;
}
} catch (Exception e) {
ret = ERROR;
} finally {
if (conn != null) {
try {
conn.close();
} catch (Exception e) {
}
}
}
return ret;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Ana Sayfa Oluştur
Şimdi bir JSP dosyası oluşturalım index.jspkullanıcı adı ve şifreyi toplamak için. Bu kullanıcı adı ve şifre veri tabanına göre kontrol edilecektir.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Login</title>
</head>
<body>
<form action = "loginaction" method = "post">
User:<br/><input type = "text" name = "user"/><br/>
Password:<br/><input type = "password" name = "password"/><br/>
<input type = "submit" value = "Login"/>
</form>
</body>
</html>Görünümler Oluşturun
Şimdi yaratalım success.jsp eylemin BAŞARILI döndürmesi durumunda çağrılacak olan dosya, ancak eylemden bir HATA döndürülmesi durumunda başka bir görünüm dosyamız olacak.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Successful Login</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>Aşağıdaki görünüm dosyası olacak error.jsp bir HATA olması durumunda eylemden döndürülür.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Invalid User Name or Password</title>
</head>
<body>
Wrong user name or password provided.
</body>
</html>Yapılandırma Dosyaları
Son olarak, struts.xml yapılandırma dosyasını kullanarak her şeyi aşağıdaki gibi bir araya getirelim -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "loginaction"
class = "com.tutorialspoint.struts2.LoginAction"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>Aşağıdakilerin içeriği web.xml dosya -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Şimdi, proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Yanlış bir kullanıcı adı ve şifre girin. Bir sonraki sayfayı görmelisiniz.
Şimdi girin scott kullanıcı adı olarak ve navyşifre olarak. Bir sonraki sayfayı görmelisiniz.
Bu bölüm, Struts 2 uygulamanızı kullanarak nasıl e-posta gönderebileceğinizi açıklamaktadır.
Bu alıştırma için, mail.jar dosyasını JavaMail API 1.4.4'ten indirip yüklemeniz vemail.jar dosyasını WEB-INF \ lib klasörünüze yerleştirin ve ardından standart eylem, görünüm ve yapılandırma dosyaları oluşturma adımlarını izleyin.
Eylem Oluştur
Bir sonraki adım, e-postanın gönderilmesiyle ilgilenen bir Eylem yöntemi oluşturmaktır. Adlı yeni bir sınıf oluşturalımEmailer.java aşağıdaki içeriklerle.
package com.tutorialspoint.struts2;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import com.opensymphony.xwork2.ActionSupport;
public class Emailer extends ActionSupport {
private String from;
private String password;
private String to;
private String subject;
private String body;
static Properties properties = new Properties();
static {
properties.put("mail.smtp.host", "smtp.gmail.com");
properties.put("mail.smtp.socketFactory.port", "465");
properties.put("mail.smtp.socketFactory.class",
"javax.net.ssl.SSLSocketFactory");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.port", "465");
}
public String execute() {
String ret = SUCCESS;
try {
Session session = Session.getDefaultInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication
getPasswordAuthentication() {
return new
PasswordAuthentication(from, password);
}
}
);
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
message.setSubject(subject);
message.setText(body);
Transport.send(message);
} catch(Exception e) {
ret = ERROR;
e.printStackTrace();
}
return ret;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public static Properties getProperties() {
return properties;
}
public static void setProperties(Properties properties) {
Emailer.properties = properties;
}
}Yukarıdaki kaynak kodda görüldüğü gibi, Emailer.javaaşağıda verilen email.jsp sayfasındaki form özelliklerine karşılık gelen özelliklere sahiptir. Bu özellikler -
From- Gönderenin e-posta adresi. Google'ın SMTP'sini kullandığımız için geçerli bir gtalk kimliğine ihtiyacımız var
Password - Yukarıdaki hesabın şifresi
To - E-postayı kime göndereceğiz?
Subject - e-postanın konusu
Body - Asıl e-posta mesajı
Yukarıdaki alanlarda herhangi bir doğrulama düşünmedik, doğrulamalar bir sonraki bölümde eklenecektir. Şimdi execute () yöntemine bakalım. Execute () yöntemi, sağlanan parametreleri kullanarak bir e-posta göndermek için javax Posta kitaplığını kullanır. Posta başarıyla gönderilirse, eylem BAŞARILI döndürür, aksi takdirde HATA döndürür.
Ana Sayfa Oluştur
Ana sayfa JSP dosyası yazalım index.jsp, yukarıda belirtilen e-postayla ilgili bilgileri toplamak için kullanılacak -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Email Form</title>
</head>
<body>
<em>The form below uses Google's SMTP server.
So you need to enter a gmail username and password
</em>
<form action = "emailer" method = "post">
<label for = "from">From</label><br/>
<input type = "text" name = "from"/><br/>
<label for = "password">Password</label><br/>
<input type = "password" name = "password"/><br/>
<label for = "to">To</label><br/>
<input type = "text" name = "to"/><br/>
<label for = "subject">Subject</label><br/>
<input type = "text" name = "subject"/><br/>
<label for = "body">Body</label><br/>
<input type = "text" name = "body"/><br/>
<input type = "submit" value = "Send Email"/>
</form>
</body>
</html>Görünümler Oluşturun
JSP dosyasını kullanacağız success.jsp Bu, eylemin BAŞARILI döndürmesi durumunda çağrılacaktır, ancak eylemden bir HATA döndürülmesi durumunda başka bir görünüm dosyasına sahip olacağız.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Email Success</title>
</head>
<body>
Your email to <s:property value = "to"/> was sent successfully.
</body>
</html>Aşağıdaki görünüm dosyası olacak error.jsp bir HATA olması durumunda eylemden döndürülür.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Email Error</title>
</head>
<body>
There is a problem sending your email to <s:property value = "to"/>.
</body>
</html>Yapılandırma Dosyaları
Şimdi struts.xml yapılandırma dosyasını kullanarak her şeyi aşağıdaki gibi bir araya getirelim -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "emailer"
class = "com.tutorialspoint.struts2.Emailer"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>Aşağıdakilerin içeriği web.xml dosya -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Şimdi, proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Gerekli bilgileri girin ve tıklayın Send Emailbuton. Her şey yolunda giderse, aşağıdaki sayfayı görmelisiniz.
Bu bölümde, Struts doğrulama çerçevesine daha derinlemesine bakacağız. Struts çekirdeğinde, uygulamanın eylem yöntemi yürütülmeden önce doğrulama gerçekleştirmek için kuralları çalıştırmasına yardımcı olan doğrulama çerçevesine sahibiz.
İstemci tarafı doğrulama genellikle Javascript kullanılarak yapılır. Ancak, tek başına müşteri tarafındaki doğrulamaya güvenilmemelidir. En iyi uygulamalar, doğrulamanın uygulama çerçevenizin tüm düzeylerinde tanıtılması gerektiğini önermektedir. Şimdi Struts projemize doğrulama eklemenin iki yolunu inceleyelim.
Burada bir örnek alacağız Employee Kimin adı ve yaşı basit bir sayfa kullanılarak kaydedilmelidir ve bu iki doğrulamayı kullanıcının her zaman 28 ile 65 arasında olması gereken bir ad ve yaş girmesini sağlamak için koyacağız.
Örneğin ana JSP sayfasıyla başlayalım.
Ana Sayfa Oluştur
Ana sayfa JSP dosyası yazalım index.jsp, yukarıda belirtilen Çalışan ile ilgili bilgileri toplamak için kullanılacaktır.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>İndex.jsp, henüz ele almadığımız Struts etiketini kullanır, ancak bunları etiketlerle ilgili bölümlerde inceleyeceğiz. Ancak şimdilik, s: textfield etiketinin bir giriş alanı yazdırdığını ve s: submit öğesinin bir gönder düğmesi yazdırdığını varsayalım. Her etiket için etiket oluşturan her etiket için etiket özelliğini kullandık.
Görünümler Oluşturun
Başarı tanımlı eylemin BAŞARILI döndürmesi durumunda çağrılacak olan JSP dosyası success.jsp'yi kullanacağız.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>Eylem Oluştur
Öyleyse küçük bir eylem sınıfı tanımlayalım Employeeve ardından adlı bir yöntem ekleyin validate() aşağıda gösterildiği gibi Employee.javadosya. Eylem sınıfınızın,ActionSupport sınıf, aksi takdirde doğrulama yönteminiz çalıştırılmayacaktır.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport {
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void validate() {
if (name == null || name.trim().equals("")) {
addFieldError("name","The name is required");
}
if (age < 28 || age > 65) {
addFieldError("age","Age must be in between 28 and 65");
}
}
}Yukarıdaki örnekte gösterildiği gibi, doğrulama yöntemi 'Ad' alanının bir değere sahip olup olmadığını kontrol eder. Herhangi bir değer sağlanmadıysa, özel bir hata mesajı içeren 'Ad' alanına bir alan hatası ekleriz. İkinci olarak, 'Yaş' alanına girilen değerin 28 ile 65 arasında olup olmadığını kontrol ediyoruz, bu koşul karşılamıyorsa doğrulanan alanın üstüne bir hata ekliyoruz.
Yapılandırma Dosyaları
Son olarak, her şeyi bir araya getirelim. struts.xml aşağıdaki gibi yapılandırma dosyası -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "empinfo"
class = "com.tutorialspoint.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
</package>
</struts>Aşağıdakilerin içeriği web.xml dosya -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Şimdi, proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Şimdi gerekli bilgileri girmeyin, sadece tıklayın Submitbuton. Aşağıdaki sonucu göreceksiniz -
Gerekli bilgileri girin, ancak Kimden alanına yanlış girin, adı "test" ve yaşı 30 olarak söyleyelim ve son olarak Submitbuton. Aşağıdaki sonucu göreceksiniz -
Bu Doğrulama Nasıl Çalışır?
Kullanıcı gönder düğmesine bastığında, Struts 2 otomatik olarak doğrulama yöntemini ve “if”yöntem içinde listelenen ifadeler doğruysa, Struts 2 addFieldError yöntemini çağıracaktır. Herhangi bir hata eklenmişse, Struts 2 yürütme yöntemini çağırmaya devam etmeyecektir. Bunun yerine Struts 2 çerçevesi geri dönecekinput eylemi çağırmanın sonucu olarak.
Bu nedenle, doğrulama başarısız olduğunda ve Struts 2 geri döndüğünde inputStruts 2 çerçevesi, index.jsp dosyasını yeniden görüntüleyecektir. Struts 2 form etiketleri kullandığımız için, Struts 2 hata mesajlarını dosyalanan formun hemen üstüne otomatik olarak ekleyecektir.
Bu hata mesajları, addFieldError yöntem çağrısında belirlediğimiz mesajlardır. AddFieldError yöntemi iki bağımsız değişken alır. İlki,form hatanın geçerli olduğu alan adı ve ikincisi, bu form alanının üzerinde görüntülenecek hata mesajıdır.
addFieldError("name","The name is required");Dönüş değerini işlemek için input eylem düğümümüze aşağıdaki sonucu eklememiz gerekiyor struts.xml.
<result name = "input">/index.jsp</result>XML Tabanlı Doğrulama
Doğrulama yapmanın ikinci yöntemi, eylem sınıfının yanına bir xml dosyası yerleştirmektir. Struts2 XML tabanlı doğrulama, e-posta doğrulama, tamsayı aralığı doğrulama, form doğrulama alanı, ifade doğrulama, regex doğrulama, gerekli doğrulama, gerekli string doğrulama, stringlength doğrulama vb. Gibi daha fazla doğrulama seçeneği sunar.
Xml dosyasının adlandırılması gerekiyor '[action-class]'-validation.xml. Yani, bizim durumumuzda adında bir dosya oluşturuyoruzEmployee-validation.xml aşağıdaki içeriklerle -
<!DOCTYPE validators PUBLIC
"-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
<field name = "name">
<field-validator type = "required">
<message>
The name is required.
</message>
</field-validator>
</field>
<field name = "age">
<field-validator type = "int">
<param name = "min">29</param>
<param name = "max">64</param>
<message>
Age must be in between 28 and 65
</message>
</field-validator>
</field>
</validators>Yukarıdaki XML dosyası ideal olarak sınıf dosyasıyla birlikte CLASSPATH'nizde saklanacaktır. Çalışan eylem sınıfımızı aşağıdaki gibi yapmadan yapalımvalidate() yöntem -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Kurulumun geri kalanı önceki örnekteki gibi kalacak, şimdi uygulamayı çalıştırırsanız, önceki örnekte aldığımızla aynı sonucu verecektir.
Yapılandırmayı depolamak için bir xml dosyasına sahip olmanın avantajı, doğrulamanın uygulama kodundan ayrılmasına izin verir. Kodu yazması için bir geliştirici ve doğrulama xml dosyalarını oluşturması için bir iş analisti alabilirsiniz. Unutulmaması gereken bir diğer husus, varsayılan olarak kullanılabilen doğrulayıcı türleridir.
Struts ile varsayılan olarak gelen çok daha fazla doğrulayıcı var. Yaygın doğrulayıcılar arasında Tarih Doğrulayıcısı, Normal İfade doğrulayıcısı ve Dize Uzunluğu doğrulayıcısı bulunur. Daha ayrıntılı Struts - XML Tabanlı Doğrulayıcılar için aşağıdaki bağlantıya bakın .
Uluslararasılaştırma (i18n), ürün ve hizmetlerin belirli yerel dillere ve kültürlere kolayca uyarlanabilmeleri için planlama ve uygulama sürecidir, yerelleştirme adı verilen bir süreçtir. Uluslararasılaştırma sürecine çeviri veya yerelleştirme sağlama denir.
Uluslararasılaştırma kısaltılmıştır i18n çünkü kelime harfle başlar “i” ve ile biter “n”ve ilk i ile son n arasında 18 karakter vardır.
Struts2, aşağıdaki yerlerde kaynak paketleri, önleyiciler ve etiket kitaplıkları aracılığıyla yerelleştirme, yani uluslararasılaştırma (i18n) desteği sağlar -
UI Etiketleri
Mesajlar ve Hatalar.
Eylem sınıfları içinde.
Kaynak Paketleri
Struts2, web uygulamasının kullanıcılarına çoklu dil ve yerel ayar seçenekleri sağlamak için kaynak paketlerini kullanır. Farklı dillerde sayfa yazma konusunda endişelenmenize gerek yok. Tek yapmanız gereken, istediğiniz her dil için bir kaynak paketi oluşturmaktır. Kaynak paketleri, kullanıcılarınızın dilinde başlıklar, mesajlar ve diğer metinleri içerecektir. Kaynak paketleri, uygulamanızın varsayılan dili için anahtar / değer çiftlerini içeren dosyadır.
Bir kaynak dosyası için en basit adlandırma biçimi -
bundlename_language_country.propertiesBuraya, bundlenameActionClass, Interface, SuperClass, Model, Package, Global kaynak özellikleri olabilir. Sonraki bölümlanguage_country ülke yerelini temsil eder, örneğin, İspanyolca (İspanya) yerel ayarı es_ES ile temsil edilir ve İngilizce (Amerika Birleşik Devletleri) yerel ayarı en_US vb. ile temsil edilir ve burada isteğe bağlı ülke bölümünü atlayabilirsiniz.
Bir mesaj öğesine anahtarıyla başvurduğunuzda, Struts çerçevesi aşağıdaki sırayla karşılık gelen bir mesaj paketini arar -
- ActionClass.properties
- Interface.properties
- SuperClass.properties
- model.properties
- package.properties
- struts.properties
- global.properties
Uygulamanızı birden çok dilde geliştirmek için, bu dillere / yerel ayara karşılık gelen birden çok özellik dosyası tutmalı ve tüm içeriği anahtar / değer çiftleri açısından tanımlamalısınız.
Örneğin, uygulamanızı ABD İngilizcesi (Varsayılan), İspanyolca ve Fransızca için geliştirecekseniz, üç özellik dosyası oluşturmanız gerekir. Burada kullanacağımglobal.properties yalnızca dosya, farklı türdeki mesajları ayırmak için farklı özellik dosyalarından da yararlanabilirsiniz.
global.properties - Varsayılan olarak İngilizce (ABD) uygulanacaktır
global_fr.properties - Bu, Franch yerel ayarı için kullanılacaktır.
global_es.properties - Bu, İspanyol yerel ayarı için kullanılacaktır.
Mesajlara erişin
GetText, metin etiketi, UI etiketlerinin temel özelliği ve i18n etiketi dahil olmak üzere mesaj kaynaklarına erişmenin birkaç yolu vardır. Kısaca görelim -
Göstermek i18n mesaj, bir çağrı kullan getText özellik etiketinde veya aşağıdaki gibi UI etiketleri gibi başka herhangi bir etikette -
<s:property value = "getText('some.key')" />text tag varsayılan kaynak paketinden bir mesaj alır, yani struts.properties
<s:text name = "some.key" />i18n tagkeyfi bir kaynak paketini değer yığınına iter. İ18n etiketi kapsamındaki diğer etiketler, bu kaynak paketinden gelen mesajları görüntüleyebilir−
<s:i18n name = "some.package.bundle">
<s:text name = "some.key" />
</s:i18n>key çoğu UI etiketinin özniteliği, bir kaynak paketinden bir mesaj oluşturmak için kullanılabilir -
<s:textfield key = "some.key" name = "textfieldName"/>Yerelleştirme Örneği
Yaratmayı hedefleyelim index.jspönceki bölümden birden çok dilde. Aynı dosya aşağıdaki gibi yazılacaktır -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form with Multilingual Support</title>
</head>
<body>
<h1><s:text name = "global.heading"/></h1>
<s:url id = "indexEN" namespace="/" action = "locale" >
<s:param name = "request_locale" >en</s:param>
</s:url>
<s:url id = "indexES" namespace="/" action = "locale" >
<s:param name = "request_locale" >es</s:param>
</s:url>
<s:url id = "indexFR" namespace="/" action = "locale" >
<s:param name = "request_locale" >fr</s:param>
</s:url>
<s:a href="%{indexEN}" >English</s:a>
<s:a href="%{indexES}" >Spanish</s:a>
<s:a href="%{indexFR}" >France</s:a>
<s:form action = "empinfo" method = "post" namespace = "/">
<s:textfield name = "name" key = "global.name" size = "20" />
<s:textfield name = "age" key = "global.age" size = "20" />
<s:submit name = "submit" key = "global.submit" />
</s:form>
</body>
</html>Biz yaratacağız success.jsp tanımlı eylem geri döndüğünde çağrılacak dosya SUCCESS.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Success</title>
</head>
<body>
<s:property value = "getText('global.success')" />
</body>
</html>Burada aşağıdaki iki eylemi oluşturmamız gerekir. (a) Locale ile ilgilenmek ve aynı index.jsp dosyasını farklı bir dilde görüntülemek için ilk eylem a (b) Diğer bir eylem, formun gönderilmesiyle ilgilenmektir. Her iki eylem de BAŞARI döndürecektir, ancak dönüş değerlerine göre farklı eylemler gerçekleştireceğiz çünkü amacımız her iki eylem için de farklı.
Locale ile ilgilenmek için eylem
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Locale extends ActionSupport {
public String execute() {
return SUCCESS;
}
}Formu Gönderme İşlemi
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Şimdi aşağıdaki üçü oluşturalım global.properties dosyaları ve koy CLASSPATH -
global.properties
global.name = Name
global.age = Age
global.submit = Submit
global.heading = Select Locale
global.success = Successfully authenticatedglobal_fr.properties
global.name = Nom d'utilisateur
global.age = l'âge
global.submit = Soumettre des
global.heading = Sé lectionnez Local
global.success = Authentifi é avec succèsglobal_es.properties
global.name = Nombre de usuario
global.age = Edad
global.submit = Presentar
global.heading = seleccionar la configuracion regional
global.success = Autenticado correctamenteBiz yaratacağız struts.xml aşağıdaki gibi iki eylemle -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<constant name = "struts.custom.i18n.resources" value = "global" />
<package name = "helloworld" extends = "struts-default" namespace="/">
<action name = "empinfo"
class = "com.tutorialspoint.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
<action name = "locale"
class = "com.tutorialspoint.struts2.Locale"
method = "execute">
<result name = "success">/index.jsp</result>
</action>
</package>
</struts>Aşağıdakilerin içeriği web.xml dosya -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Şimdi, proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Şimdi dillerden birini seçin, diyelim ki seçelim Spanish, şu sonucu gösterecektir -
Fransız dili ile de deneyebilirsiniz. Son olarak, tıklamayı deneyelimSubmit İspanyolca Yerel Ayarındayken aşağıdaki ekranı görüntüleyecektir -
Tebrikler, artık çok dilli bir web sayfanız var, web sitenizi küresel olarak açabilirsiniz.
Bir HTTP isteğindeki her şey bir Stringprotokol tarafından. Bu sayılar, booleler, tam sayılar, tarihler, ondalık sayılar ve diğer her şeyi içerir. Ancak, Struts sınıfında, herhangi bir veri türünün özelliğine sahip olabilirsiniz.
Struts özellikleri sizin için nasıl otomatik olarak bağlar?
Struts Ağır kaldırma işlemini gerçekleştirmek için kapakların altında çeşitli tip dönüştürücüler kullanır.
Örneğin, Action sınıfınızda bir tamsayı niteliğiniz varsa, Struts, siz hiçbir şey yapmadan istek parametresini otomatik olarak tamsayı niteliğine dönüştürür. Varsayılan olarak, Struts bir dizi tip dönüştürücü ile birlikte gelir
Aşağıda listelenen dönüştürücülerden herhangi birini kullanıyorsanız, endişelenmenize gerek yok -
- Tamsayı, Kayan, Çift, Ondalık
- Tarih ve Tarih Saat
- Diziler ve Koleksiyonlar
- Enumerations
- Boolean
- BigDecimal
Kendi veri türünüzü kullandığınız zamanlarda, Struts'ın görüntülemeden önce bu değerleri nasıl dönüştüreceğini bilmesini sağlamak için kendi dönüştürücülerinizi eklemeniz gerekir. Aşağıdaki POJO sınıfını düşününEnvironment.java.
package com.tutorialspoint.struts2;
public class Environment {
private String name;
public Environment(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Bu, adı verilen bir niteliğe sahip çok basit bir sınıftır. name, yani bu sınıfla ilgili özel bir şey yok. Sistem hakkında bilgi içeren başka bir sınıf oluşturalım -SystemDetails.java.
Bu alıştırmanın amacı için, Ortamı "Geliştirme" ve İşletim Sistemini "Windows XP SP3" olarak kodladım.
Gerçek zamanlı bir projede, bu bilgiyi sistem konfigürasyonundan alırsınız.
Aşağıdaki eylem sınıfına sahip olalım -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class SystemDetails extends ActionSupport {
private Environment environment = new Environment("Development");
private String operatingSystem = "Windows XP SP3";
public String execute() {
return SUCCESS;
}
public Environment getEnvironment() {
return environment;
}
public void setEnvironment(Environment environment) {
this.environment = environment;
}
public String getOperatingSystem() {
return operatingSystem;
}
public void setOperatingSystem(String operatingSystem) {
this.operatingSystem = operatingSystem;
}
}Ardından, basit bir JSP dosyası oluşturalım System.jsp Çevre ve İşletim Sistemi bilgilerini görüntülemek için.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>System Details</title>
</head>
<body>
Environment: <s:property value = "environment"/><br/>
Operating System:<s:property value = "operatingSystem"/>
</body>
</html>Bağlayalım system.jsp ve SystemDetails.java kullanarak birlikte sınıf struts.xml.
SystemDetails sınıfı, dizeyi döndüren basit bir execute () yöntemine sahiptir "SUCCESS".
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "system"
class = "com.tutorialspoint.struts2.SystemDetails"
method = "execute">
<result name = "success">/System.jsp</result>
</action>
</package>
</struts>Proje adına sağ tıklayın ve tıklayın Export > WAR File Savaş dosyası oluşturmak için.
Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin.
Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyin http://localhost:8080/HelloWorldStruts2/system.action. Bu, aşağıdaki ekranı oluşturacaktır -
Yukarıdaki çıktıda sorun nedir? Struts, "Windows XP SP3" dizesini ve diğer yerleşik veri türlerini nasıl görüntüleyeceğini ve dönüştüreceğini bilir, ancak özelliği ile ne yapacağını bilmez.Environmentyazın. Basitçe denirtoString() sınıftaki yöntem
Bu sorunu çözmek için, şimdi basit bir TypeConverter Çevre sınıfı için.
Adlı bir sınıf oluşturun EnvironmentConverter.java Takip ederek.
package com.tutorialspoint.struts2;
import java.util.Map;
import org.apache.struts2.util.StrutsTypeConverter;
public class EnvironmentConverter extends StrutsTypeConverter {
@Override
public Object convertFromString(Map context, String[] values, Class clazz) {
Environment env = new Environment(values[0]);
return env;
}
@Override
public String convertToString(Map context, Object value) {
Environment env = (Environment) value;
return env == null ? null : env.getName();
}
}EnvironmentConverter uzatır StrutsTypeConverter sınıfı ve Struts'a, Ortamın bir String'e nasıl dönüştürüleceğini ve bunun tersi, iki yöntemi geçersiz kılarak söyler. convertFromString() ve convertToString().
Uygulamamızda kullanmadan önce şimdi bu dönüştürücüyü kaydettirelim. Bir dönüştürücü kaydetmenin iki yolu vardır.
Dönüştürücü yalnızca belirli bir eylemde kullanılacaksa, şu şekilde adlandırılması gereken bir özellik dosyası oluşturmanız gerekir. '[action-class]'converstion.properties.
Bizim durumumuzda, adında bir dosya oluşturuyoruz SystemDetails-converstion.properties aşağıdaki kayıt girişi ile -
environment = com.tutorialspoint.struts2.EnvironmentConverterYukarıdaki örnekte, "ortam", mülkün SystemDetails.java sınıf ve Struts'a şunu kullanmalarını söylüyoruz: EnvironmentConverter bu mülke ve bu mülke dönüştürme için.
Ancak bunu yapmayacağız, bunun yerine bu dönüştürücüyü global olarak kaydettireceğiz, böylece uygulama boyunca kullanılabilir. Bunu yapmak için, adında bir özellik dosyası oluşturunxwork-conversion.properties içinde WEBINF/classes aşağıdaki satıra sahip klasör
com.tutorialspoint.struts2.Environment = \
com.tutorialspoint.struts2.EnvironmentConverterBu, dönüştürücüyü küresel olarak kaydeder, böylece StrutsOrtam türünde bir nesneyle her karşılaştığında otomatik olarak dönüştürme yapabilir. Şimdi, programı yeniden derleyip yeniden çalıştırırsanız, aşağıdaki gibi daha iyi bir çıktı elde edersiniz -
Açıkçası, şimdi sonuç daha iyi olacak, bu da Struts dönüştürücümüzün iyi çalıştığı anlamına geliyor.
Bu şekilde birden fazla dönüştürücü oluşturabilir ve bunları gereksinimlerinize göre kullanmak üzere kaydedebilirsiniz.
Bu bölüm için gerçek öğreticiye başlamadan önce, aşağıdaki gibi birkaç tanıma bakalım: https://struts.apache.org-
| Sr.No | Terim ve Açıklama |
|---|---|
| 1 | TAG JSP, FreeMarker veya Velocity içinden yürütülen küçük bir kod parçası. |
| 2 | TEMPLATE Genellikle FreeMarker'da yazılan ve belirli etiketlerle (HTML etiketleri) oluşturulabilen bir kod parçası. |
| 3 | THEME Ortak işlevsellik sağlamak için birlikte paketlenmiş bir şablon koleksiyonu. |
Ayrıca Struts2 Yerelleştirme bölümünü gözden geçirmenizi öneririm çünkü egzersizimizi gerçekleştirmek için aynı örneği bir kez daha alacağız.
Ne zaman bir Struts 2Web sayfanızdaki <s: submit ...>, <s: textfield ...> vb. gibi bir etiket, Struts 2 çerçevesi önceden yapılandırılmış bir stil ve düzen ile HTML kodu üretir. Struts 2, üç yerleşik temayla birlikte gelir -
| Sr.No | Tema ve Açıklama |
|---|---|
| 1 | SIMPLE theme "Çan ve ıslık" içermeyen minimal bir tema. Örneğin, textfield etiketi HTML <input /> etiketini bir etiket, doğrulama, hata raporlama veya diğer herhangi bir biçimlendirme veya işlevsellik olmadan oluşturur. |
| 2 | XHTML theme Bu, Struts 2 tarafından kullanılan varsayılan temadır ve basit temanın sağladığı ve HTML için standart iki sütunlu tablo düzeni, HTML'nin her biri için Etiketler, Doğrulama ve hata raporlama gibi çeşitli özellikleri sağladığı ve eklediği tüm temelleri sağlar. |
| 3 | CSS_XHTML theme Bu tema, basit temanın sağladığı ve CSS stil sayfasına göre yerleştirilmiş HTML Struts Etiketleri için <div> kullanan standart iki sütunlu CSS tabanlı düzen gibi çeşitli özellikleri sağladığı tüm temelleri sağlar. . |
Yukarıda belirtildiği gibi, bir tema belirtmezseniz, Struts 2 varsayılan olarak xhtml temasını kullanacaktır. Örneğin, bu Struts 2 seçme etiketi -
<s:textfield name = "name" label = "Name" />aşağıdaki HTML biçimlendirmesini oluşturur -
<tr>
<td class="tdLabel">
<label for = "empinfo_name" class="label">Name:</label>
</td>
<td>
<input type = "text" name = "name" value = "" id = "empinfo_name"/>
</td>
</tr>Buraya empinfo struts.xml dosyasında tanımlanan eylem adıdır.
Temaların Seçilmesi
Temayı Struts 2'ye göre etiket bazında belirtebilir veya Struts 2'nin hangi temayı kullanması gerektiğini belirlemek için aşağıdaki yöntemlerden birini kullanabilirsiniz -
Belirli bir etiket üzerindeki tema niteliği
Bir etiketin çevreleyen form etiketindeki tema niteliği
"Tema" adlı sayfa kapsamlı özellik
"Tema" adlı istek kapsamlı öznitelik
"Tema" adlı oturum kapsamlı öznitelik
"Tema" adlı uygulama kapsamlı öznitelik
Struts.properties içindeki struts.ui.theme özelliği (varsayılan olarak xhtml'dir)
Farklı etiketler için farklı temalar kullanmak istiyorsanız bunları etiket düzeyinde belirtmek için sözdizimi aşağıdadır -
<s:textfield name = "name" label = "Name" theme="xhtml"/>Temaları etiket bazında kullanmak çok pratik olmadığından, kuralı basitçe struts.properties aşağıdaki etiketleri kullanarak dosya -
# Standard UI theme
struts.ui.theme = xhtml
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the default template type. Either ftl, vm, or jsp
struts.ui.templateSuffix = ftlVarsayılan temayı bir ayarla kullandığımız yerelleştirme bölümünden aldığımız sonuç aşağıdadır. struts.ui.theme = xhtml içinde struts-default.properties struts2-core.xy.z.jar dosyasında varsayılan olarak gelen dosya.
Tema Nasıl Çalışır?
Belirli bir tema için, her struts etiketinin aşağıdaki gibi ilişkili bir şablonu vardır: s:textfield → text.ftl ve s:password → password.ftl vb.
Bu şablon dosyaları struts2-core.xy.z.jar dosyasında sıkıştırılmış olarak gelir. Bu şablon dosyaları, her etiket için önceden tanımlanmış bir HTML düzeni tutar.
Böylece, Struts 2 framework, Sturts etiketlerini ve ilişkili şablonları kullanarak nihai HTML biçimlendirme kodunu üretir.
Struts 2 tags + Associated template file = Final HTML markup code.Varsayılan şablonlar FreeMarker'da yazılmıştır ve bir uzantıları vardır .ftl.
Şablonlarınızı velocity veya JSP kullanarak da tasarlayabilir ve buna göre struts.properties dosyasındaki yapılandırmayı kullanarak ayarlayabilirsiniz. struts.ui.templateSuffix ve struts.ui.templateDir.
Yeni Temalar Oluşturmak
Yeni bir tema oluşturmanın en basit yolu, mevcut tema / şablon dosyalarından herhangi birini kopyalamak ve gerekli değişiklikleri yapmaktır.
Adlı bir klasör oluşturarak başlayalım templateiçinde WebContent / WEBINF / sınıfları ve yeni tema adıyla bir alt klasörde. Örneğin, WebContent / WEB-INF / sınıflar / şablon / efsane .
Buradan, sıfırdan şablon oluşturmaya başlayabilir veya şablonları buradan kopyalayabilirsiniz. Struts2 distribution bunları gelecekte gerektiği gibi değiştirebileceğiniz yer.
Mevcut varsayılan şablonu değiştireceğiz xhtmlöğrenme amacı için. Şimdi struts2-core-xyzjar / template / xhtml'deki içeriği tema dizinimize kopyalayalım ve sadece WebContent / WEBINF / classes / template / mytheme / control .ftl dosyasını değiştirelim. Aşağıdaki satırlara sahip olacak control.ftl'yi açtığımızda -
<table class="${parameters.cssClass?default('wwFormTable')?html}"<#rt/>
<#if parameters.cssStyle??> style="${parameters.cssStyle?html}"<#rt/>
</#if>
>Yukarıdaki dosyayı değiştirelim control.ftl aşağıdaki içeriğe sahip olmak için -
<table style = "border:1px solid black;">Kontrol edersen form.ftl o zaman onu bulacaksın control.ftlbu dosyada kullanılıyor, ancak form.ftl bu dosyaya xhtml temasından başvuruyor. Öyleyse bunu şu şekilde değiştirelim -
<#include "/${parameters.templateDir}/xhtml/form-validate.ftl" />
<#include "/${parameters.templateDir}/simple/form-common.ftl" /> <#if (parameters.validate?default(false))> onreset = "${parameters.onreset?default('clearErrorMessages(this);\
clearErrorLabels(this);')}"
<#else>
<#if parameters.onreset??>
onreset="${parameters.onreset?html}" </#if> </#if> #include "/${parameters.templateDir}/mytheme/control.ftl" />Tahmin ediyorum ki, FreeMarker şablon dili olsa da .ftl dosyalarına bakarak ne yapılması gerektiği konusunda iyi bir fikir edinebilirsiniz.
Ancak, yukarıdaki değişiklikleri kaydedelim ve yerelleştirme örneğimize geri dönelim ve WebContent/WEB-INF/classes/struts.properties aşağıdaki içeriğe sahip dosya
# Customized them
struts.ui.theme = mytheme
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the template type to ftl.
struts.ui.templateSuffix = ftlŞimdi bu değişiklikten sonra proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2. Bu, aşağıdaki ekranı oluşturacaktır -
Xhtml temasından kopyaladıktan sonra temada yaptığımız değişikliğin bir sonucu olan form bileşeninin etrafında bir çerçeve görebilirsiniz. FreeMarker'ı öğrenmek için çok az çaba harcarsanız, temalarınızı çok kolay bir şekilde oluşturabilir veya değiştirebilirsiniz.
Umarım artık temel bir anlayışınız vardır Sturts 2 temalar ve şablonlar değil mi?
Strutsyakalanmamış istisnayı ele almak ve kullanıcıları özel bir hata sayfasına yönlendirmek için daha kolay bir yol sağlar. Struts'ı farklı istisnalar için farklı hata sayfalarına sahip olacak şekilde kolayca yapılandırabilirsiniz.
Payandalar, "istisna" durdurucunun kullanımıyla istisna işlemeyi kolaylaştırır. "İstisna" engelleyicisi, varsayılan yığının bir parçası olarak dahil edilmiştir, bu nedenle onu yapılandırmak için fazladan bir şey yapmanıza gerek kalmaz. Kullanmanız için kutudan çıktığı gibi kullanıma hazırdır.
HelloWorldAction.java dosyasında bazı değişikliklerle birlikte basit bir Hello World örneği görelim. Burada, kasıtlı olarak bir NullPointer İstisnası ekledik.HelloWorldAction eylem kodu.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport{
private String name;
public String execute(){
String x = null;
x = x.substring(0);
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}İçeriğini saklayalım HelloWorld.jsp aşağıdaki gibi -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>Aşağıdakilerin içeriği index.jsp -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>Sizin struts.xml gibi görünmeli -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Şimdi proje adına sağ tıklayın ve tıklayın Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
"Struts2" değerini girin ve sayfayı gönderin. Aşağıdaki sayfayı görmelisiniz -
Yukarıdaki örnekte gösterildiği gibi, varsayılan istisna engelleyicisi, istisnayı ele almak için harika bir iş çıkarır.
Şimdi İstisnamız için özel bir hata sayfası oluşturalım. Adlı bir dosya oluşturunError.jsp aşağıdaki içeriklerle -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title></title>
</head>
<body>
This is my custom error page
</body>
</html>Şimdi Struts'u bir istisna durumunda bu hata sayfasını kullanacak şekilde yapılandıralım. Değiştirelimstruts.xml aşağıdaki gibi -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<exception-mapping exception = "java.lang.NullPointerException"
result = "error" />
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>Yukarıdaki örnekte gösterildiği gibi, artık Struts'ı NullPointerException için ayrılmış Error.jsp'yi kullanacak şekilde yapılandırdık. Programı şimdi yeniden çalıştırırsanız, şimdi aşağıdaki çıktıyı göreceksiniz -
Buna ek olarak, Struts2 çerçevesi istisnaları kaydetmek için bir "loglama" durdurucu ile birlikte gelir. Kaydedicinin yakalanmamış istisnaları günlüğe kaydetmesini sağlayarak, yığın izine kolayca bakabilir ve neyin yanlış gittiğini hesaplayabiliriz.
Global İstisna Eşlemeleri
Eyleme özgü istisnayı nasıl idare edebileceğimizi gördük. Tüm eylemler için geçerli olacak küresel olarak bir istisna belirleyebiliriz. Örneğin, aynı NullPointerException istisnalarını yakalamak için ekleyebiliriz<global-exception-mappings...> <paket ...> etiketinin içindeki etiket ve bunun <sonuç ...> etiketi, struts.xml dosyasındaki <action ...> etiketinin içine aşağıdaki gibi eklenmelidir -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<global-exception-mappings>
<exception-mapping exception = "java.lang.NullPointerException"
result = "error" />
</global-exception-mappings>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>Daha önce bahsedildiği gibi, Struts iki yapılandırma biçimi sağlar. Geleneksel yol,struts.xmltüm konfigürasyonlar için dosya. Şimdiye kadar öğreticide bunun birçok örneğini gördük. Strutları yapılandırmanın diğer bir yolu da Java 5 Açıklamalar özelliğini kullanmaktır. Dikme ek açıklamalarını kullanarak,Zero Configuration.
Projenizde ek açıklamaları kullanmaya başlamak için aşağıdaki jar dosyalarını eklediğinizden emin olun. WebContent/WEB-INF/lib klasör -
- struts2-convention-plugin-x.y.z.jar
- asm-x.y.jar
- antlr-x.y.z.jar
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
Şimdi, içinde bulunan yapılandırmayı nasıl ortadan kaldırabileceğinizi görelim. struts.xml dosyalayın ve açıklamalarla değiştirin.
Struts2'deki Annotation kavramını açıklamak için, Struts2 Validations bölümünde açıklanan doğrulama örneğimizi yeniden gözden geçirmemiz gerekir .
Burada, adı, yaşı basit bir sayfa kullanılarak alınacak bir Çalışan örneğini ele alacağız ve ÜSER'in her zaman bir ad girmesini ve yaşının 28 ile 65 arasında olmasını sağlamak için iki doğrulama yapacağız.
Örneğin ana JSP sayfasıyla başlayalım.
Ana Sayfa Oluştur
Ana sayfa JSP dosyası yazalım index.jsp, yukarıda belirtilen Çalışanla ilgili bilgileri toplamak için kullanılır.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>İndex.jsp, henüz ele almadığımız Struts etiketini kullanır, ancak bunları etiketlerle ilgili bölümlerde inceleyeceğiz. Ancak şimdilik, s: textfield etiketinin bir giriş alanı yazdırdığını ve s: submit öğesinin bir gönder düğmesi yazdırdığını varsayalım. Her etiket için etiket oluşturan her etiket için etiket özelliğini kullandık.
Görünümler Oluşturun
JSP dosyasını kullanacağız success.jsp tanımlanan eylemin geri dönmesi durumunda çağrılacak SUCCESS.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>Eylem Oluştur
Ek açıklamanın kullanıldığı yer burasıdır. Eylem sınıfını yeniden tanımlayalımEmployee ek açıklama ile ve ardından adlı bir yöntem ekleyin validate () aşağıda gösterildiği gibi Employee.javadosya. Eylem sınıfınızın,ActionSupport sınıf, aksi takdirde doğrulama yönteminiz çalıştırılmayacaktır.
package com.tutorialspoint.struts2;
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.Results;
import com.opensymphony.xwork2.validator.annotations.*;
@Results({
@Result(name = "success", Location = "/success.jsp"),
@Result(name = "input", Location = "/index.jsp")
})
public class Employee extends ActionSupport {
private String name;
private int age;
@Action(value = "/empinfo")
public String execute() {
return SUCCESS;
}
@RequiredFieldValidator( message = "The name is required" )
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@IntRangeFieldValidator(message = "Age must be in between 28 and 65", min = "29", max = "65")
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Bu örnekte birkaç ek açıklama kullandık. Onlardan birer birer geçmeme izin verin -
İlk olarak, dahil ettik Resultsek açıklama. Sonuçlar ek açıklaması, bir sonuç koleksiyonudur.
Sonuç ek açıklamasının altında iki sonuç ek açıklamamız var. Sonuç ek açıklamaları,namebu, yürütme yönteminin sonucuna karşılık gelir. Ayrıca execute () işlevinden dönen değere karşılık gelen görünümün sunulması gereken bir konum da içerirler.
Bir sonraki ek açıklama Actionek açıklama. Bu, execute () yöntemini dekore etmek için kullanılır. Eylem yöntemi, eylemin çağrıldığı URL olan bir değeri de alır.
Son olarak iki tane kullandım validationek açıklamalar. Gerekli alan doğrulayıcısını üzerinde yapılandırdımname alanı ve tamsayı aralığı doğrulayıcısı agealan. Doğrulamalar için özel bir mesaj da belirledim.
Yapılandırma Dosyaları
Gerçekten ihtiyacımız yok struts.xml yapılandırma dosyası, öyleyse bu dosyayı kaldıralım ve içeriğini kontrol edelim. web.xml dosya -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
<init-param>
<param-name>struts.devMode</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Şimdi, proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/index.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Şimdi gerekli bilgileri girmeyin, sadece tıklayın Submitbuton. Aşağıdaki sonucu göreceksiniz -
Gerekli bilgileri girin, ancak Kimden alanına yanlış girin, adı "test" ve yaşı 30 olarak söyleyelim ve son olarak Submitbuton. Aşağıdaki sonucu göreceksiniz -
Dikmeler 2 Ek Açıklama Türleri
Struts 2 uygulamaları, XML ve Java özellikleri yapılandırmasına alternatif olarak Java 5 açıklamalarını kullanabilir. Farklı kategorilerle ilgili en önemli ek açıklamaların listesini kontrol edebilirsiniz -
Dikmeler 2 Ek Açıklama Türleri .
Struts 2 etiketleri, sayfa yürütme akışını kontrol etmeyi kolaylaştıran bir dizi etikete sahiptir.
Aşağıda önemli Struts 2 Kontrol Etiketleri listesi verilmiştir -
If ve Else Etiketleri
Bu etiketler, her dilde bulunan temel koşul akışını gerçekleştirir.
'If' etiket kendi başına veya 'Else If' Etiket ve / veya tek / çoklu 'Else' Aşağıda gösterildiği gibi etiketleyin -
<s:if test = "%{false}">
<div>Will Not Be Executed</div>
</s:if>
<s:elseif test = "%{true}">
<div>Will Be Executed</div>
</s:elseif>
<s:else>
<div>Will Not Be Executed</div>
</s:else>Ayrıntılı Örneği Kontrol Edin
Yineleyici Etiketleri
Bu iteratorbir değer üzerinde yineleme yapacak. Yinelenebilir bir değer, itherjava.util.Collection veya java.util.Iterator dosyası olabilir. Bir yineleyici üzerinde yineleme yaparken kullanabilirsinizSort sonucu sıralamak için etiket veya SubSet listenin veya dizinin bir alt kümesini almak için etiket.
Aşağıdaki örnek, değer yığınındaki geçerli nesnenin getDays () yönteminin değerini alır ve üzerinde yineleme yapmak için kullanır.
<S: property /> etiketi, yineleyicinin mevcut değerini yazdırır.
<s:iterator value = "days">
<p>day is: <s:property/></p>
</s:iterator>Ayrıntılı Örneği Kontrol Edin
Birleştirme Etiketi
Bunlar merge etiketi, iki veya daha fazla listeyi parametre olarak alır ve aşağıda gösterildiği gibi hepsini bir araya getirir -
<s:merge var = "myMergedIterator">
<s:param value = "%{myList1}" />
<s:param value = "%{myList2}" />
<s:param value = "%{myList3}" />
</s:merge>
<s:iterator value = "%{#myMergedIterator}">
<s:property />
</s:iterator>Ayrıntılı Örneği Kontrol Edin
Etiket Ekle
Bunlar append etiketi, iki veya daha fazla listeyi parametre olarak alır ve aşağıda gösterildiği gibi hepsini bir araya getirir -
<s:append var = "myAppendIterator">
<s:param value = "%{myList1}" />
<s:param value = "%{myList2}" />
<s:param value = "%{myList3}" />
</s:append>
<s:iterator value = "%{#myAppendIterator}">
<s:property />
</s:iterator>Ayrıntılı Örneği Kontrol Edin
Jeneratör Etiketi
Bunlar generatoretiketi, sağlanan val niteliğine göre bir yineleyici oluşturur. Aşağıdaki oluşturucu etiketi bir yineleyici oluşturur ve yineleyici etiketini kullanarak bunu yazdırır.
<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
<s:iterator>
<s:property /><br/>
</s:iterator>
</s:generator>Ayrıntılı Örneği Kontrol Edin
Dikmeler 2 data tagsöncelikle bir sayfada görüntülenen verileri değiştirmek için kullanılır. Aşağıda önemli veri etiketleri listelenmiştir: <Buradan başlayın>
Eylem Etiketi
Bu etiket, geliştiricilerin eylem adını ve isteğe bağlı bir ad alanını belirterek doğrudan bir JSP sayfasından eylemleri çağırmasını sağlar. Etiketin gövde içeriği, Eylemin sonuçlarını oluşturmak için kullanılır. Bu eylem için struts.xml'de tanımlanan herhangi bir sonuç işlemci, executeResult parametresi belirtilmedikçe yok sayılacaktır.
<div>Tag to execute the action</div>
<br />
<s:action name = "actionTagAction" executeresult = "true" />
<br />
<div>To invokes special method in action class</div>
<br />
<s:action name = "actionTagAction!specialMethod" executeresult = "true" />Ayrıntılı Örneği Kontrol Edin
Dahil Et Etiketi
Bunlar include başka bir JSP sayfasına bir JSP dosyası eklemek için kullanılacaktır.
<-- First Syntax -->
<s:include value = "myJsp.jsp" />
<-- Second Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1" value = "value2" />
<s:param name = "param2" value = "value2" />
</s:include>
<-- Third Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1">value1</s:param>
<s:param name = "param2">value2</s:param>
</s:include>Ayrıntılı Örneği Kontrol Edin
Fasulye Etiketi
Bunlar beanetiketi, JavaBeans belirtimine uyan bir sınıfı somutlaştırır. Bu etiketin, o sınıftaki herhangi bir mutatör yöntemi ayarlamak için bir dizi Param öğesi içerebilen bir gövdesi vardır. Var özniteliği BeanTag üzerinde ayarlanırsa, başlatılan fasulyeyi yığının Bağlamına yerleştirir.
<s:bean name = "org.apache.struts2.util.Counter" var = "counter">
<s:param name = "first" value = "20"/>
<s:param name = "last" value = "25" />
</s:bean>Ayrıntılı Örneği Kontrol Edin
Tarih Etiketi
Bunlar dateetiketi, bir Tarihi hızlı ve kolay bir şekilde biçimlendirmenize olanak tanır. Özel bir format belirleyebilir (ör. "Gg / AA / yyyy ss: dd"), kolay okunabilir gösterimler ("2 saat, 14 dakika" gibi) oluşturabilir veya önceden tanımlanmış bir biçime geri dönebilirsiniz özellikler dosyanızdaki 'struts.date.format' anahtarını kullanın.
<s:date name = "person.birthday" format = "dd/MM/yyyy" />
<s:date name = "person.birthday" format = "%{getText('some.i18n.key')}" />
<s:date name = "person.birthday" nice="true" />
<s:date name = "person.birthday" />Ayrıntılı Örneği Kontrol Edin
Param Etiketi
Bunlar parametiketi, diğer etiketleri parametreleştirmek için kullanılabilir. Bu etiket aşağıdaki iki parametreye sahiptir.
isim (Dize) - parametrenin adı
değer (Nesne) - parametrenin değeri
<pre>
<ui:component>
<ui:param name = "key" value = "[0]"/>
<ui:param name = "value" value = "[1]"/>
<ui:param name = "context" value = "[2]"/>
</ui:component>
</pre>Ayrıntılı Örneği Kontrol Edin
Emlak Etiketi
Bunlar property etiketi, bir değerin özelliğini almak için kullanılır ve bu özellik, hiçbiri belirtilmezse varsayılan olarak yığının en üstünde olur.
<s:push value = "myBean">
<!-- Example 1: -->
<s:property value = "myBeanProperty" />
<!-- Example 2: -->TextUtils
<s:property value = "myBeanProperty" default = "a default value" />
</s:push>Ayrıntılı Örneği Kontrol Edin
Push Etiketi
Bunlar push etiketi, basitleştirilmiş kullanım için yığına değer iletmek için kullanılır.
<s:push value = "user">
<s:propery value = "firstName" />
<s:propery value = "lastName" />
</s:push>Ayrıntılı Örneği Kontrol Edin
Set Etiketi
Bunlar setetiketi, belirtilen kapsamdaki bir değişkene bir değer atar. Karmaşık bir ifadeye bir değişken atamak ve ardından karmaşık ifade yerine her seferinde bu değişkeni basitçe referans almak istediğinizde kullanışlıdır. Mevcut kapsamlarapplication, session, request, page ve action.
<s:set name = "myenv" value = "environment.name"/>
<s:property value = "myenv"/>Ayrıntılı Örneği Kontrol Edin
Metin Etiketi
Bunlar text etiketi, bir I18n metin mesajını oluşturmak için kullanılır.
<!-- First Example -->
<s:i18n name = "struts.action.test.i18n.Shop">
<s:text name = "main.title"/>
</s:i18n>
<!-- Second Example -->
<s:text name = "main.title" />
<!-- Third Examlpe -->
<s:text name = "i18n.label.greetings">
<s:param >Mr Smith</s:param>
</s:text>Ayrıntılı Örneği Kontrol Edin
URL Etiketi
Bunlar url etiketi bir URL oluşturmak için kullanılır.
<-- Example 1 -->
<s:url value = "editGadget.action">
<s:param name = "id" value = "%{selected}" />
</s:url>
<-- Example 2 -->
<s:url action = "editGadget">
<s:param name = "id" value = "%{selected}" />
</s:url>
<-- Example 3-->
<s:url includeParams="get">
<s:param name = "id" value = "%{'22'}" />
</s:url>Ayrıntılı Örneği Kontrol Edin
Listesi formetiketleri, Struts UI Etiketlerinin bir alt kümesidir. Bu etiketler, Struts web uygulamaları için gerekli olan kullanıcı arayüzünün oluşturulmasına yardımcı olur ve üç kategoriye ayrılabilir. Bu bölüm sizi üç tür UI etiketinin tümüne götürecektir -
Basit UI Etiketleri
Bu etiketleri zaten örneklerimizde kullandık, bu bölümde fırçalayacağız. Basit bir görünüm sayfasına bakalımemail.jsp birkaç basit UI etiketiyle -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<s:head/>
<title>Hello World</title>
</head>
<body>
<s:div>Email Form</s:div>
<s:text name = "Please fill in the form below:" />
<s:form action = "hello" method = "post" enctype = "multipart/form-data">
<s:hidden name = "secret" value = "abracadabra"/>
<s:textfield key = "email.from" name = "from" />
<s:password key = "email.password" name = "password" />
<s:textfield key = "email.to" name = "to" />
<s:textfield key = "email.subject" name = "subject" />
<s:textarea key = "email.body" name = "email.body" />
<s:label for = "attachment" value = "Attachment"/>
<s:file name = "attachment" accept = "text/html,text/plain" />
<s:token />
<s:submit key = "submit" />
</s:form>
</body>
</html>HTML'nin farkındaysanız, kullanılan tüm etiketler ek bir ön eke sahip çok yaygın HTML etiketleridir. s:her bir etiket ve farklı özniteliklerle birlikte. Yukarıdaki programı çalıştırdığımızda, kullanılan tüm anahtarlar için uygun eşlemeyi kurmanız şartıyla aşağıdaki kullanıcı arayüzünü elde ederiz.
Gösterildiği gibi, s: head, Struts2 uygulaması için gereken javascript ve stil sayfası öğelerini oluşturur.
Daha sonra s: div ve s: text öğelerimiz var. S: div, bir HTML Div öğesi oluşturmak için kullanılır. Bu, HTML ve Struts etiketlerini karıştırmayı sevmeyen kişiler için kullanışlıdır. Bu insanlar için, bir div oluşturmak için s: div kullanma seçeneğine sahipler.
Gösterilen s: metni, ekranda bir metin oluşturmak için kullanılır.
Daha sonra famiilar s: form etiketimiz var. S: form etiketi, formun nereye gönderileceğini belirleyen bir eylem özniteliğine sahiptir. Formda bir dosya yükleme elemanımız olduğu için, enctype'ı multipart olarak ayarlamamız gerekiyor. Aksi takdirde bunu boş bırakabiliriz.
Form etiketinin sonunda s: submit etiketi var. Bu, formu göndermek için kullanılır. Form gönderildiğinde, tüm form değerleri s: form etiketinde belirtilen eyleme gönderilir.
S: formunun içinde, gizli adında gizli bir özelliğimiz var. Bu, HTML'de gizli bir öğe oluşturur. Bizim durumumuzda, "gizli" unsur "abrakadabra" değerine sahiptir. Bu öğe, son kullanıcı tarafından görülmez ve durumu bir görünümden diğerine taşımak için kullanılır.
Daha sonra s: label, s: textfield, s: password ve s: textarea etiketlerine sahibiz. Bunlar sırasıyla etiket, giriş alanı, şifre ve metin alanını oluşturmak için kullanılır. Bunları "Struts - E-posta Gönderme" örneğinde çalışırken gördük.
Burada dikkat edilmesi gereken önemli nokta, "anahtar" özelliğinin kullanılmasıdır. "Key" özniteliği, bu kontrollerin etiketini özellik dosyasından almak için kullanılır. Bu özelliği daha önce Struts2 Yerelleştirme, uluslararasılaştırma bölümünde ele almıştık.
Ardından, bir girdi dosyası yükleme bileşeni oluşturan s: file etiketimiz var. Bu bileşen, kullanıcının dosya yüklemesine izin verir. Bu örnekte, hangi dosya türlerinin yüklenmesine izin verildiğini belirtmek için s: file etiketinin "kabul" parametresini kullandık.
Son olarak s: token etiketine sahibiz. Jeton etiketi, bir formun iki kez gönderilip gönderilmediğini bulmak için kullanılan benzersiz bir jeton oluşturur.
Form oluşturulduğunda, belirteç değeri olarak gizli bir değişken yerleştirilir. Örneğin jetonun "ABC" olduğunu varsayalım. Bu form gönderildiğinde, Struts Fitler jetonu oturumda depolanan jetonla karşılaştırır. Eşleşirse, jetonu oturumdan kaldırır. Şimdi, form yanlışlıkla yeniden gönderilirse (yenilenerek veya tarayıcı geri düğmesine basılarak), form simge olarak "ABC" ile yeniden gönderilecektir. Bu durumda filtre, jetonu oturumda depolanan jetonla yeniden kontrol eder. Ancak "ABC" simgesi oturumdan kaldırıldığı için eşleşmeyecek ve Struts filtresi isteği reddedecektir.
Grup UI Etiketleri
Grup kullanıcı arayüzü etiketleri, radyo düğmesi ve onay kutusu oluşturmak için kullanılır. Basit bir görünüm sayfasına bakalımHelloWorld.jsp onay kutusu ve radyo düğmesi etiketleriyle -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "hello.action">
<s:radio label = "Gender" name = "gender" list="{'male','female'}" />
<s:checkboxlist label = "Hobbies" name = "hobbies"
list = "{'sports','tv','shopping'}" />
</s:form>
</body>
</html>Yukarıdaki programı çalıştırdığımızda, çıktımız aşağıdakine benzer görünecektir -
Şimdi örneğe bakalım. İlk örnekte, "Cinsiyet" etiketli basit bir radyo düğmesi oluşturuyoruz. Ad özelliği radyo düğmesi etiketi için zorunludur, bu nedenle "cinsiyet" olan bir ad belirleriz. Daha sonra cinsiyete bir liste sağlıyoruz. Liste, "erkek" ve "kadın" değerleriyle doldurulur. Bu nedenle, çıktıda içinde iki değer bulunan bir radyo düğmesi alıyoruz.
İkinci örnekte, bir onay kutusu listesi oluşturuyoruz. Bu, kullanıcının hobilerini toplamak içindir. Kullanıcının birden fazla hobisi olabilir ve bu nedenle radyo düğmesi yerine onay kutusunu kullanıyoruz. Onay kutusu, "spor", "TV" ve "Alışveriş" listesiyle doldurulur. Bu, hobileri bir onay kutusu listesi olarak sunar.
UI Etiketlerini Seçin
Struts tarafından sunulan Select Tag'ın farklı varyasyonlarını inceleyelim. Basit bir görünüm sayfasına bakalımHelloWorld.jsp belirli etiketlerle -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "login.action">
<s:select name = "username" label = "Username"
list = "{'Mike','John','Smith'}" />
<s:select label = "Company Office" name = "mySelection"
value = "%{'America'}" list="%{#{'America':'America'}}">
<s:optgroup label = "Asia"
list = "%{#{'India':'India','China':'China'}}" />
<s:optgroup label = "Europe"
list="%{#{'UK':'UK','Sweden':'Sweden','Italy':'Italy'}}" />
</s:select>
<s:combobox label = "My Sign" name = "mySign"
list = "#{'aries':'aries','capricorn':'capricorn'}" headerkey = "-1"
headervalue = "--- Please Select ---" emptyOption = "true" value = "capricorn" />
<s:doubleselect label = "Occupation" name = "occupation"
list = "{'Technical','Other'}" doublename = "occupations2"
doubleList="top == 'Technical' ?
{'I.T', 'Hardware'} : {'Accounting', 'H.R'}" />
</s:form>
</body>
</html>Yukarıdaki programı çalıştırdığımızda çıktımız aşağıdakine benzer görünecektir -
Şimdi tek tek vakaları tek tek inceleyelim.
İlk olarak, select etiketi HTML seçim kutusunu oluşturur. İlk örnekte, "kullanıcı adı" adlı ve "kullanıcı adı" etiketli basit bir seçim kutusu oluşturuyoruz. Seçim kutusu, Mike, John ve Smith adlarını içeren bir listeyle doldurulacaktır.
İkinci örnekte, şirketimizin Amerika'da genel merkezi bulunmaktadır. Ayrıca Asya ve Avrupa'da küresel ofisleri vardır. Ofisleri bir seçim kutusunda görüntülemek istiyoruz ancak global ofisleri kıta adına göre gruplamak istiyoruz. Optgroup burada işe yarar. Yeni bir grup oluşturmak için s: optgroup etiketini kullanıyoruz. Gruba bir etiket ve ayrı bir liste veriyoruz.
Üçüncü örnekte, birleşik giriş kutusu kullanılmıştır. Birleşik giriş kutusu, bir giriş alanı ve bir seçim kutusunun birleşimidir. Kullanıcı, seçim kutusundan bir değer seçebilir ve bu durumda giriş alanı, kullanıcının seçtiği değerle otomatik olarak doldurulur. Kullanıcının doğrudan bir değer girmesi durumunda, seçim kutusundan hiçbir değer seçilmeyecektir.
Örneğimizde, güneş işaretlerini listeleyen birleşik giriş kutusu var. Seçim kutusu, kullanıcının listede değilse, kullanıcının güneş işaretini yazmasına izin veren yalnızca dört girişi listeler. Ayrıca seçim kutusuna bir başlık girişi de ekliyoruz. Üstbilgi girişi, seçim kutusunun üst kısmında görüntülenen giriştir. Bizim durumumuzda "Lütfen Seçin" i görüntülemek istiyoruz. Kullanıcı hiçbir şey seçmezse, değer olarak -1 kabul ederiz. Bazı durumlarda, kullanıcının boş bir değer seçmesini istemiyoruz. Bu koşullarda, "emptyOption" özelliği false olarak ayarlanır. Son olarak, örneğimizde, birleşik giriş kutusu için varsayılan değer olarak "oğlak" veriyoruz.
Dördüncü örnekte, çift seçimimiz var. İki seçim kutusunu görüntülemek istediğinizde çift seçim kullanılır. İlk seçim kutusunda seçilen değer, ikinci seçim kutusunda neyin görüneceğini belirler. Örneğimizde ilk seçim kutusu "Teknik" ve "Diğer" i görüntüler. Kullanıcı Teknik'i seçerse, ikinci seçim kutusunda BT ve Donanımı görüntüleyeceğiz. Aksi takdirde Muhasebe ve İK'yı göstereceğiz. Bu, örnekte gösterildiği gibi "liste" ve "çift liste" değerlerini kullanarak mümkündür.
Yukarıdaki örnekte, üstteki seçim kutusunun Teknik'e eşit olup olmadığını görmek için bir karşılaştırma yaptık. Varsa, BT ve Donanımı görüntüleriz.
Ayrıca üst kutu ("name = 'Occupations') ve alttaki kutu (doubleName = 'meslekler2') için bir isim vermemiz gerekiyor
Struts, AJAX etiket uygulaması için DOJO çerçevesini kullanır. Öncelikle, bu örneğe devam etmek için, sınıf yolunuza struts2-dojo-plugin-2.2.3.jar eklemeniz gerekir.
Bu dosyayı struts2 indirmenizin lib klasöründen alabilirsiniz (C: \ struts-2.2.3all \ struts-2.2.3 \ lib \ struts2-dojo-plugin-2.2.3.jar)
Bu alıştırmalar için değiştirelim HelloWorld.jsp aşağıdaki gibi -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<%@ taglib prefix = "sx" uri = "/struts-dojo-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
<sx:head />
</head>
<body>
<s:form>
<sx:autocompleter label = "Favourite Colour"
list = "{'red','green','blue'}" />
<br />
<sx:datetimepicker name = "deliverydate" label = "Delivery Date"
displayformat = "dd/MM/yyyy" />
<br />
<s:url id = "url" value = "/hello.action" />
<sx:div href="%{#url}" delay="2000">
Initial Content
</sx:div>
<br/>
<sx:tabbedpanel id = "tabContainer">
<sx:div label = "Tab 1">Tab 1</sx:div>
<sx:div label = "Tab 2">Tab 2</sx:div>
</sx:tabbedpanel>
</s:form>
</body>
</html>Yukarıdaki örneği çalıştırdığımızda, aşağıdaki çıktıyı elde ederiz -
Şimdi bu örneği adım adım inceleyelim.
Dikkat edilmesi gereken ilk şey, sx önekiyle yeni bir etiket kitaplığının eklenmesidir. Bu (struts-dojo-etiketleri), ajax entegrasyonu için özel olarak oluşturulmuş etiket kitaplığıdır.
Sonra HTML kafasının içinde sx: head adını veriyoruz. Bu dojo çerçevesini başlatır ve onu sayfadaki tüm AJAX çağrıları için hazır hale getirir. Bu adım önemlidir - ajax çağrılarınız sx: head başlatılmadan çalışmayacaktır.
İlk önce otomatik tamamlayıcı etiketimiz var. Otomatik tamamlayıcı etiketi, hemen hemen bir seçme kutusuna benziyor. Kırmızı, yeşil ve mavi değerleri ile doldurulur. Ancak bir seçim kutusu ile bunun arasındaki fark, otomatik olarak tamamlanmasıdır. Yani, gr yazmaya başlarsanız, onu "yeşil" ile dolduracaktır. Bunun dışında bu etiket, daha önce ele aldığımız s: select etiketine çok benzer.
Sonra, bir tarih saat seçicimiz var. Bu etiket, yanında bir düğme bulunan bir giriş alanı oluşturur. Düğmeye basıldığında, bir açılır tarih saat seçici görüntülenir. Kullanıcı bir tarih seçtiğinde, tarih giriş metnine tag özniteliğinde belirtilen formatta doldurulur. Örneğimizde, tarih formatı olarak gg / AA / yyyy belirledik.
Daha sonra, önceki alıştırmalarda oluşturduğumuz system.action dosyasına bir url etiketi oluşturuyoruz. System.action olması gerekmez - daha önce oluşturduğunuz herhangi bir işlem dosyası olabilir. Ardından köprünün url'ye ayarlandığı ve gecikmenin 2 saniyeye ayarlandığı bir div'imiz var. Bunu çalıştırdığınızda olan şey, "İlk İçerik" 2 saniye boyunca görüntülenecek, ardından div içeriği, içeriğin içeriği ile değiştirilecektir.hello.action yürütme.
Son olarak, iki sekmeli basit bir sekme panelimiz var. Sekmeler, Tab 1 ve Tab2 etiketleriyle kendi başlarına bölümlerdir.
Struts'taki AJAX etiket entegrasyonunun hala devam eden bir çalışma olduğunu ve bu entegrasyonun olgunluğunun her sürümde yavaşça arttığını belirtmek gerekir.
Spring, birçok yaygın web göreviyle kolay entegrasyon sağlayan popüler bir web çerçevesidir. Öyleyse soru şu ki, Struts2'ye sahip olduğumuzda neden Spring'e ihtiyacımız var? Bahar, bir MVC çerçevesinden daha fazlasıdır - Struts'ta bulunmayan birçok başka güzellik sunar.
Örneğin: herhangi bir çerçeve için yararlı olabilecek bağımlılık enjeksiyonu. Bu bölümde, Spring ve Struts2'yi nasıl entegre edeceğimizi görmek için basit bir örnek üzerinden gideceğiz.
Öncelikle, aşağıdaki dosyaları Spring kurulumundan projenin inşa yoluna eklemeniz gerekir. Spring Framework'ün son sürümünü şu adresten indirip yükleyebilirsiniz:https://www.springsource.org/download
- org.springframework.asm-x.y.z.M(a).jar
- org.springframework.beans-x.y.z.M(a).jar
- org.springframework.context-x.y.z.M(a).jar
- org.springframework.core-x.y.z.M(a).jar
- org.springframework.expression-x.y.z.M(a).jar
- org.springframework.web-x.y.z.M(a).jar
- org.springframework.web.servlet-x.y.z.M(a).jar
Son olarak ekle struts2-spring-plugin-x.y.z.jar senin içinde WEB-INF/libstruts lib dizininizden. Eclipse kullanıyorsanız, bir istisna ile karşılaşabilirsiniz java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener .
Bu sorunu çözmek için içeri girmelisiniz Markersekmesine tıklayın ve sınıf bağımlılıklarını tek tek sağ tıklayın ve tüm bağımlılıkları yayınlamak / dışa aktarmak için Hızlı düzeltme yapın. Son olarak, işaretçi sekmesi altında herhangi bir bağımlılık çakışması olmadığından emin olun.
Şimdi kurulum yapalım web.xml Struts-Yay entegrasyonu için aşağıdaki gibidir -
<?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_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Burada dikkat edilmesi gereken önemli nokta, yapılandırdığımız dinleyicidir. ContextLoaderListeneryay bağlam dosyasını yüklemek için gereklidir. Spring'in konfigürasyon dosyasıapplicationContext.xml dosya ve aynı seviyeye yerleştirilmelidir. web.xml dosya
Adlı basit bir eylem sınıfı oluşturalım User.java iki özelliğe sahip - firstName ve lastName.
package com.tutorialspoint.struts2;
public class User {
private String firstName;
private String lastName;
public String execute() {
return "success";
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}Şimdi oluşturalım applicationContext.xml Spring konfigürasyon dosyasını oluşturun ve User.javasınıf. Daha önce de belirtildiği gibi, bu dosya WEB-INF klasörünün altında olmalıdır -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id = "userClass" class = "com.tutorialspoint.struts2.User">
<property name = "firstName" value = "Michael" />
<property name = "lastName" value = "Jackson" />
</bean>
</beans>Yukarıda görüldüğü gibi, kullanıcı çekirdeğini yapılandırdık ve değerleri enjekte ettik. Michael ve Jacksonfasulye içine. Bu fasulyeye ayrıca "userClass" adını verdik, böylece bunu başka bir yerde yeniden kullanabiliriz. Sonra, oluşturalımUser.jsp WebContent klasöründe -
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2 - Spring integration</h1>
<s:form>
<s:textfield name = "firstName" label = "First Name"/><br/>
<s:textfield name = "lastName" label = "Last Name"/><br/>
</s:form>
</body>
</html>User.jspdosya oldukça basittir. Yalnızca tek bir amaca hizmet eder - kullanıcı nesnesinin adının ve soyadının değerlerini görüntülemek. Son olarak, tüm varlıkları bir araya getirelim.struts.xml dosya.
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "user" class="userClass"
method = "execute">
<result name = "success">/User.jsp</result>
</action>
</package>
</struts>Unutulmaması gereken önemli nokta, kimliği kullanmamızdır. userClasssınıfa başvurmak için. Bu, User sınıfı için bağımlılık enjeksiyonunu yapmak için spring kullandığımız anlamına gelir.
Şimdi proje adına sağ tıklayın ve tıklayın Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/User.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Şimdi iki harika çerçeveyi nasıl bir araya getireceğimizi gördük. Bu, Struts - Yay entegrasyonu bölümünü bitirir.
Bu bölümde, Tiles çerçevesini Struts2 ile entegre etme adımlarını inceleyelim. Apache Tiles, web uygulaması kullanıcı arayüzlerinin geliştirilmesini basitleştirmek için oluşturulmuş bir şablon oluşturma çerçevesidir.
Öncelikle, fayans jar dosyalarını Apache Tiles web sitesinden indirmemiz gerekiyor . Aşağıdaki jar dosyalarını projenin sınıf yoluna eklemeniz gerekir.
- tiles-api-x.y.z.jar
- tiles-compat-x.y.z.jar
- tiles-core-x.y.z.jar
- tiles-jsp-x.y.z.jar
- tiles-servlet-x.y.z.jar
Yukarıdakilere ek olarak, aşağıdaki jar dosyalarını indirdiğiniz struts2 dosyasından kopyalamamız gerekiyor. WEB-INF/lib.
- commons-beanutils-x.y.zjar
- commons-digester-x.y.jar
- struts2-tiles-plugin-x.y.z.jar
Şimdi kurulum yapalım web.xmlStruts-Tiles entegrasyonu için aşağıda verilmiştir. Burada dikkat edilmesi gereken iki önemli nokta var. Öncelikle, fayans yapılandırma dosyasını nerede bulacağımızı söylememiz gerekir.tiles.xml. Bizim durumumuzda, altında olacak/WEB-INFKlasör. Daha sonra, Struts2 indirmesiyle birlikte gelen Tiles dinleyicisini başlatmamız gerekiyor.
<?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>Struts2Example15</display-name>
<context-param>
<param-name>
org.apache.tiles.impl.BasicTilesContainer.DEFINITIONS_CONFIG
</param-name>
<param-value>
/WEB-INF/tiles.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.apache.struts2.tiles.StrutsTilesListener
</listener-class>
</listener>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>Sonra yaratalım tiles.xml aşağıdaki içeriğe sahip / WEB-INF klasörü altında -
<?xml version = "1.0" Encoding = "UTF-8" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
"http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
<tiles-definitions>
<definition name = "baseLayout" template="/baseLayout.jsp">
<put-attribute name = "title" value = "Template"/>
<put-attribute name = "banner" value = "/banner.jsp"/>
<put-attribute name = "menu" value = "/menu.jsp"/>
<put-attribute name = "body" value = "/body.jsp"/>
<put-attribute name = "footer" value = "/footer.jsp"/>
</definition>
<definition name = "tiger" extends = "baseLayout">
<put-attribute name = "title" value = "Tiger"/>
<put-attribute name = "body" value = "/tiger.jsp"/>
</definition>
<definition name = "lion" extends = "baseLayout">
<put-attribute name = "title" value = "Lion"/>
<put-attribute name = "body" value = "/lion.jsp"/>
</definition>
</tiles-definitions>Ardından, temel bir iskelet düzeni tanımlıyoruz. baseLayout.jsp. Yeniden kullanılabilir / geçersiz kılınabilir beş alanı vardır. Yanititle, banner, menu, body ve footer. BaseLayout için varsayılan değerleri sağlıyoruz ve ardından varsayılan düzenden uzanan iki özelleştirme oluşturuyoruz. Kaplan düzeni, temel düzene benzer, tek farkıtiger.jspgövdesi ve başlık olarak "Kaplan" metni. Benzer şekilde, aslan düzeni temel düzene benzer, tek farkılion.jsp gövdesi ve başlık olarak "Aslan" metni.
Tek tek jsp dosyalarına bir göz atalım. Aşağıdakilerin içeriğibaseLayout.jsp dosya -
<%@ taglib uri = "http://tiles.apache.org/tags-tiles" prefix = "tiles"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset = UTF-8">
<title>
<tiles:insertAttribute name = "title" ignore="true" />
</title>
</head>
<body>
<tiles:insertAttribute name = "banner" /><br/>
<hr/>
<tiles:insertAttribute name = "menu" /><br/>
<hr/>
<tiles:insertAttribute name = "body" /><br/>
<hr/>
<tiles:insertAttribute name = "footer" /><br/>
</body>
</html>Burada, fayans niteliklerine sahip temel bir HTML sayfası oluşturduk. Fayans niteliklerini olması gereken yerlere yerleştiririz. Sonra, bir oluşturalımbanner.jsp aşağıdaki içeriğe sahip dosya -
<img src="http://www.tutorialspoint.com/images/tp-logo.gif"/>menu.jsp dosyası, TigerMenu.action ve LionMenu.action struts eylemlerine bağlantılar olan aşağıdaki satırlara sahip olacaktır.
<%@taglib uri = "/struts-tags" prefix = "s"%>
<a href = "<s:url action = "tigerMenu"/>" Tiger</a><br>
<a href = "<s:url action = "lionMenu"/>" Lion</a><br>lion.jsp dosya şu içeriğe sahip olacak -
<img src="http://upload.wikimedia.org/wikipedia/commons/d/d2/Lion.jpg"/>
The liontiger.jsp dosya şu içeriğe sahip olacak -
<img src="http://www.freewebs.com/tigerofdarts/tiger.jpg"/>
The tigerSonra, eylem sınıfı dosyasını oluşturalım MenuAction.java aşağıdakileri içeren -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class MenuAction extends ActionSupport {
public String tiger() { return "tiger"; }
public String lion() { return "lion"; }
}Bu oldukça basit bir ders. Sonuç olarak sırasıyla kaplan ve aslanı döndüren iki yöntemi kaplan () ve aslan () ilan ettik. Hepsini bir araya getirelimstruts.xml dosya -
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name = "default" extends = "struts-default">
<result-types>
<result-type name = "tiles"
class="org.apache.struts2.views.tiles.TilesResult" />
</result-types>
<action name = "*Menu" method = "{1}"
class = "com.tutorialspoint.struts2.MenuAction">
<result name = "tiger" type = "tiles">tiger</result>
<result name = "lion" type = "tiles">lion</result>
</action>
</package>
</struts>Yukarıdaki dosyada ne yaptığımızı kontrol edelim. Her şeyden önce, artık görünüm teknolojisi için düz jsp yerine döşemeler kullandığımız için "karo" adı verilen yeni bir sonuç türü ilan ettik. Struts2, Tiles View sonuç türü için kendi desteğine sahiptir, bu nedenle "org.apache.struts2.view.tiles.TilesResult" sınıfına ait "karolar" sonuç türünü oluştururuz.
Daha sonra, isteğin /tigerMenu.action için olup olmadığını, kullanıcıyı kaplan karoları sayfasına, /lionMenu.action içinse kullanıcıyı aslan karoları sayfasına götürdüğünü söylemek istiyoruz.
Bunu biraz düzenli ifade kullanarak başarıyoruz. Eylem tanımımızda, "* Menü" kalıbıyla eşleşen her şeyin bu eylem tarafından ele alınacağını söylüyoruz. Eşleştirme yöntemi MenuAction sınıfında çağrılacaktır. Yani, tigerMenu.action kaplan () ve lionMenu.action aslan () çağıracaktır. Daha sonra sonucun sonucunu uygun karo sayfalarına eşlememiz gerekir.
Şimdi proje adına sağ tıklayın ve tıklayın Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/tigerMenu.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Benzer şekilde, lionMenu.action sayfasına giderseniz, aynı döşeme düzenini kullanan aslan sayfasını göreceksiniz.
Hibernate, açık kaynak GNU Kısıtlı Genel Kamu Lisansı (LGPL) altında lisanslanan ve indirmesi ücretsiz olan yüksek performanslı bir Nesne / İlişkisel kalıcılık ve sorgu hizmetidir. Bu bölümde. Hibernate ile Struts 2 entegrasyonunun nasıl sağlanacağını öğreneceğiz. Hazırda Bekletme konusuna aşina değilseniz, Hazırda Bekletme eğitimimize göz atabilirsiniz .
Veritabanı Kurulumu
Bu eğitim için, "struts2_tutorial" MySQL veritabanını kullanacağım. Bu veritabanına makinemde "root" kullanıcı adını kullanarak ve parola olmadan bağlanıyorum. Öncelikle aşağıdaki betiği çalıştırmanız gerekiyor. Bu komut dosyası adında yeni bir tablo oluştururstudent ve bu tabloda birkaç kayıt oluşturur -
CREATE TABLE IF NOT EXISTS `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`first_name` varchar(40) NOT NULL,
`last_name` varchar(40) NOT NULL,
`marks` int(11) NOT NULL,
PRIMARY KEY (`id`)
);
--
-- Dumping data for table `student`
--
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(1, 'George', 'Kane', 20);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(2, 'Melissa', 'Michael', 91);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(3, 'Jessica', 'Drake', 21);Hazırda Bekletme Yapılandırması
Ardından, hazırda bekletme modunun yapılandırma dosyası olan hibernate.cfg.xml dosyasını oluşturalım.
<?xml version = '1.0' encoding = 'utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.connection.driver_class">c
om.mysql.jdbc.Driver
</property>
<property name = "hibernate.connection.url">
jdbc:mysql://www.tutorialspoint.com/struts_tutorial
</property>
<property name = "hibernate.connection.username">root</property>
<property name = "hibernate.connection.password"></property>
<property name = "hibernate.connection.pool_size">10</property>
<property name = "show_sql">true</property>
<property name = "dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.hbm2ddl.auto">update</property>
<mapping class = "com.tutorialspoint.hibernate.Student" />
</session-factory>
</hibernate-configuration>Hazırda bekleme yapılandırma dosyasını inceleyelim. İlk olarak MySQL sürücüsü kullandığımızı ilan ettik. Daha sonra veritabanına bağlanmak için jdbc url'sini ilan ettik. Ardından bağlantının kullanıcı adını, şifresini ve havuz boyutunu açıkladık. Ayrıca "show_sql" öğesini true olarak etkinleştirerek SQL'i günlük dosyasında görmek istediğimizi belirttik. Bu özelliklerin ne anlama geldiğini anlamak için lütfen hazırda bekletme eğitimini okuyun.
Son olarak, mapping sınıfını bu bölümde oluşturacağımız com.tutorialspoint.hibernate.Student olarak ayarladık.
Çevre Kurulumu
Daha sonra bu proje için çok sayıda kavanoz gerekiyor. Ekte, gerekli JAR dosyalarının tam listesinin bir ekran görüntüsü bulunmaktadır -
JAR dosyalarının çoğu, destek dağıtımınızın bir parçası olarak edinilebilir. Glassfish, websphere veya jboss gibi bir uygulama sunucunuz kurulu ise, kalan jar dosyalarının çoğunu appserver'ın lib klasöründen alabilirsiniz. Değilse, dosyaları ayrı ayrı indirebilirsiniz -
Hazırda bekletme jar dosyaları - Hibernate.org
Struts hazırda bekletme eklentisi - Struts hibernate plugin
JTA dosyaları - JTA dosyaları
Dom4j dosyaları - Dom4j
log4j dosyaları - log4j
Dosyaların geri kalanı, Struts2 dağıtımınızdan alabilmeniz gerekir.
Hazırda Bekletme Sınıfları
Şimdi hazırda bekletme entegrasyonu için gerekli java sınıflarını oluşturalım. Aşağıdakilerin içeriğiStudent.java -
package com.tutorialspoint.hibernate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "student")
public class Student {
@Id
@GeneratedValue
private int id;
@Column(name = "last_name")
private String lastName;
@Column(name = "first_name")
private String firstName;
private int marks;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public int getMarks() {
return marks;
}
public void setMarks(int marks) {
this.marks = marks;
}
}Bu, bir POJO sınıfıdır. studentHazırda bekletme özelliğine göre tablo. Öğrenci tablosunun sütun adlarına karşılık gelen id, firstName ve lastName özelliklerine sahiptir. Sonra yaratalımStudentDAO.java aşağıdaki gibi dosya -
package com.tutorialspoint.hibernate;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.SessionTarget;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.TransactionTarget;
public class StudentDAO {
@SessionTarget
Session session;
@TransactionTarget
Transaction transaction;
@SuppressWarnings("unchecked")
public List<Student> getStudents() {
List<Student> students = new ArrayList<Student>();
try {
students = session.createQuery("from Student").list();
} catch(Exception e) {
e.printStackTrace();
}
return students;
}
public void addStudent(Student student) {
session.save(student);
}
}StudentDAO sınıfı, Öğrenci sınıfı için veri erişim katmanıdır. Tüm öğrencileri listelemek ve ardından yeni bir öğrenci kaydı kaydetmek için yöntemleri vardır.
Eylem Sınıfı
Dosya takip AddStudentAction.javaeylem sınıfımızı tanımlar. Burada iki eylem yöntemimiz var - execute () ve listStudents (). Execute () yöntemi yeni öğrenci kaydını eklemek için kullanılır. Bunu başarmak için dao'nun save () yöntemini kullanıyoruz.
Diğer yöntem olan listStudents () öğrencileri listelemek için kullanılır. Tüm öğrencilerin listesini almak için dao'nun liste yöntemini kullanıyoruz.
package com.tutorialspoint.struts2;
import java.util.ArrayList;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.tutorialspoint.hibernate.Student;
import com.tutorialspoint.hibernate.StudentDAO;
public class AddStudentAction extends ActionSupport implements ModelDriven<Student> {
Student student = new Student();
List<Student> students = new ArrayList<Student>();
StudentDAO dao = new StudentDAO();
@Override
public Student getModel() {
return student;
}
public String execute() {
dao.addStudent(student);
return "success";
}
public String listStudents() {
students = dao.getStudents();
return "success";
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}ModelDriven arayüzünü uyguladığımızı fark edeceksiniz. Bu, eylem sınıfınız tek tek özelliklerin (firstName, lastName gibi) aksine somut bir model sınıfıyla (Öğrenci gibi) ilgilendiğinde kullanılır. ModelAware arabirimi, modeli döndürmek için bir yöntem uygulamanızı gerektirir. Bizim durumumuzda "öğrenci" nesnesini iade ediyoruz.
Görünüm Dosyaları Oluşturun
Şimdi oluşturalım student.jsp aşağıdaki içeriğe sahip dosyayı görüntüleyin -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "addStudent">
<s:textfield name = "firstName" label = "First Name"/>
<s:textfield name = "lastName" label = "Last Name"/>
<s:textfield name = "marks" label = "Marks"/>
<s:submit/>
<hr/>
<table>
<tr>
<td>First Name</td>
<td>Last Name</td>
<td>Marks</td>
</tr>
<s:iterator value = "students">
<tr>
<td><s:property value = "firstName"/></td>
<td><s:property value = "lastName"/></td>
<td><s:property value = "marks"/></td>
</tr>
</s:iterator>
</table>
</s:form>
</body>
</html>Student.jsp oldukça basittir. Üst bölümde, "addStudent.action" a gönderen bir formumuz var. FirstName, lastName ve işaretleri alır. AddStudent eylemi ModelAware "AddSudentAction" a bağlı olduğundan, firstName, lastName değerleri ile otomatik olarak bir öğrenci bean oluşturulur ve otomatik olarak doldurulur.
Alt bölümde, öğrenciler listesine göz atıyoruz (bkz. AddStudentAction.java). Listeyi yineleriz ve bir tablodaki ad, soyad ve işaretler için değerleri görüntüleriz.
Dikmeler Yapılandırması
Kullanarak hepsini bir araya getirelim struts.xml -
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "myhibernate" extends = "hibernate-default">
<action name = "addStudent" method = "execute"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success" type = "redirect">
listStudents
</result>
</action>
<action name = "listStudents" method = "listStudents"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success">/students.jsp</result>
</action>
</package>
</struts>Burada dikkat edilmesi gereken önemli nokta, "myhibernate" paketimizin "hibernate-default" adı verilen struts2 varsayılan paketini genişletmesidir. Daha sonra iki eylem bildiriyoruz - addStudent ve listStudents. addStudent, AddStudentAction sınıfında execute () öğesini çağırır ve ardından başarıya ulaştığında listStudents eylem yöntemini çağırır.
ListStudent eylem yöntemi, AddStudentAction sınıfında listStudents () öğesini çağırır ve görünüm olarak student.jsp'yi kullanır.
Şimdi, proje adına sağ tıklayın ve Export > WAR FileSavaş dosyası oluşturmak için. Ardından bu SAVAŞI Tomcat'in webapps dizinine yerleştirin. Son olarak, Tomcat sunucusunu başlatın ve URL'ye erişmeyi deneyinhttp://localhost:8080/HelloWorldStruts2/student.jsp. Bu, aşağıdaki ekranı oluşturacaktır -
Üst bölümde, yeni bir öğrenci kaydı için değerleri girmek için bir form alıyoruz ve alt bölüm, öğrencileri veritabanında listeliyor. Devam edin ve yeni bir öğrenci kaydı ekleyin ve gönder düğmesine basın. Gönder'i her tıkladığınızda ekran yenilenecek ve size güncellenmiş bir liste gösterecektir.