İlkbahar - Hızlı Kılavuz
Spring, kurumsal Java için en popüler uygulama geliştirme çerçevesidir. Dünyanın dört bir yanındaki milyonlarca geliştirici, yüksek performanslı, kolayca test edilebilir ve yeniden kullanılabilir kodlar oluşturmak için Spring Framework'ü kullanıyor.
Spring framework, açık kaynaklı bir Java platformudur. Başlangıçta Rod Johnson tarafından yazılmış ve ilk olarak Haziran 2003'te Apache 2.0 lisansı altında piyasaya sürülmüştür.
Konu boyut ve şeffaflık olduğunda yay hafiftir. Spring çerçevesinin temel sürümü 2MB civarındadır.
Spring Framework'ün temel özellikleri herhangi bir Java uygulamasının geliştirilmesinde kullanılabilir, ancak Java EE platformunun üzerinde web uygulamaları oluşturmak için uzantılar vardır. Spring çerçevesi, J2EE geliştirmenin kullanımını kolaylaştırmayı hedefler ve POJO tabanlı bir programlama modelini etkinleştirerek iyi programlama uygulamalarını destekler.
Bahar Çerçevesini Kullanmanın Yararları
Spring Framework kullanmanın büyük faydalarından birkaçının listesi aşağıdadır -
Spring, geliştiricilerin POJO'ları kullanarak kurumsal sınıf uygulamalar geliştirmesine olanak tanır. Yalnızca POJO'ları kullanmanın yararı, uygulama sunucusu gibi bir EJB konteyner ürününe ihtiyacınız olmaması, ancak Tomcat gibi yalnızca sağlam bir servlet konteyneri veya bazı ticari ürünler kullanma seçeneğinizin olmasıdır.
Bahar modüler bir şekilde düzenlenmiştir. Paketlerin ve sınıfların sayısı önemli olsa da, yalnızca ihtiyacınız olanlar için endişelenmeli ve gerisini görmezden gelmelisiniz.
Bahar tekerleği yeniden icat etmez, bunun yerine birkaç ORM çerçevesi, günlükleme çerçevesi, JEE, Quartz ve JDK zamanlayıcıları ve diğer görünüm teknolojileri gibi mevcut teknolojilerin bazılarını gerçekten kullanır.
Spring ile yazılmış bir uygulamayı test etmek basittir çünkü ortama bağlı kod bu çerçeveye taşınır. Ayrıca, JavaBeanstyle POJO'larını kullanarak, test verilerini enjekte etmek için bağımlılık enjeksiyonu kullanmak daha kolay hale gelir.
Spring'in web çerçevesi, Struts veya diğer fazla tasarlanmış veya daha az popüler web çerçeveleri gibi web çerçevelerine harika bir alternatif sağlayan, iyi tasarlanmış bir web MVC çerçevesidir.
Spring, teknolojiye özgü istisnaları (örneğin, JDBC, Hibernate veya JDO tarafından atılan) tutarlı, kontrol edilmeyen istisnalara çevirmek için uygun bir API sağlar.
Hafif IoC konteynerler, özellikle örneğin EJB konteynerlerle karşılaştırıldığında hafif olma eğilimindedir. Bu, sınırlı belleğe ve CPU kaynaklarına sahip bilgisayarlarda uygulama geliştirmek ve dağıtmak için faydalıdır.
Spring, yerel bir işleme ölçeklenebilen (örneğin tek bir veritabanı kullanarak) ve küresel işlemlere kadar ölçeklenebilen (örneğin JTA kullanarak) tutarlı bir işlem yönetimi arabirimi sağlar.
Bağımlılık Enjeksiyonu (DI)
Spring'in en çok özdeşleştiği teknoloji, Dependency Injection (DI)Ters Kontrolün tadı. Inversion of Control (IoC)genel bir kavramdır ve birçok farklı şekilde ifade edilebilir. Bağımlılık Enjeksiyonu, Kontrolün Ters Çevrilmesi'nin somut bir örneğidir.
Karmaşık bir Java uygulaması yazarken, bu sınıfları yeniden kullanma olasılığını artırmak ve birim testi sırasında bunları diğer sınıflardan bağımsız olarak test etmek için uygulama sınıfları diğer Java sınıflarından olabildiğince bağımsız olmalıdır. Bağımlılık Enjeksiyonu, bu sınıfların birbirine yapıştırılmasına ve aynı zamanda bağımsız kalmasına yardımcı olur.
Bağımlılık enjeksiyonu tam olarak nedir? Bu iki kelimeye ayrı ayrı bakalım. Burada bağımlılık kısmı, iki sınıf arasındaki bir ilişkiye dönüşür. Örneğin, A sınıfı B sınıfına bağımlıdır. Şimdi ikinci bölüm olan enjeksiyona bakalım. Tüm bu, B sınıfının IoC tarafından A sınıfına enjekte edileceği anlamına gelir.
Bağımlılık enjeksiyonu, parametrelerin kurucuya iletilmesi şeklinde veya ayarlayıcı yöntemleri kullanılarak inşa sonrası gerçekleşebilir. Bağımlılık Enjeksiyonu, Bahar Çerçevesinin kalbi olduğundan, bu kavramı ayrı bir bölümde ilgili örnekle açıklayacağız.
Görünüşe Yönelik Programlama (AOP)
Baharın temel bileşenlerinden biri, Aspect Oriented Programming (AOP)çerçeve. Bir uygulamanın birden çok noktasını kapsayan işlevlerecross-cutting concernsve bu kesişen endişeler kavramsal olarak uygulamanın iş mantığından ayrıdır. Günlüğe kaydetme, bildirimsel işlemler, güvenlik, önbelleğe alma, vb. Dahil olmak üzere çeşitli yaygın iyi örnekler vardır.
OOP'de modülerliğin ana birimi sınıftır, oysa AOP'de modülerlik birimi görünümdür. DI, uygulama nesnelerinizi birbirinden ayırmanıza yardımcı olurken, AOP kesişen endişeleri etkiledikleri nesnelerden ayırmanıza yardımcı olur.
Spring Framework'ün AOP modülü, ayrılması gereken işlevselliği uygulayan kodu temiz bir şekilde ayırmak için yöntem durdurucuları ve nokta kesimlerini tanımlamanıza izin veren, yön odaklı bir programlama uygulaması sağlar. Bahar AOP kavramları hakkında ayrı bir bölümde daha fazla tartışacağız.
Spring, potansiyel olarak tüm kurumsal uygulamalarınız için tek adres olabilir. Ancak Spring modülerdir ve geri kalanını yanınızda getirmek zorunda kalmadan hangi modülleri sizin için uygun olduğunu seçmenize olanak tanır. Aşağıdaki bölüm, Spring Framework'te bulunan tüm modüller hakkında ayrıntılar sağlar.
Spring Framework, bir uygulama gereksinimine göre kullanılabilen yaklaşık 20 modül sağlar.
Çekirdek Konteyner
Çekirdek Kap, ayrıntıları aşağıdaki gibi Çekirdek, Fasulye, Bağlam ve İfade Dili modüllerinden oluşur -
Core modülü, IoC ve Bağımlılık Enjeksiyon özellikleri dahil olmak üzere çerçevenin temel parçalarını sağlar.
Bean modülü, fabrika modelinin gelişmiş bir uygulaması olan BeanFactory'yi sağlar.
Contextmodül, Core and Beans modülleri tarafından sağlanan katı temel üzerine kuruludur ve tanımlanan ve yapılandırılmış herhangi bir nesneye erişmek için bir ortamdır. ApplicationContext arabirimi, Context modülünün odak noktasıdır.
SpEL modülü, çalışma zamanında bir nesne grafiğini sorgulamak ve değiştirmek için güçlü bir ifade dili sağlar.
Veri Erişimi / Entegrasyonu
Veri Erişim / Entegrasyon katmanı, detayları aşağıdaki gibi olan JDBC, ORM, OXM, JMS ve İşlem modüllerinden oluşur -
JDBC modülü, sıkıcı JDBC ile ilgili kodlama ihtiyacını ortadan kaldıran bir JDBC-soyutlama katmanı sağlar.
ORM modülü, JPA, JDO, Hibernate ve iBatis dahil olmak üzere popüler nesne ilişkisel haritalama API'leri için entegrasyon katmanları sağlar.
OXM modülü JAXB, Castor, XMLBeans, JiBX ve XStream için Object / XML haritalama uygulamalarını destekleyen bir soyutlama katmanı sağlar.
Java Mesajlaşma Hizmeti JMS modülü, mesajların üretilmesi ve tüketilmesi için özellikler içerir.
Transaction modülü, özel arabirimler uygulayan sınıflar ve tüm POJO'larınız için programlı ve bildirim temelli işlem yönetimini destekler.
ağ
Web katmanı, ayrıntıları aşağıdaki gibi olan Web, Web-MVC, Web-Socket ve Web-Portlet modüllerinden oluşur -
Web modülü, çok parçalı dosya yükleme işlevi ve servlet dinleyicileri ve web odaklı bir uygulama bağlamı kullanarak IoC konteynerinin başlatılması gibi temel web odaklı entegrasyon özellikleri sağlar.
Web-MVC modül, web uygulamaları için Spring'in Model-View-Controller (MVC) uygulamasını içerir.
Web-Socket modülü, web uygulamalarında istemci ve sunucu arasında WebSocket tabanlı, iki yönlü iletişim için destek sağlar.
Web-Portlet modül, bir portlet ortamında kullanılmak üzere MVC uygulamasını sağlar ve Web-Servlet modülünün işlevselliğini yansıtır.
Çeşitli
Ayrıntıları aşağıdaki gibi olan AOP, Yönler, Enstrümantasyon, Web ve Test modülleri gibi birkaç önemli modül vardır -
AOP modül, ayrılması gereken işlevselliği uygulayan kodu temiz bir şekilde ayırmak için yöntem durdurucuları ve nokta kesimlerini tanımlamanıza olanak tanıyan, yön odaklı bir programlama uygulaması sağlar.
Aspects modülü yine güçlü ve olgun bir AOP çerçevesi olan AspectJ ile entegrasyon sağlar.
Instrumentation modülü, belirli uygulama sunucularında kullanılmak üzere sınıf enstrümantasyon desteği ve sınıf yükleyici uygulamaları sağlar.
Messagingmodül, uygulamalarda kullanılacak WebSocket alt protokolü olarak STOMP için destek sağlar. Ayrıca, WebSocket istemcilerinden STOMP mesajlarının yönlendirilmesi ve işlenmesi için bir açıklama programlama modelini destekler.
Test modül, JUnit veya TestNG çerçeveleriyle Spring bileşenlerinin test edilmesini destekler.
Bu bölüm, Spring Framework ile çalışmanıza başlamak için bir geliştirme ortamını nasıl hazırlayacağınız konusunda size rehberlik edecektir. Ayrıca Spring Framework'ü kurmadan önce makinenizde JDK, Tomcat ve Eclipse'in nasıl kurulacağını da öğretecektir -
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 başvuracak şekilde ayarlayın, tipik olarak sırasıyla java_install_dir / bin ve java_install_dir.
Windows çalıştırıyorsanız ve JDK'yi C: \ jdk1.6.0_15'e yüklediyseniz, aşağıdaki satırı C: \ autoexec.bat dosyanıza koymanız gerekir.
set PATH=C:\jdk1.6.0_15\bin;%PATH%
set JAVA_HOME=C:\jdk1.6.0_15Alternatif olarak, Windows NT / 2000 / XP'de Bilgisayarım'a sağ tıklamanız, Özellikler → Gelişmiş → Ortam Değişkenleri'ni seçmeniz gerekecektir. Ardından, PATH değerini güncellemeniz ve OK düğmesine tıklamanız gerekecektir.
Unix'te (Solaris, Linux, vb.), SDK /usr/local/jdk1.6.0_15'e kuruluysa ve C kabuğunu kullanıyorsanız, aşağıdakileri .cshrc dosyanıza koymanız gerekecektir.
setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.6.0_15Alternatif 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 derlemeniz ve çalıştırmanız gerekecektir. Aksi takdirde, IDE belgesinde verildiği gibi uygun bir kurulum yapmanız gerekecektir.
Adım 2 - Apache Common Logging API'yi yükleyin
Apache Commons Logging API'nin en son sürümünü şu adresten indirebilirsiniz: https://commons.apache.org/logging/. Kurulumu indirdikten sonra, ikili dağıtımı uygun bir konuma açın. Örneğin, Windows'ta C: \ commons-logging-1.1.1 veya Linux / Unix'te /usr/local/commons-logging-1.1.1'de. Bu dizinde aşağıdaki jar dosyaları ve diğer destekleyici belgeler vb.
Bu dizinde CLASSPATH değişkeninizi doğru bir şekilde ayarladığınızdan emin olun, aksi takdirde uygulamanızı çalıştırırken bir sorunla karşılaşacaksınız.
Adım 3 - Eclipse IDE'yi Kurun
Bu eğitimdeki tüm örnekler Eclipse IDE kullanılarak yazılmıştır. Bu nedenle, makinenize Eclipse'in en son sürümünü yüklemenizi öneririz.
Eclipse IDE'yi 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 - Spring Framework Kitaplıklarını Kurun
Şimdi her şey yolundaysa, Spring çerçevenizi kurmaya devam edebilirsiniz. Çerçeveyi makinenize indirip kurmanın basit adımları aşağıdadır.
Spring'i 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.
Spring framework ikili dosyalarının en son sürümünü şuradan indirin: https://repo.spring.io/release/org/springframework/spring.
Bu öğreticiyi geliştirirken, spring-framework-4.1.6.RELEASE-dist.zipWindows makineye indirildi. İndirilen dosya sıkıştırıldıktan sonra, E: \ spring içinde aşağıdaki dizin yapısını verir.
Tüm Bahar kütüphanelerini dizinde bulacaksınız. E:\spring\libs. Bu dizinde CLASSPATH değişkeninizi doğru bir şekilde ayarladığınızdan emin olun, aksi takdirde uygulamanızı çalıştırırken bir sorunla karşılaşacaksınız. Eclipse kullanıyorsanız, tüm ayarlar Eclipse aracılığıyla yapılacağından CLASSPATH'ı ayarlamanız gerekmez.
Bu son adımı tamamladığınızda, bir sonraki bölümdeki ilk Bahar Örneğinize geçmeye hazırsınız.
Spring Framework ile gerçek programlamaya başlayalım. Spring çerçevesini kullanarak ilk örneğinizi yazmaya başlamadan önce, Spring - Environment Setup Chapter'da açıklandığı gibi Spring ortamınızı doğru bir şekilde kurduğunuzdan emin olmalısınız . Ayrıca Eclipse IDE hakkında biraz çalışma bilgisine sahip olduğunuzu varsayıyoruz.
Şimdi basit bir Bahar Uygulaması yazalım, "Merhaba Dünya!" veya Spring Beans Yapılandırma dosyasında yapılan yapılandırmaya dayalı başka herhangi bir mesaj.
Adım 1 - Java Projesi Oluşturun
İlk adım, Eclipse IDE'yi kullanarak basit bir Java Projesi oluşturmaktır. Seçeneği takip edinFile → New → Project ve son olarak seçin Java Projectsihirbaz listesinden sihirbaz. Şimdi projenizi şu şekilde adlandırın:HelloSpring sihirbaz penceresini aşağıdaki gibi kullanarak -
Projeniz başarıyla oluşturulduktan sonra, aşağıdaki içeriğe sahip olacaksınız. Project Explorer -
Adım 2 - Gerekli Kitaplıkları Ekleyin
İkinci adım olarak projemize Spring Framework ve ortak günlük API kitaplıkları ekleyelim. Bunu yapmak için proje adınıza sağ tıklayınHelloSpring ve ardından bağlam menüsünde bulunan aşağıdaki seçeneği izleyin - Build Path → Configure Build Path Java Derleme Yolu penceresini aşağıdaki gibi görüntülemek için -
Şimdi kullan Add External JARs altında bulunan düğme Libraries Spring Framework ve Common Logging kurulum dizinlerinden aşağıdaki temel JAR'ları eklemek için sekme -
commons-logging-1.1.1
spring-aop-4.1.6.RELEASE
spring-aspects-4.1.6.RELEASE
spring-beans-4.1.6.RELEASE
spring-context-4.1.6.RELEASE
spring-context-support-4.1.6.RELEASE
spring-core-4.1.6.RELEASE
spring-expression-4.1.6.RELEASE
spring-instrument-4.1.6.RELEASE
spring-instrument-tomcat-4.1.6.RELEASE
spring-jdbc-4.1.6.RELEASE
spring-jms-4.1.6.RELEASE
spring-messaging-4.1.6.RELEASE
spring-orm-4.1.6.RELEASE
spring-oxm-4.1.6.RELEASE
spring-test-4.1.6.RELEASE
spring-tx-4.1.6.RELEASE
spring-web-4.1.6.RELEASE
spring-webmvc-4.1.6.RELEASE
spring-webmvc-portlet-4.1.6.RELEASE
spring-websocket-4.1.6.RELEASE
Adım 3 - Kaynak Dosyaları Oluşturun
Şimdi gerçek kaynak dosyaları oluşturalım. HelloSpringproje. Önce adında bir paket oluşturmalıyızcom.tutorialspoint. Bunu yapmak için sağ tıklayınsrc paket gezgini bölümünde aşağıdaki seçeneği izleyin - New → Package.
Sonra yaratacağız HelloWorld.java ve MainApp.java com.tutorialspoint paketi altındaki dosyalar.
İşte içeriği HelloWorld.java dosya -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}İkinci dosyanın içeriği aşağıdadır MainApp.java -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
}
}Ana program hakkında aşağıdaki iki önemli noktaya dikkat edilmelidir:
İlk adım, çerçeve API'yi kullandığımız bir uygulama bağlamı oluşturmaktır ClassPathXmlApplicationContext(). Bu API, fasulye konfigürasyon dosyasını yükler ve sonunda sağlanan API'ye bağlı olarak, tüm nesneleri, yani konfigürasyon dosyasında belirtilen fasulyeleri, oluşturmayı ve başlatmayı üstlenir.
İkinci adım, gerekli fasulyeyi kullanarak elde etmek için kullanılır. getBean()oluşturulan bağlamın yöntemi. Bu yöntem, en sonunda gerçek nesneye dönüştürülebilecek genel bir nesne döndürmek için fasulye kimliğini kullanır. Bir nesneye sahip olduğunuzda, herhangi bir sınıf yöntemini çağırmak için bu nesneyi kullanabilirsiniz.
Adım 4 - Bean Yapılandırma Dosyası Oluşturun
Bir XML dosyası olan ve fasulyeleri, yani sınıfları birbirine yapıştıran bir çimento görevi gören bir Bean Yapılandırma dosyası oluşturmanız gerekir. Bu dosyanın oluşturulması gerekiyorsrc aşağıdaki ekran görüntüsünde gösterildiği gibi dizin -
Genellikle geliştiriciler bu dosyayı şu şekilde adlandırır: Beans.xml, ancak istediğiniz herhangi bir ismi seçmekte özgürsünüz. Bu dosyanın CLASSPATH'da mevcut olduğundan emin olmanız ve MainApp.java dosyasında gösterildiği gibi bir uygulama bağlamı oluştururken ana uygulamada aynı adı kullanmanız gerekir.
Beans.xml, farklı çekirdeklere benzersiz kimlikler atamak ve herhangi bir Spring kaynak dosyasını etkilemeden farklı değerlere sahip nesnelerin oluşturulmasını kontrol etmek için kullanılır. Örneğin, aşağıdaki dosyayı kullanarak "mesaj" değişkeni için herhangi bir değer iletebilir ve HelloWorld.java ve MainApp.java dosyalarını etkilemeden farklı mesaj değerleri yazdırabilirsiniz. Nasıl çalıştığını görelim -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>Spring uygulaması belleğe yüklendiğinde, Framework tanımlanan tüm fasulyeleri oluşturmak için yukarıdaki konfigürasyon dosyasını kullanır ve bunlara şurada tanımlandığı gibi benzersiz bir kimlik atar. <bean>etiket. Kullanabilirsiniz<property> nesne oluşturma sırasında kullanılan farklı değişkenlerin değerlerini iletmek için etiket.
Adım 5 - Programı Çalıştırmak
Kaynak ve fasulye yapılandırma dosyalarını oluşturmayı tamamladığınızda, programınızı derleyen ve çalıştıran bu adıma hazırsınız. Bunu yapmak için MainApp.Java dosyası sekmesini aktif tutun ve ikisinden birini kullanınRun Eclipse IDE'de mevcut seçenek veya kullanım Ctrl + F11 derlemek ve çalıştırmak için MainAppuygulama. Uygulamanızda her şey yolundaysa, bu, Eclipse IDE'nin konsolunda aşağıdaki mesajı yazdıracaktır -
Your Message : Hello World!Tebrikler, ilk Bahar Başvurunuzu başarıyla oluşturdunuz. Yukarıdaki Spring uygulamasının esnekliğini "message" özelliğinin değerini değiştirerek ve her iki kaynak dosyayı değiştirmeden tutarak görebilirsiniz.
Yay konteyneri, Yay Çerçevesinin merkezindedir. Konteyner, nesneleri yaratacak, bunları birbirine bağlayacak, yapılandıracak ve yaratılıştan imha edilmesine kadar tüm yaşam döngülerini yönetecek. Spring konteyner, bir uygulamayı oluşturan bileşenleri yönetmek için DI kullanır. Bu nesnelere, bir sonraki bölümde tartışacağımız Bahar Fasulyesi adı verilir.
Kap, sağlanan yapılandırma meta verilerini okuyarak hangi nesnelerin başlatılacağı, yapılandırılacağı ve birleştirileceği hakkındaki talimatlarını alır. Yapılandırma meta verileri, XML, Java notları veya Java kodu ile temsil edilebilir. Aşağıdaki diyagram, Spring'in nasıl çalıştığına dair üst düzey bir görünümü temsil etmektedir. Spring IoC konteyneri, tam olarak yapılandırılmış ve yürütülebilir bir sistem veya uygulama üretmek için Java POJO sınıflarını ve yapılandırma meta verilerini kullanır.
Yay, aşağıdaki iki farklı tipte kap sağlar.
| Sr.No. | Konteyner ve Açıklama |
|---|---|
| 1 | Spring BeanFactory Konteyner Bu, DI için temel desteği sağlayan en basit kapsayıcıdır ve org.springframework.beans.factory.BeanFactory arabirimi tarafından tanımlanır . BeanFactory ve BeanFactoryAware, InitializingBean, DisposableBean gibi ilgili arayüzler, Spring ile entegre olan çok sayıda üçüncü taraf çerçeveyle geriye dönük uyumluluk amacıyla hala Spring'te mevcuttur. |
| 2 | Spring ApplicationContext Konteyner Bu kapsayıcı, bir özellikler dosyasından metin mesajlarını çözme yeteneği ve ilgili olay dinleyicilerine uygulama olaylarını yayınlama yeteneği gibi daha fazla kuruma özgü işlevsellik ekler. Bu kapsayıcı, org.springframework.context.ApplicationContext arabirimi tarafından tanımlanır . |
ApplicationContext konteyner tüm işlevselliği BeanFactory genellikle üzerinde tavsiye edilir, böylece kabın BeanFactory . BeanFactory, veri hacmi ve hızının önemli olduğu mobil cihazlar veya uygulama tabanlı uygulamalar gibi hafif uygulamalar için hala kullanılabilir.
Uygulamanızın omurgasını oluşturan ve Spring IoC konteyner tarafından yönetilen nesneler denir beans. Fasulye, bir Spring IoC konteyneri tarafından örneklenen, bir araya getirilen ve başka şekilde yönetilen bir nesnedir. Bu çekirdekler, konteynere sağladığınız konfigürasyon meta verileriyle oluşturulur. Örneğin, önceki bölümlerde gördüğünüz XML <bean /> tanımları biçiminde.
Fasulye tanımı, adı verilen bilgileri içerir configuration metadata, konteynerin aşağıdakileri bilmesi için gerekli olan -
- Fasulye nasıl oluşturulur
- Bean yaşam döngüsü ayrıntıları
- Bean bağımlılıkları
Yukarıdaki konfigürasyon meta verilerinin tümü, her bir fasulye tanımını oluşturan aşağıdaki özelliklerin bir kümesine çevrilir.
| Sr.No. | Özellikler ve Açıklama |
|---|---|
| 1 | class Bu öznitelik zorunludur ve çekirdeği oluşturmak için kullanılacak fasulye sınıfını belirtir. |
| 2 | name Bu öznitelik, fasulye tanımlayıcısını benzersiz bir şekilde belirtir. XML tabanlı konfigürasyon meta verilerinde, fasulye tanımlayıcılarını belirtmek için id ve / veya name niteliklerini kullanırsınız. |
| 3 | scope Bu özellik, belirli bir fasulye tanımından yaratılan nesnelerin kapsamını belirtir ve fasulye kapsamları bölümünde tartışılacaktır. |
| 4 | constructor-arg Bu, bağımlılıkları enjekte etmek için kullanılır ve sonraki bölümlerde tartışılacaktır. |
| 5 | properties Bu, bağımlılıkları enjekte etmek için kullanılır ve sonraki bölümlerde tartışılacaktır. |
| 6 | autowiring mode Bu, bağımlılıkları enjekte etmek için kullanılır ve sonraki bölümlerde tartışılacaktır. |
| 7 | lazy-initialization mode Tembel başlatılmış bir fasulye, IoC konteynerine başlangıçta değil, ilk istendiğinde bir fasulye örneği oluşturmasını söyler. |
| 8 | initialization method Çekirdek üzerindeki tüm gerekli özellikler konteyner tarafından ayarlandıktan hemen sonra çağrılacak bir geri arama. Fasulye yaşam döngüsü bölümünde tartışılacaktır. |
| 9 | destruction method Çekirdeği içeren kap yok edildiğinde kullanılacak bir geri arama. Fasulye yaşam döngüsü bölümünde tartışılacaktır. |
Bahar Yapılandırması Meta Verileri
Spring IoC konteyneri, bu konfigürasyon meta verilerinin gerçekte yazıldığı formattan tamamen bağımsızdır. Spring Container'a yapılandırma meta verileri sağlamanın üç önemli yöntemi şunlardır:
- XML tabanlı konfigürasyon dosyası.
- Ek açıklama tabanlı yapılandırma
- Java tabanlı konfigürasyon
XML tabanlı yapılandırma meta verilerinin konteynere nasıl sağlandığını zaten gördünüz, ancak tembel başlatma, başlatma yöntemi ve imha yöntemi dahil olmak üzere farklı fasulye tanımlarına sahip başka bir XML tabanlı yapılandırma dosyası örneği görelim -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- A simple bean definition -->
<bean id = "..." class = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with lazy init set on -->
<bean id = "..." class = "..." lazy-init = "true">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with initialization method -->
<bean id = "..." class = "..." init-method = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with destruction method -->
<bean id = "..." class = "..." destroy-method = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- more bean definitions go here -->
</beans>Kontrol edebilirsiniz Bahar Merhaba Dünya Örneği , yapılandır tanımlayabilir ve Bahar fasulye nasıl oluşturulduğunu anlamak için.
Ek Açıklama Tabanlı Yapılandırma hakkında ayrı bir bölümde tartışacağız. Ek Açıklamalarla Yay Bağımlılık Enjeksiyonu ile programlamaya başlamadan önce, diğer birkaç önemli Bahar kavramını anlamanızı istediğimizden, ayrı bir bölümde kasıtlı olarak tartışılmıştır.
Bir <bean> tanımlarken, o fasulye için bir kapsam belirtme seçeneğiniz vardır. Örneğin, Spring'i her ihtiyaç duyulduğunda yeni bir fasulye örneği üretmeye zorlamak için, bean'in kapsam özniteliğini şöyle beyan etmelisiniz:prototype. Benzer şekilde, Spring'in her ihtiyaç duyulduğunda aynı bean örneğini döndürmesini istiyorsanız, bean'ın kapsam özniteliğini olarak beyan etmelisiniz.singleton.
Spring Framework, üçü yalnızca web uyumlu bir ApplicationContext kullanıyorsanız mevcut olan aşağıdaki beş kapsamı destekler.
| Sr.No. | Kapsam ve Açıklama |
|---|---|
| 1 | singleton Bu, fasulye tanımını Spring IoC kabı başına tek bir örneğe kapsamaktadır (varsayılan). |
| 2 | prototype Bu, herhangi bir sayıda nesne örneğine sahip olmak için tek bir fasulye tanımını kapsar. |
| 3 | request Bu, bir HTTP isteğine bir fasulye tanımını kapsar. Yalnızca web'e duyarlı bir Spring ApplicationContext bağlamında geçerlidir. |
| 4 | session Bu, bir HTTP oturumunun bean tanımını kapsar. Yalnızca web'e duyarlı bir Spring ApplicationContext bağlamında geçerlidir. |
| 5 | global-session Bu, genel bir HTTP oturumuna bir fasulye tanımını kapsar. Yalnızca web'e duyarlı bir Spring ApplicationContext bağlamında geçerlidir. |
Bu bölümde, ilk iki kapsam hakkında tartışacağız ve kalan üçü, web'e duyarlı Spring ApplicationContext hakkında tartıştığımızda tartışılacaktır.
Singleton kapsamı
Bir kapsam singleton olarak ayarlanmışsa, Spring IoC konteyneri bu fasulye tanımıyla tanımlanan nesnenin tam olarak bir örneğini oluşturur. Bu tek örnek, bu tür tekli çekirdeklerin bir önbelleğinde saklanır ve bu adlandırılmış fasulye için tüm sonraki istekler ve başvurular önbelleğe alınan nesneyi döndürür.
Varsayılan kapsam her zaman tekildir. Ancak, bir fasulyenin bir örneğine ihtiyacınız olduğunda,scope mülkiyet singleton fasulye yapılandırma dosyasında, aşağıdaki kod parçacığında gösterildiği gibi -
<!-- A bean definition with singleton scope -->
<bean id = "..." class = "..." scope = "singleton">
<!-- collaborators and configuration for this bean go here -->
</bean>Misal
Çalışan bir Eclipse IDE'ye sahip olalım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları atalım -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Com.tutorialspoint paketi altında HelloWorld ve MainApp Java sınıfları oluşturun . |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği HelloWorld.java dosya -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Aşağıdakilerin içeriği MainApp.java dosya -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}Yapılandırma dosyası aşağıdadır Beans.xml singleton kapsamı için gerekli -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "singleton">
</bean>
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
Your Message : I'm object A
Your Message : I'm object APrototip kapsamı
Kapsam prototip olarak ayarlanmışsa, Spring IoC konteyneri o belirli fasulye için her talep yapıldığında nesnenin yeni bir fasulye örneğini oluşturur. Kural olarak, tüm eyalet-dolu çekirdekler için prototip kapsamını ve devletsiz çekirdekler için tekli kapsamı kullanın.
Bir prototip kapsamı tanımlamak için, scope mülkiyet prototype fasulye yapılandırma dosyasında, aşağıdaki kod parçacığında gösterildiği gibi -
<!-- A bean definition with prototype scope -->
<bean id = "..." class = "..." scope = "prototype">
<!-- collaborators and configuration for this bean go here -->
</bean>Misal
Eclipse IDE'yi yerinde çalıştıralım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları takip edelim -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Com.tutorialspoint paketi altında HelloWorld ve MainApp Java sınıfları oluşturun . |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği HelloWorld.java dosya
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Aşağıdakilerin içeriği MainApp.java dosya -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}Yapılandırma dosyası aşağıdadır Beans.xml prototip kapsamı için gerekli -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "prototype">
</bean>
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
Your Message : I'm object A
Your Message : nullBir Bahar fasulyesinin yaşam döngüsünün anlaşılması kolaydır. Bir fasulye somutlaştırıldığında, onu kullanılabilir bir duruma getirmek için bazı başlatma işlemlerinin gerçekleştirilmesi gerekebilir. Benzer şekilde, çekirdek artık gerekli olmadığında ve kaptan çıkarıldığında, bir miktar temizlik gerekebilir.
Fasulye Örnekleme zamanı ile imhası arasında sahnenin arkasında gerçekleşen faaliyetlerin listeleri olsa da, bu bölümde fasulyenin başlatılması ve yok edilmesi sırasında gerekli olan yalnızca iki önemli fasulye yaşam döngüsü geri çağırma yöntemi tartışılacaktır.
Bir fasulyenin kurulumunu ve sökülmesini tanımlamak için, basitçe <bean> initmethod ve / veya destroy-methodparametreleri. İnit-method özniteliği, somutlaştırmanın hemen ardından bean üzerinde çağrılacak bir yöntemi belirtir. Benzer şekilde, destroymethod, bir fasulye konteynerden çıkarılmadan hemen önce çağrılan bir yöntemi belirtir.
Başlatma geri aramaları
Org.springframework.beans.factory.InitializingBean arayüzü tek bir yöntemi belirtir -
void afterPropertiesSet() throws Exception;Böylece, yukarıdaki arayüzü basitçe uygulayabilirsiniz ve ilklendirme çalışması afterPropertiesSet () yöntemi içinde aşağıdaki gibi yapılabilir -
public class ExampleBean implements InitializingBean {
public void afterPropertiesSet() {
// do some initialization work
}
}XML tabanlı konfigürasyon meta verileri durumunda, init-methodvoid no-argument imzası olan yöntemin adını belirtmek için öznitelik. Örneğin -
<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>Sınıf tanımı aşağıdadır -
public class ExampleBean {
public void init() {
// do some initialization work
}
}İmha geri aramaları
Org.springframework.beans.factory.DisposableBean arayüz tek bir yöntemi kapsar -
void destroy() throws Exception;Böylece, yukarıdaki arayüzü basitçe uygulayabilir ve sonlandırma çalışması destroy () metodu içinde aşağıdaki gibi yapılabilir -
public class ExampleBean implements DisposableBean {
public void destroy() {
// do some destruction work
}
}XML tabanlı konfigürasyon meta verileri durumunda, destroy-methodvoid no-argument imzası olan yöntemin adını belirtmek için öznitelik. Örneğin -
<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>Sınıf tanımı aşağıdadır -
public class ExampleBean {
public void destroy() {
// do some destruction work
}
}Spring'in IoC konteynerini web dışı bir uygulama ortamında kullanıyorsanız; örneğin, zengin bir istemci masaüstü ortamında, JVM ile bir kapatma kancası kaydedersiniz. Bunu yapmak, zarif bir kapatma sağlar ve tekli çekirdeklerinizdeki ilgili yok etme yöntemlerini çağırır, böylece tüm kaynaklar serbest bırakılır.
InitializingBean veya DisposableBean geri aramalarını kullanmamanız önerilir, çünkü XML yapılandırması yönteminizi adlandırma açısından büyük esneklik sağlar.
Misal
Çalışan bir Eclipse IDE'ye sahip olalım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları atalım -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Com.tutorialspoint paketi altında HelloWorld ve MainApp Java sınıfları oluşturun . |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği HelloWorld.java dosya -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy() {
System.out.println("Bean will destroy now.");
}
}Aşağıdakilerin içeriği MainApp.javadosya. Burada bir kapatma kancası kaydetmeniz gerekiyorregisterShutdownHook()AbstractApplicationContext sınıfında bildirilen yöntem. Bu, sorunsuz bir kapatma sağlar ve ilgili yok etme yöntemlerini çağırır.
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}Yapılandırma dosyası aşağıdadır Beans.xml başlatma ve yok etme yöntemleri için gereklidir -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" init-method = "init"
destroy-method = "destroy">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
Bean is going through init.
Your Message : Hello World!
Bean will destroy now.Varsayılan başlatma ve yok etme yöntemleri
Aynı ada sahip başlatma ve / veya yok etme yöntemlerine sahip çok fazla fasulyeniz varsa, beyan etmenize gerek yoktur. init-method ve destroy-methodher bir fasulyede. Bunun yerine çerçeve, bu tür bir durumu,default-init-method ve default-destroy-method <beans> öğesindeki öznitelikler aşağıdaki gibidir -
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
default-init-method = "init"
default-destroy-method = "destroy">
<bean id = "..." class = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
</beans>BeanPostProcessor arabirim, kendi örnekleme mantığınızı, bağımlılık çözümleme mantığınızı vb. sağlamak için uygulayabileceğiniz geri çağırma yöntemlerini tanımlar. Ayrıca, Spring kapsayıcı bir veya daha fazla BeanPostProcessor uygulamasını takarak bir fasulyeyi örneklemeyi, yapılandırmayı ve başlatmayı bitirdikten sonra da bazı özel mantık uygulayabilirsiniz. .
Birden çok BeanPostProcessor arabirimini yapılandırabilir ve bu BeanPostProcessor arabirimlerinin hangi sırayla yürütüleceğini kontrol edebilirsiniz. order özellik, BeanPostProcessor'ın Ordered arayüz.
BeanPostProcessors, bean (veya nesne) örneklerinde çalışır; bu, Spring IoC konteynerinin bir bean örneğini başlattığı ve ardından BeanPostProcessor arabirimlerinin işlerini yaptığı anlamına gelir.
Bir ApplicationContext otomatik olarak algılar. BeanPostProcessor arabirim oluşturur ve bu çekirdekleri sonradan işlemciler olarak kaydeder ve daha sonra çekirdek oluşturulduktan sonra kap tarafından uygun şekilde çağrılır.
Misal
Aşağıdaki örnekler, bir ApplicationContext bağlamında BeanPostProcessors'ın nasıl yazılacağını, kaydedileceğini ve kullanılacağını gösterir.
Çalışan bir Eclipse IDE'ye sahip olalım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları atalım -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Com.tutorialspoint paketi altında HelloWorld , InitHelloWorld ve MainApp Java sınıfları oluşturun . |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği HelloWorld.java dosya -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy(){
System.out.println("Bean will destroy now.");
}
}Bu, herhangi bir çekirdeğin başlatılmasından önce ve sonra bir fasulye adı yazdıran BeanPostProcessor uygulamasının çok temel bir örneğidir. Bir fasulyeyi kullanıma sunmadan önce ve sonra daha karmaşık bir mantık uygulayabilirsiniz çünkü her iki son işlemci yönteminde de fasulye nesnesine erişiminiz vardır.
İşte içeriği InitHelloWorld.java dosya -
package com.tutorialspoint;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;
public class InitHelloWorld implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("BeforeInitialization : " + beanName);
return bean; // you can return any other object as well
}
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("AfterInitialization : " + beanName);
return bean; // you can return any other object as well
}
}Aşağıdakilerin içeriği MainApp.javadosya. Burada bir kapatma kancası kaydetmeniz gerekiyorregisterShutdownHook()AbstractApplicationContext sınıfında bildirilen yöntem. Bu, sorunsuz bir kapatma sağlar ve ilgili yok etme yöntemlerini çağırır.
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}Yapılandırma dosyası aşağıdadır Beans.xml başlatma ve yok etme yöntemleri için gereklidir -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
init-method = "init" destroy-method = "destroy">
<property name = "message" value = "Hello World!"/>
</bean>
<bean class = "com.tutorialspoint.InitHelloWorld" />
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturduktan sonra uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.Bean tanımı, yapıcı bağımsız değişkenleri, özellik değerleri ve başlatma yöntemi, statik fabrika yöntemi adı vb. Gibi kapsayıcıya özgü bilgiler dahil olmak üzere birçok yapılandırma bilgisi içerebilir.
Bir alt fasulye tanımı, yapılandırma verilerini bir üst tanımdan devralır. Çocuk tanımı, gerektiğinde bazı değerleri geçersiz kılabilir veya diğerlerini ekleyebilir.
Spring Bean tanım kalıtımının Java sınıfı kalıtımla ilgisi yoktur, ancak kalıtım kavramı aynıdır. Bir ana çekirdek tanımını şablon olarak tanımlayabilirsiniz ve diğer alt fasulyeler, gerekli yapılandırmayı ana fasulyeden devralabilir.
XML tabanlı yapılandırma meta verilerini kullandığınızda, bir alt fasulye tanımını belirtirsiniz. parent öznitelik, bu özniteliğin değeri olarak ana fasulyeyi belirtir.
Misal
Çalışan bir Eclipse IDE'ye sahip olalım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları atalım -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Com.tutorialspoint paketi altında HelloWorld , HelloIndia ve MainApp Java sınıfları oluşturun . |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
Yapılandırma dosyası aşağıdadır Beans.xmlBurada message1 ve message2 olmak üzere iki özelliğe sahip "merhabaDünya" fasulyesini tanımladık . Sonraki "merhabaHindistan" fasulyesi, kullanılarak "merhabaDünya" fasulyesinin çocuğu olarak tanımlandıparentöznitelik. Alt fasulye, message2 özelliğini olduğu gibi devralır ve message1 özelliğini geçersiz kılar ve bir tane daha message3 özelliği sunar .
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message1" value = "Hello World!"/>
<property name = "message2" value = "Hello Second World!"/>
</bean>
<bean id ="helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "helloWorld">
<property name = "message1" value = "Hello India!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
</beans>İşte içeriği HelloWorld.java dosya -
package com.tutorialspoint;
public class HelloWorld {
private String message1;
private String message2;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void getMessage1(){
System.out.println("World Message1 : " + message1);
}
public void getMessage2(){
System.out.println("World Message2 : " + message2);
}
}İşte içeriği HelloIndia.java dosya -
package com.tutorialspoint;
public class HelloIndia {
private String message1;
private String message2;
private String message3;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void setMessage3(String message){
this.message3 = message;
}
public void getMessage1(){
System.out.println("India Message1 : " + message1);
}
public void getMessage2(){
System.out.println("India Message2 : " + message2);
}
public void getMessage3(){
System.out.println("India Message3 : " + message3);
}
}Aşağıdakilerin içeriği MainApp.java dosya -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.getMessage1();
objA.getMessage2();
HelloIndia objB = (HelloIndia) context.getBean("helloIndia");
objB.getMessage1();
objB.getMessage2();
objB.getMessage3();
}
}Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
World Message1 : Hello World!
World Message2 : Hello Second World!
India Message1 : Hello India!
India Message2 : Hello Second World!
India Message3 : Namaste India!Burada gözlemlediyseniz, "helloIndia" fasulyesini oluştururken mesaj2'yi iletmedik, ancak Bean Tanımı Devralması nedeniyle geçti.
Fasulye Tanım Şablonu
Çok fazla çaba harcamadan diğer alt fasulye tanımları tarafından kullanılabilecek bir Bean tanımı şablonu oluşturabilirsiniz. Bir Bean Tanım Şablonu tanımlarken,class öznitelik ve belirtmeli abstract öznitelik ve soyut özniteliği bir değerle belirtmelidir true aşağıdaki kod parçacığında gösterildiği gibi -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "beanTeamplate" abstract = "true">
<property name = "message1" value = "Hello World!"/>
<property name = "message2" value = "Hello Second World!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
<bean id = "helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "beanTeamplate">
<property name = "message1" value = "Hello India!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
</beans>Üst fasulye, eksik olduğu için kendi başına örneklenemez ve ayrıca açıkça soyut olarak işaretlenmiştir . Bir tanım bu şekilde soyut olduğunda, yalnızca çocuk tanımları için bir ana tanım olarak hizmet eden saf bir şablon fasulye tanımı olarak kullanılabilir.
Her Java tabanlı uygulamanın, son kullanıcının çalışan bir uygulama olarak gördüklerini sunmak için birlikte çalışan birkaç nesnesi vardır. Karmaşık bir Java uygulaması yazarken, bu sınıfları yeniden kullanma olasılığını artırmak ve birim testi sırasında bunları diğer sınıflardan bağımsız olarak test etmek için uygulama sınıfları diğer Java sınıflarından olabildiğince bağımsız olmalıdır. Bağımlılık Enjeksiyonu (veya bazen kablolama olarak adlandırılır), bu sınıfları birbirine yapıştırmaya ve aynı zamanda bağımsız tutmaya yardımcı olur.
Metin düzenleyici bileşeni olan bir uygulamanız olduğunu ve bir yazım denetimi sağlamak istediğinizi düşünün. Standart kodunuz şuna benzer -
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor() {
spellChecker = new SpellChecker();
}
}Burada yaptığımız şey, TextEditor ve SpellChecker arasında bir bağımlılık yaratmaktır. Kontrol senaryosunun tersine çevrilmesinde, bunun yerine şöyle bir şey yapardık -
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker) {
this.spellChecker = spellChecker;
}
}Burada TextEditor, SpellChecker uygulaması konusunda endişelenmemelidir. Yazım Denetimi bağımsız olarak uygulanacak ve TextEditor somutlaştırması sırasında TextEditor'a sağlanacaktır. Tüm bu prosedür, Spring Framework tarafından kontrol edilmektedir.
Burada, TextEditor'dan toplam kontrolü kaldırdık ve onu başka bir yerde tuttuk (yani XML yapılandırma dosyası) ve bağımlılık (yani, SpellChecker sınıfı) TextEditor sınıfına bir Class Constructor. Bu nedenle, bağımlılıkları bazı harici sistemlere etkin bir şekilde delege ettiğiniz için kontrol akışı Bağımlılık Enjeksiyonu (DI) tarafından "tersine çevrilmiştir".
Bağımlılığı enjekte etmenin ikinci yöntemi, Setter MethodsBir SpellChecker örneği oluşturacağımız TextEditor sınıfının. Bu örnek, TextEditor'ın özelliklerini başlatmak için setter yöntemlerini çağırmak için kullanılacaktır.
Bu nedenle, DI iki ana varyantta mevcuttur ve aşağıdaki iki alt bölüm her ikisini de örneklerle kapsayacaktır -
| Sr.No. | Bağımlılık Enjeksiyon Tipi ve Tanımı |
|---|---|
| 1 | Yapıcı tabanlı bağımlılık ekleme Oluşturucu tabanlı DI, kapsayıcı, her biri diğer sınıfa bağımlılığı temsil eden bir dizi argümana sahip bir sınıf oluşturucusunu çağırdığında gerçekleştirilir. |
| 2 | Belirleyici tabanlı bağımlılık enjeksiyonu Ayarlayıcı tabanlı DI, fasulyenizi başlatmak için bağımsız değişken olmayan veya bağımsız değişken olmayan statik fabrika yöntemini çağırdıktan sonra fasulyelarınızda ayarlayıcı yöntemlerini çağıran konteyner tarafından gerçekleştirilir. |
Hem Oluşturucu tabanlı hem de Ayarlayıcı tabanlı DI'yi karıştırabilirsiniz, ancak zorunlu bağımlılıklar için yapıcı bağımsız değişkenlerini ve isteğe bağlı bağımlılıklar için ayarlayıcıları kullanmak iyi bir kuraldır.
Kod, DI ilkesiyle daha temizdir ve nesnelere bağımlılıkları sağlandığında ayırma daha etkilidir. Nesne bağımlılıklarına bakmaz ve bağımlılıkların yerini veya sınıfını bilmez, bunun yerine her şey Spring Framework tarafından halledilir.
Bildiğiniz gibi Java iç sınıfları da benzer şekilde diğer sınıflar kapsamında tanımlanır, inner beansbaşka bir fasulye kapsamında tanımlanan fasulyelerdir. Bu nedenle, <property /> veya <constructor-arg /> elemanlarının içindeki bir <bean /> elemanı iç fasulye olarak adlandırılır ve aşağıda gösterilmiştir.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "outerBean" class = "...">
<property name = "target">
<bean id = "innerBean" class = "..."/>
</property>
</bean>
</beans>Misal
Eclipse IDE'yi yerinde çalıştıralım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları takip edelim -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Com.tutorialspoint paketi altında TextEditor , SpellChecker ve MainApp Java sınıfları oluşturun . |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği TextEditor.java dosya -
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
// a setter method to inject the dependency.
public void setSpellChecker(SpellChecker spellChecker) {
System.out.println("Inside setSpellChecker." );
this.spellChecker = spellChecker;
}
// a getter method to return spellChecker
public SpellChecker getSpellChecker() {
return spellChecker;
}
public void spellCheck() {
spellChecker.checkSpelling();
}
}Aşağıda, başka bir bağımlı sınıf dosyasının içeriği yer almaktadır SpellChecker.java -
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}Aşağıdakilerin içeriği MainApp.java dosya -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
TextEditor te = (TextEditor) context.getBean("textEditor");
te.spellCheck();
}
}Yapılandırma dosyası aşağıdadır Beans.xml ayarlayıcı tabanlı enjeksiyon için yapılandırmaya sahip olan ancak kullanan inner beans -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Definition for textEditor bean using inner bean -->
<bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
<property name = "spellChecker">
<bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"/>
</property>
</bean>
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.İlkel veri türlerinin nasıl yapılandırılacağını gördünüz. value kullanarak nitelik ve nesne referansları refBean yapılandırma dosyanızdaki <property> etiketinin özniteliği. Her iki durum da tekil değeri bir fasulyeye aktarmayla ilgilidir.
Şimdi, Liste, Küme, Harita ve Özellikler gibi Java Koleksiyonu türleri gibi çoğul değerleri iletmek isterseniz ne olur? Durumun üstesinden gelmek için Spring, aşağıdaki gibi dört tür koleksiyon yapılandırma öğesi sunar:
| Sr.No | Öğe ve Açıklama |
|---|---|
| 1 | <list> Bu, kablolamada yardımcı olur, yani bir değerler listesi enjekte ederek kopyalara izin verir. |
| 2 | <set> Bu, bir dizi değeri kablolamaya yardımcı olur, ancak herhangi bir kopya olmadan. |
| 3 | <map> Bu, ad ve değerin herhangi bir türde olabileceği ad-değer çiftleri koleksiyonunu enjekte etmek için kullanılabilir. |
| 4 | <props> Bu, ad ve değerin her ikisinin de Dizeler olduğu ad-değer çiftleri koleksiyonunu enjekte etmek için kullanılabilir. |
Herhangi bir java.util.Collection uygulamasını bağlamak için <list> veya <set> kullanabilirsiniz. array.
İki durumla karşılaşacaksınız (a) Koleksiyonun doğrudan değerlerini iletme ve (b) Koleksiyon öğelerinden biri olarak bir fasulyenin referansını iletme.
Misal
Çalışan bir Eclipse IDE'ye sahip olalım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları atalım -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Java sınıfları oluşturma JavaCollection ve MainApp altında com.tutorialspoint paketinin. |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği JavaCollection.java dosya -
package com.tutorialspoint;
import java.util.*;
public class JavaCollection {
List addressList;
Set addressSet;
Map addressMap;
Properties addressProp;
// a setter method to set List
public void setAddressList(List addressList) {
this.addressList = addressList;
}
// prints and returns all the elements of the list.
public List getAddressList() {
System.out.println("List Elements :" + addressList);
return addressList;
}
// a setter method to set Set
public void setAddressSet(Set addressSet) {
this.addressSet = addressSet;
}
// prints and returns all the elements of the Set.
public Set getAddressSet() {
System.out.println("Set Elements :" + addressSet);
return addressSet;
}
// a setter method to set Map
public void setAddressMap(Map addressMap) {
this.addressMap = addressMap;
}
// prints and returns all the elements of the Map.
public Map getAddressMap() {
System.out.println("Map Elements :" + addressMap);
return addressMap;
}
// a setter method to set Property
public void setAddressProp(Properties addressProp) {
this.addressProp = addressProp;
}
// prints and returns all the elements of the Property.
public Properties getAddressProp() {
System.out.println("Property Elements :" + addressProp);
return addressProp;
}
}Aşağıdakilerin içeriği MainApp.java dosya -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
JavaCollection jc=(JavaCollection)context.getBean("javaCollection");
jc.getAddressList();
jc.getAddressSet();
jc.getAddressMap();
jc.getAddressProp();
}
}Yapılandırma dosyası aşağıdadır Beans.xml tüm koleksiyon türleri için yapılandırmaya sahip olan -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Definition for javaCollection -->
<bean id = "javaCollection" class = "com.tutorialspoint.JavaCollection">
<!-- results in a setAddressList(java.util.List) call -->
<property name = "addressList">
<list>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>USA</value>
</list>
</property>
<!-- results in a setAddressSet(java.util.Set) call -->
<property name = "addressSet">
<set>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>USA</value>
</set>
</property>
<!-- results in a setAddressMap(java.util.Map) call -->
<property name = "addressMap">
<map>
<entry key = "1" value = "INDIA"/>
<entry key = "2" value = "Pakistan"/>
<entry key = "3" value = "USA"/>
<entry key = "4" value = "USA"/>
</map>
</property>
<!-- results in a setAddressProp(java.util.Properties) call -->
<property name = "addressProp">
<props>
<prop key = "one">INDIA</prop>
<prop key = "one">INDIA</prop>
<prop key = "two">Pakistan</prop>
<prop key = "three">USA</prop>
<prop key = "four">USA</prop>
</props>
</property>
</bean>
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
List Elements :[INDIA, Pakistan, USA, USA]
Set Elements :[INDIA, Pakistan, USA]
ap Elements :{1 = INDIA, 2 = Pakistan, 3 = USA, 4 = USA}
Property Elements :{two = Pakistan, one = INDIA, three = USA, four = USA}Fasulye Referanslarının Enjekte Edilmesi
Aşağıdaki Bean tanımı, koleksiyonun öğelerinden biri olarak fasulye referanslarının nasıl enjekte edileceğini anlamanıza yardımcı olacaktır. Aşağıdaki kod parçacığında gösterildiği gibi referansları ve değerleri birlikte karıştırabilirsiniz -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Bean Definition to handle references and values -->
<bean id = "..." class = "...">
<!-- Passing bean reference for java.util.List -->
<property name = "addressList">
<list>
<ref bean = "address1"/>
<ref bean = "address2"/>
<value>Pakistan</value>
</list>
</property>
<!-- Passing bean reference for java.util.Set -->
<property name = "addressSet">
<set>
<ref bean = "address1"/>
<ref bean = "address2"/>
<value>Pakistan</value>
</set>
</property>
<!-- Passing bean reference for java.util.Map -->
<property name = "addressMap">
<map>
<entry key = "one" value = "INDIA"/>
<entry key = "two" value-ref = "address1"/>
<entry key = "three" value-ref = "address2"/>
</map>
</property>
</bean>
</beans>Yukarıdaki fasulye tanımını kullanmak için, ayarlayıcı yöntemlerinizi referansları da işleyebilecek şekilde tanımlamanız gerekir.
Boş ve boş dize değerleri enjekte etme
Değer olarak boş bir dizge iletmeniz gerekirse, aşağıdaki gibi iletebilirsiniz -
<bean id = "..." class = "exampleBean">
<property name = "email" value = ""/>
</bean>Önceki örnek Java koduna eşdeğerdir: exampleBean.setEmail ("")
Bir NULL değeri iletmeniz gerekiyorsa, aşağıdaki gibi geçebilirsiniz -
<bean id = "..." class = "exampleBean">
<property name = "email"><null/></property>
</bean>Yukarıdaki örnek Java koduna eşdeğerdir: exampleBean.setEmail (null)
XML yapılandırma dosyasında <bean> öğesini kullanarak fasulye bildirmeyi ve <bean> öğesini <constructor-arg> ve <property> öğelerini kullanarak nasıl enjekte edeceğinizi öğrendiniz.
Yaylı konteyner autowire <constructor-arg> ve <property> öğelerini kullanmadan ortak çalışan fasulye arasındaki ilişkiler, büyük bir Spring tabanlı uygulama için yazdığınız XML yapılandırması miktarını azaltmanıza yardımcı olur.
Otomatik Kablolama Modları
Aşağıdakiler, Yaylı konteynere bağımlılık enjeksiyonu için otomatik kablolamayı kullanma talimatı vermek için kullanılabilen otomatik kablolama modlarıdır. <Bean /> öğesinin autowire özniteliğini belirtmek için kullanırsınızautowire fasulye tanımı için mod.
| Sr.No | Mod ve Açıklama |
|---|---|
| 1 | no Bu, otomatik kablolama olmadığı anlamına gelen varsayılan ayardır ve kablolama için açık fasulye referansı kullanmanız gerekir. Bu kablolama için özel yapacak hiçbir şeyiniz yok. Bu, Bağımlılık Enjeksiyonu bölümünde gördüğünüz şeydir. |
| 2 | isimle Mülk adına göre otomatik kablolama. Spring kapsayıcı , XML yapılandırma dosyasında autowire özniteliğinin byName olarak ayarlandığı fasulye özelliklerine bakar . Ardından, özelliklerini yapılandırma dosyasında aynı adlarla tanımlanan fasulye ile eşleştirmeye ve bağlamayı dener. |
| 3 | byType Mülk veri türüne göre otomatik kablolama. Spring container , XML yapılandırma dosyasında autowire niteliğinin byType olarak ayarlandığı fasulye özelliklerine bakar . Daha sonra bir özelliği eşleştirmeye ve bağlamayı dener.typeyapılandırma dosyasındaki fasulye adlarından biriyle tam olarak eşleşir. Birden fazla böyle fasulye varsa, ölümcül bir istisna atılır. |
| 4 | constructor Similar to byType, but type applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised. |
| 5 | autodetect Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType. |
You can use byType or constructor autowiring mode to wire arrays and other typed-collections.
Limitations with autowiring
Autowiring works best when it is used consistently across a project. If autowiring is not used in general, it might be confusing for developers to use it to wire only one or two bean definitions. Though, autowiring can significantly reduce the need to specify properties or constructor arguments but you should consider the limitations and disadvantages of autowiring before using them.
| Sr.No. | Limitations & Description |
|---|---|
| 1 | Overriding possibility You can still specify dependencies using <constructor-arg> and <property> settings which will always override autowiring. |
| 2 | Primitive data types You cannot autowire so-called simple properties such as primitives, Strings, and Classes. |
| 3 | Confusing nature Autowiring is less exact than explicit wiring, so if possible prefer using explict wiring. |
Starting from Spring 2.5 it became possible to configure the dependency injection using annotations. So instead of using XML to describe a bean wiring, you can move the bean configuration into the component class itself by using annotations on the relevant class, method, or field declaration.
Annotation injection is performed before XML injection. Thus, the latter configuration will override the former for properties wired through both approaches.
Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file. So consider the following configuration file in case you want to use any annotation in your Spring application.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:context = "http://www.springframework.org/schema/context"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>Once <context:annotation-config/> is configured, you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors. Let us look at a few important annotations to understand how they work −
| Sr.No. | Annotation & Description |
|---|---|
| 1 | @Required The @Required annotation applies to bean property setter methods. |
| 2 | @Autowired The @Autowired annotation can apply to bean property setter methods, non-setter methods, constructor and properties. |
| 3 | @Qualifier The @Qualifier annotation along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired. |
| 4 | JSR-250 Annotations Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations. |
So far you have seen how we configure Spring beans using XML configuration file. If you are comfortable with XML configuration, then it is really not required to learn how to proceed with Java-based configuration as you are going to achieve the same result using either of the configurations available.
Java-based configuration option enables you to write most of your Spring configuration without XML but with the help of few Java-based annotations explained in this chapter.
@Configuration & @Bean Annotations
Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context. The simplest possible @Configuration class would be as follows −
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}The above code will be equivalent to the following XML configuration −
<beans>
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>Here, the method name is annotated with @Bean works as bean ID and it creates and returns the actual bean. Your configuration class can have a declaration for more than one @Bean. Once your configuration classes are defined, you can load and provide them to Spring container using AnnotationConfigApplicationContext as follows −
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}You can load various configuration classes as follows −
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class, OtherConfig.class);
ctx.register(AdditionalConfig.class);
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
| Steps | Description |
|---|---|
| 1 | Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project. |
| 2 | Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter. |
| 3 | Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org. |
| 4 | Create Java classes HelloWorldConfig, HelloWorld and MainApp under the com.tutorialspoint package. |
| 5 | The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below. |
Here is the content of HelloWorldConfig.java file
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}Here is the content of HelloWorld.java file
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Following is the content of the MainApp.java file
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}
}Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −
Your Message : Hello World!Injecting Bean Dependencies
When @Beans have dependencies on one another, expressing that the dependency is as simple as having one bean method calling another as follows −
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
return new Foo(bar());
}
@Bean
public Bar bar() {
return new Bar();
}
}Here, the foo bean receives a reference to bar via the constructor injection. Now let us look at another working example.
Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
| Steps | Description |
|---|---|
| 1 | Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project. |
| 2 | Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter. |
| 3 | Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org. |
| 4 | Create Java classes TextEditorConfig, TextEditor, SpellChecker and MainApp under the com.tutorialspoint package. |
| 5 | The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below. |
Here is the content of TextEditorConfig.java file
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class TextEditorConfig {
@Bean
public TextEditor textEditor(){
return new TextEditor( spellChecker() );
}
@Bean
public SpellChecker spellChecker(){
return new SpellChecker( );
}
}Here is the content of TextEditor.java file
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker){
System.out.println("Inside TextEditor constructor." );
this.spellChecker = spellChecker;
}
public void spellCheck(){
spellChecker.checkSpelling();
}
}Following is the content of another dependent class file SpellChecker.java
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}Following is the content of the MainApp.java file
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(TextEditorConfig.class);
TextEditor te = ctx.getBean(TextEditor.class);
te.spellCheck();
}
}Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −
Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.The @Import Annotation
The @Import annotation allows for loading @Bean definitions from another configuration class. Consider a ConfigA class as follows −
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}You can import above Bean declaration in another Bean Declaration as follows −
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B b() {
return new B();
}
}Now, rather than needing to specify both ConfigA.class and ConfigB.class when instantiating the context, only ConfigB needs to be supplied as follows −
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
// now both beans A and B will be available...
A a = ctx.getBean(A.class);
B b = ctx.getBean(B.class);
}Yaşam Döngüsü Geri Aramaları
@Bean ek açıklaması, Spring XML'in bean öğesindeki init-method ve destroy-method özniteliklerine çok benzer şekilde, keyfi başlatma ve imha geri çağırma yöntemlerini belirtmeyi destekler -
public class Foo {
public void init() {
// initialization logic
}
public void cleanup() {
// destruction logic
}
}
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup" )
public Foo foo() {
return new Foo();
}
}Fasulye Kapsamını Belirleme
Varsayılan kapsam tekildir, ancak bunu aşağıdaki gibi @Scope ek açıklamasıyla geçersiz kılabilirsiniz -
@Configuration
public class AppConfig {
@Bean
@Scope("prototype")
public Foo foo() {
return new Foo();
}
}Tüm bölümlerde Bahar'ın özünün ApplicationContextçekirdeklerinin tüm yaşam döngüsünü yöneten. ApplicationContext, fasulyeleri yüklerken belirli olay türlerini yayınlar. Örneğin, bir ContextStartedEvent bağlam başlatılır ve ne zaman yayınlanır ContextStoppedEvent bağlam durdurulduğunda yayınlanmaktadır.
ApplicationContext'teki olay işleme , ApplicationEvent sınıfı ve ApplicationListener arabirimi aracılığıyla sağlanır . Bu nedenle, bir fasulye ApplicationListener'ı uygularsa , o zaman bir ApplicationEvent ApplicationContext'te her yayımlandığında, o fasulye bilgilendirilir.
Bahar, aşağıdaki standart etkinlikleri sağlar -
| Sr.No. | İlkbahar Yerleşik Etkinlikler ve Açıklama |
|---|---|
| 1 | ContextRefreshedEvent Bu olay, ApplicationContext başlatıldığında veya yenilendiğinde yayınlanır. Bu ayrıca, ConfigurableApplicationContext arabiriminde yenileme () yöntemi kullanılarak da ortaya çıkarılabilir . |
| 2 | ContextStartedEvent Bu olay, ApplicationContext , ConfigurableApplicationContext arabiriminde start () yöntemi kullanılarak başlatıldığında yayınlanır . Veritabanınızı sorgulayabilir veya bu olayı aldıktan sonra durdurulmuş herhangi bir uygulamayı yeniden başlatabilirsiniz. |
| 3 | ContextStoppedEvent Bu olay, ApplicationContext , configureableApplicationContext arabiriminde stop () yöntemi kullanılarak durdurulduğunda yayınlanır . Bu olayı aldıktan sonra gerekli temizlik işlerini yapabilirsiniz. |
| 4 | ContextClosedEvent Bu olay, ApplicationContext , ConfigurableApplicationContext arabiriminde close () yöntemi kullanılarak kapatıldığında yayınlanır . Kapalı bir bağlam yaşamın sonuna ulaşır; yenilenemez veya yeniden başlatılamaz. |
| 5 | RequestHandledEvent Bu, tüm fasulyelere bir HTTP isteğinin sunulduğunu bildiren web'e özgü bir olaydır. |
Spring'in olay işleme süreci tek iş parçacıklıdır, bu nedenle bir olay yayınlanırsa, tüm alıcılar mesajı alana kadar ve almadıkça, işlemler engellenir ve akış devam etmez. Bu nedenle, olay işleme kullanılacaksa uygulamanızı tasarlarken dikkatli olunmalıdır.
Bağlam Olaylarını Dinleme
Bir bağlam olayını dinlemek için, bir Bean , yalnızca bir yöntemi olan ApplicationListener arabirimini uygulamalıdır.onApplicationEvent(). Öyleyse olayların nasıl yayıldığını ve kodunuzu belirli olaylara göre gerekli görevi yerine getirmek için nasıl yerleştirebileceğinizi görmek için bir örnek yazalım.
Çalışan bir Eclipse IDE'ye sahip olalım ve bir Spring uygulaması oluşturmak için aşağıdaki adımları atalım -
| Adım | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Com.tutorialspoint paketi altında HelloWorld , CStartEventHandler , CStopEventHandler ve MainApp Java sınıfları oluşturun . |
| 4 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 5 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği HelloWorld.java dosya
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Aşağıdakilerin içeriği CStartEventHandler.java dosya
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;
public class CStartEventHandler
implements ApplicationListener<ContextStartedEvent>{
public void onApplicationEvent(ContextStartedEvent event) {
System.out.println("ContextStartedEvent Received");
}
}Aşağıdakilerin içeriği CStopEventHandler.java dosya
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStoppedEvent;
public class CStopEventHandler
implements ApplicationListener<ContextStoppedEvent>{
public void onApplicationEvent(ContextStoppedEvent event) {
System.out.println("ContextStoppedEvent Received");
}
}Aşağıdakilerin içeriği MainApp.java dosya
package com.tutorialspoint;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ConfigurableApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
// Let us raise a start event.
context.start();
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
// Let us raise a stop event.
context.stop();
}
}Yapılandırma dosyası aşağıdadır Beans.xml
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
<bean id = "cStartEventHandler" class = "com.tutorialspoint.CStartEventHandler"/>
<bean id = "cStopEventHandler" class = "com.tutorialspoint.CStopEventHandler"/>
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent Receivedİsterseniz, kendi özel etkinliklerinizi yayınlayabilir ve daha sonra bu özel olaylara karşı herhangi bir işlem yapmak için aynısını yakalayabilirsiniz. Kendi özel etkinliklerinizi yazmakla ilgileniyorsanız , İlkbaharda Özel Etkinlikler'i kontrol edebilirsiniz .
Kendi özel etkinliklerinizi yazmak ve yayınlamak için atmanız gereken birkaç adım vardır. Özel Bahar Etkinliklerini yazmak, yayınlamak ve yönetmek için bu bölümde verilen talimatları izleyin.
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .srcoluşturulan projedeki klasör. Tüm sınıflar bu paket altında oluşturulacaktır. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Bir olay sınıfı oluşturma, CustomEvent uzatarakApplicationEvent. Bu sınıf, bir yapıcıyı ApplicationEvent sınıfından devralması gereken varsayılan bir kurucu tanımlamalıdır. |
| 4 | Olay sınıfınız tanımlandıktan sonra, herhangi bir sınıftan yayınlayabilirsiniz, örneğin ApplicationEventPublisherAware'i uygulayan EventClassPublisher diyelim . Ayrıca, kapsayıcının ApplicationEventPublisherAware arabirimini uyguladığı için çekirdeği bir olay yayıncısı olarak tanımlayabilmesi için bu sınıfı XML yapılandırma dosyasında bir fasulye olarak bildirmeniz gerekecektir. |
| 5 | Bir yayınlanan olay bir sınıfta ele alınabilir diyelim EventClassHandler uygular ApplicationListener arayüzü ve uygular onApplicationEvent özel etkinliği için bir yöntem. |
| 6 | Fasulye yapılandırma dosyası Beans.xml altındasrcklasör ve Spring uygulaması olarak çalışacak bir MainApp sınıfı. |
| 7 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği CustomEvent.java dosya
package com.tutorialspoint;
import org.springframework.context.ApplicationEvent;
public class CustomEvent extends ApplicationEvent{
public CustomEvent(Object source) {
super(source);
}
public String toString(){
return "My Custom Event";
}
}Aşağıdakilerin içeriği CustomEventPublisher.java dosya
package com.tutorialspoint;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
public class CustomEventPublisher implements ApplicationEventPublisherAware {
private ApplicationEventPublisher publisher;
public void setApplicationEventPublisher (ApplicationEventPublisher publisher) {
this.publisher = publisher;
}
public void publish() {
CustomEvent ce = new CustomEvent(this);
publisher.publishEvent(ce);
}
}Aşağıdakilerin içeriği CustomEventHandler.java dosya
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
public class CustomEventHandler implements ApplicationListener<CustomEvent> {
public void onApplicationEvent(CustomEvent event) {
System.out.println(event.toString());
}
}Aşağıdakilerin içeriği MainApp.java dosya
package com.tutorialspoint;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ConfigurableApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
CustomEventPublisher cvp =
(CustomEventPublisher) context.getBean("customEventPublisher");
cvp.publish();
cvp.publish();
}
}Yapılandırma dosyası aşağıdadır Beans.xml
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "customEventHandler" class = "com.tutorialspoint.CustomEventHandler"/>
<bean id = "customEventPublisher" class = "com.tutorialspoint.CustomEventPublisher"/>
</beans>Kaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, aşağıdaki mesajı yazdıracaktır -
y Custom Event
y Custom EventSpring Framework'ün temel bileşenlerinden biri, Aspect oriented programming (AOP)çerçeve. Görünüşe Dayalı Programlama, program mantığını sözde endişeler adı verilen farklı bölümlere ayırmayı gerektirir. Bir uygulamanın birden çok noktasını kapsayan işlevlerecross-cutting concernsve bu kesişen endişeler kavramsal olarak uygulamanın iş mantığından ayrıdır. Günlüğe kaydetme, denetim, bildirimsel işlemler, güvenlik, önbelleğe alma vb. Gibi çeşitli yaygın iyi örnekler vardır.
OOP'de modülerliğin ana birimi sınıftır, oysa AOP'de modülerlik birimi görünümdür. Bağımlılık Enjeksiyonu, uygulama nesnelerinizi birbirinden ayırmanıza yardımcı olur ve AOP, kesişen endişeleri etkiledikleri nesnelerden ayırmanıza yardımcı olur. AOP, Perl, .NET, Java ve diğerleri gibi programlama dillerindeki tetikleyiciler gibidir.
Yaylı AOP modülü, bir uygulamayı durdurmak için engelleyiciler sağlar. Örneğin, bir yöntem yürütüldüğünde, yöntemin yürütülmesinden önce veya sonra ekstra işlevsellik ekleyebilirsiniz.
AOP Terminolojileri
AOP ile çalışmaya başlamadan önce, AOP kavramları ve terminolojisine aşina olalım. Bu terimler Spring'e özel değildir, daha çok AOP ile ilgilidir.
| Sr.No | Şartlar ve Açıklama |
|---|---|
| 1 | Aspect Bu, kesişen gereksinimleri sağlayan bir dizi API'ye sahip bir modüldür. Örneğin, bir günlük kaydı modülü, günlük kaydı için AOP yönü olarak adlandırılır. Bir uygulama, ihtiyaca bağlı olarak herhangi bir sayıda özelliğe sahip olabilir. |
| 2 | Join point Bu, uygulamanızda AOP yönünü takabileceğiniz bir noktayı temsil eder. Ayrıca Spring AOP çerçevesi kullanılarak bir eylemin yapılacağı uygulamada gerçek yer diyebilirsiniz. |
| 3 | Advice Bu, yöntemin yürütülmesinden önce veya sonra yapılacak gerçek eylemdir. Bu, Spring AOP çerçevesi tarafından programın yürütülmesi sırasında çağrılan gerçek bir kod parçasıdır. |
| 4 | Pointcut Bu, bir tavsiyenin yerine getirilmesi gereken bir veya daha fazla birleşme noktası kümesidir. AOP örneklerimizde göreceğimiz gibi, ifadeleri veya kalıpları kullanarak nokta kesimlerini belirtebilirsiniz. |
| 5 | Introduction Giriş, mevcut sınıflara yeni yöntemler veya öznitelikler eklemenize izin verir. |
| 6 | Target object Bir veya daha fazla yönden tavsiye edilen nesne. Bu nesne her zaman, tavsiye edilen nesne olarak da anılan vekil bir nesne olacaktır. |
| 7 | Weaving Dokuma, tavsiye edilen bir nesne oluşturmak için yönleri diğer uygulama türleri veya nesnelerle ilişkilendirme işlemidir. Bu, derleme zamanında, yükleme zamanında veya çalışma zamanında yapılabilir. |
Tavsiye Türleri
İlkbahar konuları, aşağıda belirtilen beş tür tavsiyeyle işe yarayabilir -
| Sr.No | Tavsiye ve Açıklama |
|---|---|
| 1 | before Bir yöntemi uygulamadan önce tavsiye çalıştırın. |
| 2 | after Sonucu ne olursa olsun, yöntem çalıştırıldıktan sonra tavsiye çalıştırın. |
| 3 | after-returning Yöntemin çalıştırılmasından sonra, yalnızca yöntem başarıyla tamamlanırsa tavsiye çalıştırın. |
| 4 | after-throwing Yöntemin çalıştırılmasından sonra, yalnızca yöntem bir istisna atarak çıkarsa çalıştır. |
| 5 | around Tavsiye edilen yöntemin kullanılmasından önce ve sonra tavsiye çalıştırın. |
Özel Yönlerin Uygulanması
Bahar, @AspectJ annotation style yaklaşım ve schema-basedözel yönleri uygulama yaklaşımı. Bu iki yaklaşım aşağıdaki bölümlerde ayrıntılı olarak açıklanmıştır.
| Sr.No | Yaklaşım ve Açıklama |
|---|---|
| 1 | XML Şeması tabanlı Yönler, XML tabanlı yapılandırmanın yanı sıra normal sınıflar kullanılarak uygulanır. |
| 2 | @AspectJ tabanlı @AspectJ, Java 5 notları ile açıklama eklenmiş normal Java sınıfları olarak durumları bildirme stilini ifade eder. |
Düz eski JDBC kullanarak veritabanı ile çalışırken, istisnaları ele almak, veritabanı bağlantılarını açmak ve kapatmak vb. İçin gereksiz kod yazmak zahmetli hale gelir. Bununla birlikte, Spring JDBC Framework, bağlantıyı açmaktan başlayarak tüm düşük seviyeli ayrıntıları halleder, ve SQL ifadesini yürütün, istisnaları işleyin, işlemleri yönetin ve son olarak bağlantıyı kapatın.
Yani yapmanız gereken, sadece bağlantı parametrelerini tanımlamak ve yürütülecek SQL ifadesini belirtmek ve veritabanından veri alırken her yineleme için gerekli işi yapmaktır.
Spring JDBC, veritabanıyla arayüz oluşturmak için çeşitli yaklaşımlar ve buna uygun olarak farklı sınıflar sağlar. Klasik ve en popüler yaklaşımı kullanacağım.JdbcTemplateçerçevenin sınıfı. Bu, tüm veritabanı iletişimini ve istisna işlemeyi yöneten merkezi çerçeve sınıfıdır.
JdbcTemplate Sınıfı
JDBC Template sınıfı, SQL sorgularını yürütür, ifadeleri günceller, prosedür çağrılarını depolar, ResultSets üzerinde yineleme gerçekleştirir ve döndürülen parametre değerlerini çıkarır. Ayrıca, JDBC istisnalarını yakalar ve bunları, org.springframework.dao paketinde tanımlanan genel, daha bilgilendirici, istisna hiyerarşisine çevirir.
Örneklerini JdbcTemplate sınıfında olan ÅŸan bir kez yapılandırılmış. Böylece, tek bir JdbcTemplate örneğini yapılandırabilir ve ardından bu paylaşılan referansı birden çok DAO'ya güvenli bir şekilde enjekte edebilirsiniz.
JDBC Template sınıfını kullanırken yaygın bir uygulama , Spring yapılandırma dosyanızda bir DataSource yapılandırmak ve ardından DAO sınıflarınıza paylaşılan DataSource çekirdeğini bağımlılık enjekte etmektir ve JdbcTemplate, DataSource için ayarlayıcıda oluşturulur.
Veri Kaynağını Yapılandırma
Bir veritabanı tablosu oluşturalım Student veri tabanımızda TEST. MySQL veritabanı ile çalıştığınızı varsayıyoruz, eğer başka bir veritabanı ile çalışıyorsanız, DDL ve SQL sorgularınızı buna göre değiştirebilirsiniz.
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);Şimdi, JDBC Şablonuna bir Veri Kaynağı sağlamamız gerekiyor, böylece veritabanı erişimi elde etmek için kendini yapılandırabilir. Aşağıdaki kod parçacığında gösterildiği gibi XML dosyasındaki DataSource'u bir kod parçasıyla yapılandırabilirsiniz -
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "password"/>
</bean>Veri Erişim Nesnesi (DAO)
DAO, yaygın olarak veritabanı etkileşimi için kullanılan Veri Erişim Nesnesi anlamına gelir. DAO'lar, veri tabanına veri okumak ve yazmak için bir araç sağlamak için vardır ve bu işlevselliği, uygulamanın geri kalanının onlara erişeceği bir arabirim aracılığıyla ifşa etmeleri gerekir.
Spring'deki DAO desteği, JDBC, Hibernate, JPA veya JDO gibi veri erişim teknolojileriyle tutarlı bir şekilde çalışmayı kolaylaştırır.
SQL ifadelerinin yürütülmesi
SQL ve JDBC Template nesnesini kullanarak veritabanı tablolarında CRUD (Create, Read, Update ve Delete) işlemini nasıl gerçekleştirebileceğimize bir bakalım.
Querying for an integer
String SQL = "select count(*) from Student";
int rowCount = jdbcTemplateObject.queryForInt( SQL );Querying for a long
String SQL = "select count(*) from Student";
long rowCount = jdbcTemplateObject.queryForLong( SQL );A simple query using a bind variable
String SQL = "select age from Student where id = ?";
int age = jdbcTemplateObject.queryForInt(SQL, new Object[]{10});Querying for a String
String SQL = "select name from Student where id = ?";
String name = jdbcTemplateObject.queryForObject(SQL, new Object[]{10}, String.class);Querying and returning an object
String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
SQL, new Object[]{10}, new StudentMapper());
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setID(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Querying and returning multiple objects
String SQL = "select * from Student";
List<Student> students = jdbcTemplateObject.query(
SQL, new StudentMapper());
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setID(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Inserting a row into the table
String SQL = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 11} );Updating a row into the table
String SQL = "update Student set name = ? where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 10} );Deleting a row from the table
String SQL = "delete Student where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{20} );DDL İfadelerinin Yürütülmesi
Kullanabilirsiniz execute(..)herhangi bir SQL deyimini veya DDL deyimini yürütmek için jdbcTemplate'den yöntem . Aşağıda, bir tablo oluşturmak için CREATE ifadesinin kullanılmasına bir örnek verilmiştir -
String SQL = "CREATE TABLE Student( " +
"ID INT NOT NULL AUTO_INCREMENT, " +
"NAME VARCHAR(20) NOT NULL, " +
"AGE INT NOT NULL, " +
"PRIMARY KEY (ID));"
jdbcTemplateObject.execute( SQL );Spring JDBC Çerçeve Örnekleri
Yukarıdaki kavramlara dayanarak, İlkbaharda JDBC çerçevesinin kullanımını anlamanıza yardımcı olacak birkaç önemli örneği kontrol edelim -
| Sr.No. | Örnek ve Açıklama |
|---|---|
| 1 | Spring JDBC Örneği Bu örnek, JDBC tabanlı basit bir Spring uygulamasının nasıl yazılacağını açıklayacaktır. |
| 2 | Baharda SQL Depolanan Prosedür Spring'de JDBC'yi kullanırken SQL saklı yordamını nasıl çağıracağınızı öğrenin. |
Veritabanı işlemi, tek bir iş birimi olarak değerlendirilen bir eylemler dizisidir. Bu eylemler ya tamamen tamamlanmalı ya da hiç etkili olmamalıdır. İşlem yönetimi, veri bütünlüğünü ve tutarlılığını sağlamak için RDBMS odaklı kurumsal uygulamanın önemli bir parçasıdır. İşlem kavramı, aşağıdaki dört temel özellik ile tanımlanabilir:ACID -
Atomicity - Bir işlem, tek bir işlem birimi olarak ele alınmalıdır; bu, tüm işlem sırasının başarılı veya başarısız olduğu anlamına gelir.
Consistency - Bu, veritabanının bilgi tutarlılığının, tablolardaki benzersiz birincil anahtarların vb. Tutarlılığını temsil eder.
Isolation- Aynı anda aynı veri kümesiyle birçok işlem gerçekleştirilebilir. Veri bozulmasını önlemek için her işlem diğerlerinden izole edilmelidir.
Durability - Bir işlem tamamlandıktan sonra, bu işlemin sonuçları kalıcı hale getirilmelidir ve sistem arızası nedeniyle veri tabanından silinemez.
Gerçek bir RDBMS veritabanı sistemi, her işlem için dört özelliğin tümünü garanti edecektir. SQL kullanılarak veritabanına verilen bir işlemin basit görünümü aşağıdaki gibidir -
İşlemi başlat komutunu kullanarak işleme başlayın .
SQL sorgularını kullanarak çeşitli silme, güncelleme veya ekleme işlemlerini gerçekleştirin.
Tüm işlemler başarılıysa, kesinleştirme gerçekleştirin, aksi takdirde tüm işlemleri geri alın .
Spring çerçevesi, farklı temel işlem yönetimi API'lerinin üzerinde soyut bir katman sağlar. Spring'in işlem desteği, POJO'lara işlem yetenekleri ekleyerek EJB işlemlerine bir alternatif sağlamayı amaçlamaktadır. Spring, hem programlı hem de bildirim temelli işlem yönetimini destekler. EJB'ler bir uygulama sunucusu gerektirir, ancak Spring işlem yönetimi bir uygulama sunucusuna ihtiyaç duyulmadan gerçekleştirilebilir.
Yerel ve Küresel İşlemler
Yerel işlemler, JDBC bağlantısı gibi tek bir işlem kaynağına özgüdür, oysa küresel işlemler, dağıtılmış bir sistemdeki işlem gibi birden çok işlem kaynağına yayılabilir.
Yerel işlem yönetimi, uygulama bileşenlerinin ve kaynaklarının tek bir sitede bulunduğu ve işlem yönetiminin yalnızca tek bir makinede çalışan yerel bir veri yöneticisini içerdiği merkezi bir bilgi işlem ortamında yararlı olabilir. Yerel işlemlerin uygulanması daha kolaydır.
Küresel işlem yönetimi, tüm kaynakların birden çok sisteme dağıtıldığı dağıtılmış bir bilgi işlem ortamında gereklidir. Böyle bir durumda işlem yönetiminin hem yerel hem de küresel düzeyde yapılması gerekir. Dağıtılmış veya küresel bir işlem, birden çok sistemde yürütülür ve yürütülmesi, küresel işlem yönetimi sistemi ile ilgili tüm sistemlerin tüm yerel veri yöneticileri arasında koordinasyonu gerektirir.
Programatik ve Bildirici
Spring iki tür işlem yönetimini destekler -
Programatik işlem yönetimi - Bu, işlemi programlama yardımı ile yönetmeniz gerektiği anlamına gelir. Bu size aşırı esneklik sağlar, ancak bakımı zordur.
Bildirime dayalı işlem yönetimi - Bu, işlem yönetimini işletme kodundan ayırdığınız anlamına gelir. İşlemleri yönetmek için yalnızca ek açıklamaları veya XML tabanlı yapılandırmayı kullanırsınız.
Bildirime dayalı işlem yönetimi, programlı işlem yönetimine tercih edilir, ancak programlı işlem yönetiminden daha az esnektir ve bu da işlemlerinizi kodunuz aracılığıyla kontrol etmenize olanak tanır. Ancak bir tür kesişen sorun olarak, bildirimsel işlem yönetimi AOP yaklaşımı ile modüler hale getirilebilir. Spring, Spring AOP çerçevesi aracılığıyla bildirim temelli işlem yönetimini destekler.
Bahar İşlem Soyutlamaları
Spring işlem soyutlamasının anahtarı , aşağıdaki gibi org.springframework.transaction.PlatformTransactionManager arabirimi tarafından tanımlanır -
public interface PlatformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition);
throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
}| Sr.No | Yöntem ve Açıklama |
|---|---|
| 1 | TransactionStatus getTransaction(TransactionDefinition definition) Bu yöntem, belirtilen yayılma davranışına göre şu anda etkin olan bir işlemi döndürür veya yeni bir tane oluşturur. |
| 2 | void commit(TransactionStatus status) Bu yöntem, durumuna göre verilen işlemi taahhüt eder. |
| 3 | void rollback(TransactionStatus status) Bu yöntem, verilen işlemin geri alınmasını gerçekleştirir. |
TransactionDefinition Spring işlem desteği çekirdek arayüzü ve aşağıdaki gibi tanımlanır -
public interface TransactionDefinition {
int getPropagationBehavior();
int getIsolationLevel();
String getName();
int getTimeout();
boolean isReadOnly();
}| Sr.No | Yöntem ve Açıklama |
|---|---|
| 1 | int getPropagationBehavior() Bu yöntem yayılma davranışını döndürür. Spring, EJB CMT'den bilinen tüm işlem yayma seçeneklerini sunar. |
| 2 | int getIsolationLevel() Bu yöntem, bu işlemin diğer işlemlerin çalışmasından ne kadar izole edildiğini döndürür. |
| 3 | String getName() Bu yöntem, bu işlemin adını döndürür. |
| 4 | int getTimeout() Bu yöntem, işlemin tamamlanması gereken zamanı saniye cinsinden döndürür. |
| 5 | boolean isReadOnly() Bu yöntem, işlemin salt okunur olup olmadığını döndürür. |
İzolasyon seviyesi için olası değerler aşağıdadır -
| Sr.No | İzolasyon ve Açıklama |
|---|---|
| 1 | TransactionDefinition.ISOLATION_DEFAULT Bu, varsayılan izolasyon seviyesidir. |
| 2 | TransactionDefinition.ISOLATION_READ_COMMITTED Kirli okumaların önlendiğini gösterir; tekrarlanamayan okumalar ve hayali okumalar meydana gelebilir. |
| 3 | TransactionDefinition.ISOLATION_READ_UNCOMMITTED Kirli okumaların, tekrarlanamayan okumaların ve hayali okumaların meydana gelebileceğini belirtir. |
| 4 | TransactionDefinition.ISOLATION_REPEATABLE_READ Kirli okumaların ve tekrarlanamayan okumaların önlendiğini gösterir; hayali okumalar meydana gelebilir. |
| 5 | TransactionDefinition.ISOLATION_SERIALIZABLE Kirli okumaların, tekrarlanamayan okumaların ve hayali okumaların engellendiğini gösterir. |
Yayılma türleri için olası değerler aşağıdadır -
| Sr.No. | Yayılma ve Açıklama |
|---|---|
| 1 | TransactionDefinition.PROPAGATION_MANDATORY Mevcut bir işlemi destekler; mevcut işlem yoksa bir istisna atar. |
| 2 | TransactionDefinition.PROPAGATION_NESTED Geçerli bir işlem varsa, iç içe geçmiş bir işlem içinde yürütülür. |
| 3 | TransactionDefinition.PROPAGATION_NEVER Mevcut bir işlemi desteklemiyor; mevcut bir işlem varsa bir istisna atar. |
| 4 | TransactionDefinition.PROPAGATION_NOT_SUPPORTED Mevcut bir işlemi desteklemiyor; bunun yerine her zaman işlem dışı olarak yürütür. |
| 5 | TransactionDefinition.PROPAGATION_REQUIRED Mevcut bir işlemi destekler; yoksa yeni bir tane oluşturur. |
| 6 | TransactionDefinition.PROPAGATION_REQUIRES_NEW Varsa mevcut işlemi askıya alarak yeni bir işlem oluşturur. |
| 7 | TransactionDefinition.PROPAGATION_SUPPORTS Mevcut bir işlemi destekler; hiçbiri yoksa işlem dışı olarak yürütülür. |
| 8 | TransactionDefinition.TIMEOUT_DEFAULT Temel alınan işlem sisteminin varsayılan zaman aşımını kullanır veya zaman aşımları desteklenmiyorsa hiçbirini kullanır. |
TransactionStatus arayüz kontrol işlem yürütme ve sorgu işlem durumu işlem kodu için basit bir yol sağlar.
public interface TransactionStatus extends SavepointManager {
boolean isNewTransaction();
boolean hasSavepoint();
void setRollbackOnly();
boolean isRollbackOnly();
boolean isCompleted();
}| Sr.No. | Yöntem ve Açıklama |
|---|---|
| 1 | boolean hasSavepoint() Bu yöntem, bu işlemin dahili olarak bir kayıt noktası taşıyıp taşımadığını, yani bir kayıt noktasına dayalı iç içe geçmiş işlem olarak yaratılıp yaratılmadığını döndürür. |
| 2 | boolean isCompleted() Bu yöntem, bu işlemin tamamlanıp tamamlanmadığını, yani önceden kaydedilmiş veya geri alınmış olup olmadığını döndürür. |
| 3 | boolean isNewTransaction() Mevcut işlemin yeni olması durumunda bu yöntem true döndürür. |
| 4 | boolean isRollbackOnly() Bu yöntem, işlemin yalnızca geri alma olarak işaretlenip işaretlenmediğini döndürür. |
| 5 | void setRollbackOnly() Bu yöntem, işlemi yalnızca geri alma olarak ayarlar. |
Spring Web MVC çerçevesi, Model-View-Controller (MVC) mimarisi ve esnek ve gevşek bağlı web uygulamaları geliştirmek için kullanılabilen hazır bileşenler sağlar. MVC modeli, uygulamanın farklı yönlerini (giriş mantığı, iş mantığı ve UI mantığı) ayırırken, bu öğeler arasında gevşek bir bağlantı sağlar.
Model uygulama verilerini içerir ve genel olarak POJO'dan oluşacaktır.
View model verilerinin işlenmesinden sorumludur ve genel olarak müşterinin tarayıcısının yorumlayabileceği HTML çıktısını üretir.
Controller kullanıcı isteklerini işleme almaktan ve uygun bir model oluşturmaktan sorumludur ve bunu işleme için görünüme aktarır.
DispatcherServlet
Spring Web model-görünüm-denetleyici (MVC) çerçevesi, tüm HTTP isteklerini ve yanıtlarını işleyen bir DispatcherServlet etrafında tasarlanmıştır . Spring Web MVC DispatcherServlet'in istek işleme iş akışı aşağıdaki diyagramda gösterilmektedir -
DispatcherServlet'e gelen bir HTTP isteğine karşılık gelen olaylar dizisi aşağıdadır -
Bir HTTP isteği aldıktan sonra DispatcherServlet , uygun Denetleyiciyi çağırmak için HandlerMapping'e başvurur .
Denetleyici isteği alır ve kullanılan GET veya POST yöntemiyle göre uygun hizmet yöntemlerini çağırır. Hizmet yöntemi, model verilerini tanımlanan iş mantığına göre ayarlar ve görünüm adını DispatcherServlet'e döndürür .
DispatcherServlet yardım alacak ViewResolver pikap istek için tanımlanmış bir görünüm.
Görünüm sonlandırıldığında, DispatcherServlet model verilerini nihayet tarayıcıda işlenen görünüme aktarır.
Yukarıda bahsedilen bileşenlerin tümü, yani HandlerMapping, Controller ve ViewResolver, web uygulamaları için gerekli bazı ekstra özelliklere sahip düz ApplicationContext'in bir uzantısı olan WebApplicationContext w'nin parçalarıdır .
Gerekli Yapılandırma
DispatcherServlet'in işlemesini istediğiniz istekleri, içinde bir URL eşlemesi kullanarak eşlemeniz gerekir.web.xmldosya. Aşağıdaki, bildirim ve eşlemeyi göstermek için bir örnektir.HelloWeb DispatcherServlet örneği -
<web-app id = "WebApp_ID" version = "2.4"
xmlns = "http://java.sun.com/xml/ns/j2ee"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>Spring MVC Application</display-name>
<servlet>
<servlet-name>HelloWeb</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>HelloWeb</servlet-name>
<url-pattern>*.jsp</url-pattern>
</servlet-mapping>
</web-app>web.xmldosyası, web uygulamanızın WebContent / WEB-INF dizininde tutulacaktır. BaşlatıldığındaHelloWeb DispatcherServlet, çerçeve uygulama bağlamını adlı bir dosyadan yüklemeye çalışacaktır. [servlet-name]-servlet.xmluygulamanın WebContent / WEB-INF dizininde bulunur. Bu durumda dosyamızHelloWebservlet.xml.
Ardından, <servlet-mapping> etiketi, hangi URL'lerin hangi DispatcherServlet tarafından işleneceğini belirtir. İşte ile biten tüm HTTP istekleri.jsp tarafından ele alınacak HelloWeb DispatcherServlet.
Varsayılan dosya adını [servlet-name] -servlet.xml ve varsayılan konumu WebContent / WEB-INF olarak gitmek istemiyorsanız , web.xml dosyanıza sunucu uygulaması dinleyicisi ContextLoaderListener ekleyerek bu dosya adını ve konumunu özelleştirebilirsiniz . aşağıdaki gibi -
<web-app...>
<!-------- DispatcherServlet definition goes here----->
....
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>Şimdi, gerekli konfigürasyonu kontrol edelim HelloWeb-servlet.xmldosyası, web uygulamanızın WebContent / WEB-INF dizinine yerleştirilir -
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:context = "http://www.springframework.org/schema/context"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package = "com.tutorialspoint" />
<bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name = "prefix" value = "/WEB-INF/jsp/" />
<property name = "suffix" value = ".jsp" />
</bean>
</beans>Aşağıdakiler hakkında önemli noktalar HelloWeb-servlet.xml dosya -
[Servlet-name] -servlet.xml dosya küresel kapsamda aynı adla tanımlanmış herhangi fasulye tanımları geçersiz kılma, tanımlanmış fasulye oluşturmak için kullanılacaktır.
<Bağlam: bileşen tarama ...> etiketi vb @Controller ve @ RequestMapping gibi ek açıklamaların kullanmasını sağlıyor etkinleştirmek Bahar MVC açıklama tarama yeteneği faydası dokunur
InternalResourceViewResolver görünümü adlarını çözümlemek için tanımlanmış kurallar olacaktır. Yukarıda tanımlanan kurala göre, adında bir mantıksal görünümhello/WEB-INF/jsp/hello.jsp adresinde bulunan bir görünüm uygulamasına delege edilmiştir .
Aşağıdaki bölüm, Kontrolör, Model ve Görünüm gibi gerçek bileşenlerinizi nasıl oluşturacağınızı gösterecektir.
Bir Denetleyicinin Tanımlanması
DispatcherServlet, denetleyicilere, kendisine özgü işlevselliği yürütme isteğini yetkilendirir. @Controllerek açıklama, belirli bir sınıfın bir denetleyici rolüne hizmet ettiğini gösterir. @RequestMapping ek açıklama, bir URL'yi tüm bir sınıfa veya belirli bir işleyici yöntemine eşlemek için kullanılır.
@Controller
@RequestMapping("/hello")
public class HelloController {
@RequestMapping(method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}@Controllerek açıklama, sınıfı bir Spring MVC denetleyicisi olarak tanımlar. Burada ilk kullanım@RequestMapping bu denetleyicideki tüm işleme yöntemlerinin, /helloyol. Sonraki açıklama@RequestMapping(method = RequestMethod.GET)HTTP GET isteğini işlemek için denetleyicinin varsayılan hizmet yöntemi olarakprintHello () yöntemini bildirmek için kullanılır. Herhangi bir POST isteğini aynı URL'de işlemek için başka bir yöntem tanımlayabilirsiniz.
Yukarıdaki denetleyiciyi, @RequestMapping'e aşağıdaki gibi ek öznitelikler ekleyebileceğiniz başka bir biçimde yazabilirsiniz -
@Controller
public class HelloController {
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}value öznitelik, işleyici yönteminin eşlendiği URL'yi ve methodöznitelik, HTTP GET isteğini işlemek için hizmet yöntemini tanımlar. Yukarıda tanımlanan kontrolör hakkında aşağıdaki önemli noktalara dikkat edilmelidir -
Bir hizmet yöntemi içinde gerekli iş mantığını tanımlayacaksınız. Gereksinime göre bu yöntemin içinde başka bir yöntemi çağırabilirsiniz.
Tanımlanan iş mantığına göre bu yöntem dahilinde bir model oluşturacaksınız. Ayarlayıcı farklı model özniteliklerini kullanabilirsiniz ve bu özniteliklere nihai sonucu sunmak için görünüm tarafından erişilebilir. Bu örnek, "mesaj" niteliğine sahip bir model oluşturur.
Tanımlanmış bir hizmet yöntemi, viewmodeli oluşturmak için kullanılacak. Bu örnek, mantıksal görünüm adı olarak "merhaba" döndürür.
JSP Görünümleri Oluşturma
Spring MVC, farklı sunum teknolojileri için birçok görünüm türünü destekler. Bunlar, JSP'ler, HTML, PDF, Excel çalışma sayfaları, XML, Velocity şablonları, XSLT, JSON, Atom ve RSS beslemeleri, JasperReports vb. İçerir. Ancak en yaygın olarak JSTL ile yazılmış JSP şablonlarını kullanırız.
Basit bir yazalım hello /WEB-INF/hello/hello.jsp içinde görüntüle -
<html>
<head>
<title>Hello Spring MVC</title>
</head>
<body>
<h2>${message}</h2>
</body>
</html>Buraya ${message}Kontrolör içinde kurduğumuz niteliktir. Görünümünüzün içinde görüntülenecek birden çok özelliğe sahip olabilirsiniz.
Spring Web MVC Çerçeve Örnekleri
Yukarıdaki kavramlara dayanarak, Bahar Web Uygulamalarınızı oluşturmanıza yardımcı olacak birkaç önemli örneği kontrol edelim -
| Sr.No. | Örnek ve Açıklama |
|---|---|
| 1 | Bahar MVC Merhaba Dünya Örneği Bu örnek, basit bir Spring Web Hello World uygulamasının nasıl yazılacağını açıklayacaktır. |
| 2 | Spring MVC Form İşleme Örneği Bu örnek, verileri denetleyiciye göndermek ve işlenmiş bir sonucu görüntülemek için HTML formlarını kullanarak bir Spring Web uygulamasının nasıl yazılacağını açıklayacaktır. |
| 3 | İlkbahar Sayfası Yeniden Yönlendirme Örneği Spring MVC Framework'te sayfa yeniden yönlendirme işlevini nasıl kullanacağınızı öğrenin. |
| 4 | Yay Statik Sayfaları Örneği Spring MVC Framework'te dinamik sayfaların yanı sıra statik sayfalara nasıl erişileceğini öğrenin. |
| 5 | Bahar Özel Durum İşleme Örneği Spring MVC Framework'te istisnaların nasıl ele alınacağını öğrenin. |
Bu, Spring uygulamaları içinde kullanımı çok kolay bir Log4J işlevidir. Aşağıdaki örnek, Log4J ve Spring arasındaki basit entegrasyonu açıklamak için sizi basit adımlardan geçirecektir.
Zaten sahip olduğunuzu varsayıyoruz log4Jmakinenize kurulur. Eğer sahip değilseniz, buradan indirebilirsiniz.https://logging.apache.org/ve sıkıştırılmış dosyayı herhangi bir klasöre çıkartın. Sadece kullanacağızlog4j-x.y.z.jar projemizde.
Ardından, çalışan bir Eclipse IDE'ye sahip olalım ve Spring Web Framework kullanarak Dinamik Form tabanlı bir Web Uygulaması geliştirmek için aşağıdaki adımları atalım -
| Adımlar | Açıklama |
|---|---|
| 1 | SpringExample adıyla bir proje oluşturun ve altında bir com.tutorialspoint paketi oluşturun .src oluşturulan projedeki klasör. |
| 2 | Bahar Merhaba Dünya Örneği bölümünde açıklandığı gibi Harici JAR Ekle seçeneğini kullanarak gerekli Bahar kitaplıklarını ekleyin . |
| 3 | Harici JAR Ekle kullanarak log4j kitaplığı log4j-xyzjar'ı projenize ekleyin . |
| 4 | Com.tutorialspoint paketi altında HelloWorld ve MainApp Java sınıfları oluşturun . |
| 5 | Beans yapılandırma dosyasını Beans.xml altında oluşturun.src Klasör. |
| 6 | LOG4J yapılandırma dosyası oluşturma log4j.properties altındasrc Klasör. |
| 7 | Son adım, tüm Java dosyalarının ve Bean Yapılandırma dosyasının içeriğini oluşturmak ve aşağıda açıklandığı gibi uygulamayı çalıştırmaktır. |
İşte içeriği HelloWorld.java dosya
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage() {
System.out.println("Your Message : " + message);
}
}İkinci dosyanın içeriği aşağıdadır MainApp.java
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.log4j.Logger;
public class MainApp {
static Logger log = Logger.getLogger(MainApp.class.getName());
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
log.info("Going to create HelloWord Obj");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
log.info("Exiting the program");
}
}Üretebilirsin debug ve errorbilgi mesajları oluşturduğumuza benzer şekilde mesaj. Şimdi içeriğini görelimBeans.xml dosya
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>Aşağıdakilerin içeriği log4j.properties Log4J'nin günlük mesajları oluşturması için gereken standart kuralları tanımlayan
# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE
# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
# Set the name of the file
log4j.appender.FILE.File=C:\\log.out
# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true
# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug
# Set the append to false, overwrite
log4j.appender.FILE.Append=false
# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%nKaynak ve bean yapılandırma dosyalarını oluşturmayı tamamladığınızda uygulamayı çalıştırmamıza izin verin. Uygulamanızda her şey yolundaysa, bu, Eclipse konsolunda aşağıdaki mesajı yazdıracaktır -
Your Message : Hello World!C: \\ sürücünüzü kontrol ederseniz, günlük dosyanızı bulmalısınız log.out aşağıdaki gibi çeşitli günlük mesajlarıyla -
<!-- initialization log messages -->
Going to create HelloWord Obj
Returning cached instance of singleton bean 'helloWorld'
Exiting the programJakarta Commons Logging (JCL) API'si
Alternatif olarak kullanabilirsiniz Jakarta Commons Logging (JCL)Spring uygulamanızda bir günlük oluşturmak için API. JCL şu adresten indirilebilir:https://jakarta.apache.org/commons/logging/. Bu pakette teknik olarak ihtiyacımız olan tek dosya , yukarıdaki örnekte log4j-xyzjar'ı koyduğunuza benzer bir şekilde sınıf yolunuza yerleştirilmesi gereken commons-logging-xyzjar dosyasıdır .
Günlük işlevini kullanmak için bir org.apache.commons.logging.Log nesnesine ihtiyacınız vardır ve ardından ihtiyacınıza göre aşağıdaki yöntemlerden birini çağırabilirsiniz -
- ölümcül (Nesne mesajı)
- hata (Nesne mesajı)
- warn (Nesne mesajı)
- bilgi (Nesne mesajı)
- hata ayıklama (Nesne mesajı)
- izleme (Nesne mesajı)
Aşağıda, JCL API'sini kullanan MainApp.java'nın yerini almaktadır.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.commons.logging. Log;
import org.apache.commons.logging. LogFactory;
public class MainApp {
static Log log = LogFactory.getLog(MainApp.class.getName());
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
log.info("Going to create HelloWord Obj");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
log.info("Exiting the program");
}
}Programı derleyip çalıştırmadan önce projenize commons-logging-xyzjar dosyasını dahil ettiğinizden emin olmalısınız.
Şimdi yukarıdaki örnekte konfigürasyonun ve içeriğin geri kalanını değiştirmeden tutarak, uygulamanızı derler ve çalıştırırsanız, Log4J API kullanarak elde ettiğiniz sonuca benzer bir sonuç alırsınız.