Spring - Panduan Cepat

Spring adalah framework pengembangan aplikasi paling populer untuk perusahaan Java. Jutaan pengembang di seluruh dunia menggunakan Spring Framework untuk membuat kode berkinerja tinggi, mudah diuji, dan dapat digunakan kembali.

Kerangka Spring adalah platform Java open source. Ini awalnya ditulis oleh Rod Johnson dan pertama kali dirilis di bawah lisensi Apache 2.0 pada Juni 2003.

Musim semi itu ringan dalam hal ukuran dan transparansi. Versi dasar framework Spring berukuran sekitar 2MB.

Fitur inti dari Spring Framework dapat digunakan dalam mengembangkan aplikasi Java apa pun, tetapi ada ekstensi untuk membangun aplikasi web di atas platform Java EE. Target framework Spring untuk membuat pengembangan J2EE lebih mudah digunakan dan mempromosikan praktik pemrograman yang baik dengan mengaktifkan model pemrograman berbasis POJO.

Manfaat Menggunakan Kerangka Pegas

Berikut ini adalah daftar beberapa manfaat besar menggunakan Spring Framework -

  • Spring memungkinkan pengembang untuk mengembangkan aplikasi kelas perusahaan menggunakan POJO. Manfaat menggunakan hanya POJO adalah Anda tidak memerlukan produk kontainer EJB seperti server aplikasi tetapi Anda memiliki pilihan untuk hanya menggunakan kontainer servlet yang kuat seperti Tomcat atau beberapa produk komersial.

  • Musim semi diatur secara modular. Meskipun jumlah paket dan kelasnya banyak, Anda hanya perlu mengkhawatirkan yang Anda butuhkan dan mengabaikan sisanya.

  • Spring tidak menemukan kembali roda, melainkan benar-benar menggunakan beberapa teknologi yang ada seperti beberapa kerangka ORM, kerangka kerja logging, JEE, Quartz dan JDK timer, dan teknologi tampilan lainnya.

  • Menguji aplikasi yang ditulis dengan Spring itu sederhana karena kode yang bergantung pada lingkungan dipindahkan ke kerangka kerja ini. Selain itu, dengan menggunakan POJO JavaBeanstyle, penggunaan injeksi ketergantungan untuk memasukkan data pengujian menjadi lebih mudah.

  • Kerangka web Spring adalah kerangka kerja MVC web yang dirancang dengan baik, yang memberikan alternatif yang bagus untuk kerangka kerja web seperti Struts atau kerangka kerja web lain yang direkayasa secara berlebihan atau kurang populer.

  • Spring menyediakan API yang nyaman untuk menerjemahkan pengecualian khusus teknologi (dilemparkan oleh JDBC, Hibernate, atau JDO, misalnya) menjadi pengecualian yang konsisten dan tidak dicentang.

  • Kontainer IoC yang ringan cenderung lebih ringan, terutama jika dibandingkan dengan kontainer EJB, misalnya. Ini bermanfaat untuk mengembangkan dan menerapkan aplikasi di komputer dengan memori dan sumber daya CPU terbatas.

  • Spring menyediakan antarmuka manajemen transaksi yang konsisten yang dapat menurunkan skala ke transaksi lokal (menggunakan database tunggal, misalnya) dan meningkatkan ke transaksi global (menggunakan JTA, misalnya).

Dependency Injection (DI)

Teknologi yang paling identik dengan Spring adalah Dependency Injection (DI)rasa dari Inversi Kontrol. ItuInversion of Control (IoC)adalah konsep umum, dan dapat diekspresikan dalam berbagai cara. Dependency Injection hanyalah salah satu contoh konkret dari Inversi Kontrol.

Saat menulis aplikasi Java yang kompleks, kelas aplikasi harus sebebas mungkin dari kelas Java lainnya untuk meningkatkan kemungkinan menggunakan kembali kelas-kelas ini dan mengujinya secara independen dari kelas lain saat pengujian unit. Injeksi Ketergantungan membantu dalam merekatkan kelas-kelas ini bersama-sama dan pada saat yang sama menjaganya tetap independen.

Apa sebenarnya injeksi ketergantungan itu? Mari kita lihat dua kata ini secara terpisah. Di sini bagian dependensi diterjemahkan menjadi asosiasi antara dua kelas. Sebagai contoh, kelas A bergantung pada kelas B. Sekarang, mari kita lihat bagian kedua, injeksi. Artinya, kelas B akan disuntikkan ke kelas A oleh IoC.

Injeksi ketergantungan dapat terjadi dengan cara meneruskan parameter ke konstruktor atau dengan pasca konstruksi menggunakan metode penyetel. Karena Injeksi Ketergantungan adalah inti dari Kerangka Pegas, kami akan menjelaskan konsep ini dalam bab terpisah dengan contoh yang relevan.

Aspect Oriented Programming (AOP)

Salah satu komponen utama Spring adalah Aspect Oriented Programming (AOP)kerangka. Fungsi yang menjangkau banyak titik aplikasi disebutcross-cutting concernsdan masalah lintas bidang ini secara konseptual terpisah dari logika bisnis aplikasi. Ada berbagai contoh bagus dari aspek termasuk logging, transaksi deklaratif, keamanan, caching, dll.

Unit kunci dari modularitas di OOP adalah class, sedangkan di AOP unit modularity adalah aspeknya. DI membantu Anda memisahkan objek aplikasi dari satu sama lain, sementara AOP membantu Anda memisahkan masalah lintas sektor dari objek yang terpengaruh.

Modul AOP Spring Framework menyediakan implementasi pemrograman berorientasi aspek yang memungkinkan Anda untuk mendefinisikan metode-interseptor dan pointcut untuk memisahkan kode dengan rapi yang mengimplementasikan fungsionalitas yang harus dipisahkan. Kami akan membahas lebih lanjut tentang konsep Spring AOP di bab terpisah.

Spring berpotensi menjadi toko serba ada untuk semua aplikasi perusahaan Anda. Namun, Spring bersifat modular, memungkinkan Anda untuk memilih modul mana yang sesuai untuk Anda, tanpa harus membawa modul lainnya. Bagian berikut memberikan detail tentang semua modul yang tersedia di Spring Framework.

Framework Spring menyediakan sekitar 20 modul yang dapat digunakan berdasarkan kebutuhan aplikasi.

Kontainer Inti

Kontainer Inti terdiri dari modul Core, Beans, Context, dan Expression Language yang detailnya adalah sebagai berikut -

  • Itu Core modul menyediakan bagian-bagian dasar kerangka kerja, termasuk fitur IoC dan Injeksi Ketergantungan.

  • Itu Bean modul menyediakan BeanFactory, yang merupakan implementasi canggih dari pola pabrik.

  • Itu Contextmodul dibangun di atas dasar kokoh yang disediakan oleh modul Core and Beans dan merupakan media untuk mengakses objek apa pun yang ditentukan dan dikonfigurasi. Antarmuka ApplicationContext adalah titik fokus dari modul Konteks.

  • Itu SpEL modul menyediakan bahasa ekspresi yang kuat untuk menanyakan dan memanipulasi grafik objek saat runtime.

Akses / Integrasi Data

Lapisan Akses / Integrasi Data terdiri dari modul JDBC, ORM, OXM, JMS, dan Transaksi yang detailnya adalah sebagai berikut -

  • Itu JDBC modul menyediakan lapisan abstraksi JDBC yang menghilangkan kebutuhan akan pengkodean terkait JDBC yang membosankan.

  • Itu ORM modul menyediakan lapisan integrasi untuk API pemetaan relasional objek yang populer, termasuk JPA, JDO, Hibernate, dan iBatis.

  • Itu OXM modul menyediakan lapisan abstraksi yang mendukung implementasi pemetaan Objek / XML untuk JAXB, Castor, XMLBeans, JiBX dan XStream.

  • Layanan Pesan Java JMS modul berisi fitur untuk menghasilkan dan menggunakan pesan.

  • Itu Transaction modul mendukung manajemen transaksi terprogram dan deklaratif untuk kelas yang mengimplementasikan antarmuka khusus dan untuk semua POJO Anda.

Web

Lapisan Web terdiri dari modul Web, Web-MVC, Web-Socket, dan Web-Portlet yang rinciannya adalah sebagai berikut -

  • Itu Web modul menyediakan fitur integrasi berorientasi web dasar seperti fungsionalitas unggah file multi-bagian dan inisialisasi wadah IoC menggunakan pendengar servlet dan konteks aplikasi berorientasi web.

  • Itu Web-MVC modul berisi implementasi Model-View-Controller (MVC) Spring untuk aplikasi web.

  • Itu Web-Socket modul menyediakan dukungan untuk komunikasi dua arah berbasis WebSocket antara klien dan server dalam aplikasi web.

  • Itu Web-Portlet modul menyediakan implementasi MVC untuk digunakan dalam lingkungan portlet dan mencerminkan fungsionalitas modul Web-Servlet.

Miscellaneous

Ada beberapa modul penting lainnya seperti modul AOP, Aspects, Instrumentation, Web dan Test yang detailnya adalah sebagai berikut -

  • Itu AOP module menyediakan implementasi pemrograman berorientasi aspek yang memungkinkan Anda untuk mendefinisikan method-interseptor dan pointcut untuk memisahkan kode dengan rapi yang mengimplementasikan fungsionalitas yang harus dipisahkan.

  • Itu Aspects modul menyediakan integrasi dengan AspectJ, yang sekali lagi merupakan kerangka kerja AOP yang kuat dan matang.

  • Itu Instrumentation modul menyediakan dukungan instrumentasi kelas dan implementasi pemuat kelas untuk digunakan di server aplikasi tertentu.

  • Itu Messagingmodul memberikan dukungan untuk STOMP sebagai sub-protokol WebSocket untuk digunakan dalam aplikasi. Ini juga mendukung model pemrograman anotasi untuk perutean dan pemrosesan pesan STOMP dari klien WebSocket.

  • Itu Test modul mendukung pengujian komponen Spring dengan kerangka JUnit atau TestNG.

Bab ini akan memandu Anda tentang cara mempersiapkan lingkungan pengembangan untuk memulai pekerjaan Anda dengan Spring Framework. Ini juga akan mengajari Anda cara mengatur JDK, Tomcat dan Eclipse pada mesin Anda sebelum Anda mengatur Spring Framework -

Langkah 1 - Siapkan Java Development Kit (JDK)

Anda dapat mengunduh versi terbaru SDK dari situs Java Oracle - Unduhan Java SE. Anda akan menemukan instruksi untuk menginstal JDK dalam file yang diunduh, ikuti instruksi yang diberikan untuk menginstal dan mengkonfigurasi pengaturan. Terakhir, setel variabel lingkungan PATH dan JAVA_HOME untuk merujuk ke direktori yang berisi java dan javac, biasanya masing-masing java_install_dir / bin dan java_install_dir.

Jika Anda menjalankan Windows dan telah menginstal JDK di C: \ jdk1.6.0_15, Anda harus meletakkan baris berikut di file C: \ autoexec.bat Anda.

set PATH=C:\jdk1.6.0_15\bin;%PATH% 
set JAVA_HOME=C:\jdk1.6.0_15

Atau, pada Windows NT / 2000 / XP, Anda harus mengklik kanan pada My Computer, pilih Properties → Advanced → Environment Variables. Kemudian, Anda harus memperbarui nilai PATH dan mengklik tombol OK.

Di Unix (Solaris, Linux, dll.), Jika SDK diinstal di /usr/local/jdk1.6.0_15 dan Anda menggunakan shell C, Anda harus memasukkan yang berikut ini ke dalam file .cshrc Anda.

setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH 
setenv JAVA_HOME /usr/local/jdk1.6.0_15

Alternatifnya, jika Anda menggunakan Integrated Development Environment (IDE) seperti Borland JBuilder, Eclipse, IntelliJ IDEA, atau Sun ONE Studio, Anda harus mengompilasi dan menjalankan program sederhana untuk memastikan bahwa IDE mengetahui di mana Anda menginstal Java. Jika tidak, Anda harus melakukan penyiapan yang tepat seperti yang diberikan dalam dokumen IDE.

Langkah 2 - Instal Apache Common Logging API

Anda dapat mengunduh Apache Commons Logging API versi terbaru dari https://commons.apache.org/logging/. Setelah Anda mengunduh instalasi, buka paket distribusi biner ke lokasi yang nyaman. Misalnya, di C: \ commons-logging-1.1.1 di Windows, atau /usr/local/commons-logging-1.1.1 di Linux / Unix. Direktori ini akan memiliki file jar berikut dan dokumen pendukung lainnya, dll.

Pastikan Anda menyetel variabel CLASSPATH Anda pada direktori ini dengan benar jika tidak, Anda akan menghadapi masalah saat menjalankan aplikasi Anda.

Langkah 3 - Siapkan Eclipse IDE

Semua contoh dalam tutorial ini telah ditulis menggunakan Eclipse IDE. Jadi kami menyarankan Anda harus menginstal Eclipse versi terbaru di komputer Anda.

Untuk menginstal Eclipse IDE, unduh binari Eclipse terbaru dari https://www.eclipse.org/downloads/. Setelah Anda mengunduh instalasi, buka paket distribusi biner ke lokasi yang nyaman. Misalnya, di C: \ eclipse di Windows, atau / usr / local / eclipse di Linux / Unix dan terakhir atur variabel PATH dengan tepat.

Eclipse dapat dimulai dengan menjalankan perintah berikut di mesin Windows, atau Anda cukup mengklik dua kali pada eclipse.exe

%C:\eclipse\eclipse.exe

Eclipse dapat dimulai dengan menjalankan perintah berikut di mesin Unix (Solaris, Linux, dll.) -

$/usr/local/eclipse/eclipse

Setelah startup berhasil, jika semuanya baik-baik saja maka itu akan menampilkan hasil sebagai berikut -

Langkah 4 - Siapkan Perpustakaan Kerangka Musim Semi

Sekarang jika semuanya baik-baik saja, maka Anda dapat melanjutkan untuk menyiapkan kerangka Spring Anda. Berikut adalah langkah-langkah sederhana untuk mendownload dan menginstal framework di komputer Anda.

  • Tentukan pilihan apakah Anda ingin menginstal Spring di Windows atau Unix, lalu lanjutkan ke langkah berikutnya untuk mengunduh file .zip untuk Windows dan file .tz untuk Unix.

  • Unduh versi terbaru biner kerangka kerja Spring dari https://repo.spring.io/release/org/springframework/spring.

  • Pada saat mengembangkan tutorial ini, spring-framework-4.1.6.RELEASE-dist.ziptelah diunduh di mesin Windows. Setelah file yang diunduh dibuka ritsletingnya, ini memberikan struktur direktori berikut di dalam E: \ spring.

Anda akan menemukan semua perpustakaan Spring di direktori E:\spring\libs. Pastikan Anda menyetel variabel CLASSPATH Anda pada direktori ini dengan benar jika tidak, Anda akan menghadapi masalah saat menjalankan aplikasi Anda. Jika Anda menggunakan Eclipse, maka tidak perlu mengatur CLASSPATH karena semua pengaturan akan dilakukan melalui Eclipse.

Setelah Anda selesai dengan langkah terakhir ini, Anda siap untuk melanjutkan ke Contoh Musim Semi pertama Anda di bab berikutnya.

Mari kita mulai pemrograman aktual dengan Spring Framework. Sebelum Anda mulai menulis contoh pertama Anda menggunakan kerangka kerja Spring, Anda harus memastikan bahwa Anda telah mengatur lingkungan Spring Anda dengan benar seperti yang dijelaskan di Spring - Bab Pengaturan Lingkungan . Kami juga berasumsi bahwa Anda memiliki sedikit pengetahuan tentang Eclipse IDE.

Sekarang mari kita lanjutkan untuk menulis Aplikasi Musim Semi sederhana, yang akan mencetak "Hello World!" atau pesan lain berdasarkan konfigurasi yang dilakukan di file Konfigurasi Spring Beans.

Langkah 1 - Buat Proyek Java

Langkah pertama adalah membuat Proyek Java sederhana menggunakan Eclipse IDE. Ikuti opsinyaFile → New → Project dan akhirnya pilih Java Projectwizard dari daftar wizard. Sekarang beri nama proyek Anda sebagaiHelloSpring menggunakan jendela wizard sebagai berikut -

Setelah proyek Anda berhasil dibuat, Anda akan memiliki konten berikut di Project Explorer -

Langkah 2 - Tambahkan Perpustakaan yang Diperlukan

Sebagai langkah kedua, mari kita tambahkan Spring Framework dan pustaka API logging umum dalam proyek kita. Untuk melakukan ini, klik kanan pada nama proyek AndaHelloSpring dan kemudian ikuti opsi berikut yang tersedia di menu konteks - Build Path → Configure Build Path untuk menampilkan jendela Java Build Path sebagai berikut -

Sekarang gunakan Add External JARs tombol tersedia di bawah Libraries tab untuk menambahkan JAR inti berikut dari direktori instalasi Spring Framework dan Common Logging -

  • 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

Langkah 3 - Buat File Sumber

Sekarang mari kita buat file sumber aktual di bawah HelloSpringproyek. Pertama kita perlu membuat paket bernamacom.tutorialspoint. Untuk melakukan ini, klik kanansrc di bagian penjelajah paket dan ikuti opsi - New → Package.

Selanjutnya kita akan membuat HelloWorld.java dan MainApp.java file di bawah paket com.tutorialspoint.

Berikut adalah konten dari 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);
   }
}

Berikut adalah isi dari file kedua 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();
   }
}

Berikut dua poin penting yang harus diperhatikan tentang program utama -

  • Langkah pertama adalah membuat konteks aplikasi tempat kami menggunakan API kerangka kerja ClassPathXmlApplicationContext(). API ini memuat file konfigurasi kacang dan akhirnya berdasarkan API yang disediakan, API ini menangani pembuatan dan inisialisasi semua objek, yaitu kacang yang disebutkan dalam file konfigurasi.

  • Langkah kedua digunakan untuk mendapatkan kacang yang dibutuhkan dengan menggunakan getBean()metode dari konteks yang dibuat. Metode ini menggunakan ID kacang untuk mengembalikan objek generik, yang akhirnya dapat dicor ke objek sebenarnya. Setelah Anda memiliki objek, Anda dapat menggunakan objek ini untuk memanggil metode kelas apa pun.

Langkah 4 - Buat File Konfigurasi Bean

Anda perlu membuat file Konfigurasi Kacang yang merupakan file XML dan bertindak sebagai semen yang merekatkan kacang, yaitu kelas bersama. File ini perlu dibuat di bawahsrc direktori seperti yang ditunjukkan pada tangkapan layar berikut -

Biasanya pengembang menamai file ini sebagai Beans.xml, tetapi Anda bebas memilih nama apa pun yang Anda suka. Anda harus memastikan bahwa file ini tersedia di CLASSPATH dan menggunakan nama yang sama di aplikasi utama saat membuat konteks aplikasi seperti yang ditunjukkan di file MainApp.java.

Beans.xml digunakan untuk menetapkan ID unik ke kacang yang berbeda dan untuk mengontrol pembuatan objek dengan nilai yang berbeda tanpa memengaruhi file sumber Spring apa pun. Misalnya, menggunakan file berikut, Anda dapat meneruskan nilai apa pun untuk variabel "message" dan Anda dapat mencetak nilai pesan yang berbeda tanpa memengaruhi file HelloWorld.java dan MainApp.java. Mari kita lihat cara kerjanya -

<?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>

Ketika aplikasi Spring dimuat ke dalam memori, Framework menggunakan file konfigurasi di atas untuk membuat semua kacang yang ditentukan dan memberinya ID unik seperti yang ditentukan di <bean>menandai. Kamu dapat memakai<property> tag untuk meneruskan nilai variabel berbeda yang digunakan pada saat pembuatan objek.

Langkah 5 - Menjalankan Program

Setelah Anda selesai membuat file konfigurasi source dan beans, Anda siap untuk langkah ini, yaitu mengkompilasi dan menjalankan program Anda. Untuk melakukan ini, biarkan tab file MainApp.Java aktif dan gunakan salah satunyaRun pilihan yang tersedia di Eclipse IDE atau gunakan Ctrl + F11 untuk mengkompilasi dan menjalankan file MainAppaplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, ini akan mencetak pesan berikut di konsol Eclipse IDE -

Your Message : Hello World!

Selamat, Anda telah berhasil membuat Aplikasi Musim Semi pertama Anda. Anda dapat melihat fleksibilitas aplikasi Spring di atas dengan mengubah nilai properti "message" dan menjaga kedua file sumber tidak diubah.

Wadah Pegas adalah inti dari Kerangka Pegas. Penampung akan membuat objek, menyatukannya, mengkonfigurasinya, dan mengelola siklus hidup lengkapnya dari pembuatan hingga penghancuran. Wadah Pegas menggunakan DI untuk mengelola komponen yang membentuk aplikasi. Benda-benda ini disebut Kacang Musim Semi, yang akan kita bahas di bab selanjutnya.

Container mendapatkan instruksinya tentang objek apa yang harus dibuat instance, dikonfigurasi, dan dirakit dengan membaca metadata konfigurasi yang disediakan. Metadata konfigurasi dapat direpresentasikan dengan XML, penjelasan Java, atau kode Java. Diagram berikut menunjukkan tampilan tingkat tinggi tentang cara kerja Spring. Container Spring IoC menggunakan class Java POJO dan metadata konfigurasi untuk menghasilkan sistem atau aplikasi yang sepenuhnya dikonfigurasi dan dapat dijalankan.

Spring menyediakan dua jenis wadah berikut ini.

Sr.No. Wadah & Deskripsi
1 Spring BeanFactory Container

Ini adalah wadah paling sederhana yang menyediakan dukungan dasar untuk DI dan ditentukan oleh antarmuka org.springframework.beans.factory.BeanFactory . BeanFactory dan antarmuka terkait, seperti BeanFactoryAware, InitializingBean, DisposableBean, masih ada di Spring untuk tujuan kompatibilitas ke belakang dengan sejumlah besar framework pihak ketiga yang terintegrasi dengan Spring.

2 Kontainer Konteks Aplikasi Musim Semi

Penampung ini menambahkan lebih banyak fungsi khusus perusahaan seperti kemampuan untuk menyelesaikan pesan tekstual dari file properti dan kemampuan untuk memublikasikan peristiwa aplikasi ke pemroses peristiwa yang tertarik. Penampung ini ditentukan oleh antarmuka org.springframework.context.ApplicationContext .

The ApplicationContext kontainer mencakup semua fungsi dari BeanFactory wadah, sehingga umumnya direkomendasikan atas BeanFactory . BeanFactory masih dapat digunakan untuk aplikasi ringan seperti perangkat seluler atau aplikasi berbasis applet di mana volume dan kecepatan data signifikan.

Objek yang membentuk tulang punggung aplikasi Anda dan yang dikelola oleh container IoC Spring dipanggil beans. Kacang adalah objek yang dibuat, dirakit, dan dikelola oleh wadah Spring IoC. Kacang ini dibuat dengan metadata konfigurasi yang Anda berikan ke penampung. Misalnya, dalam bentuk definisi XML <bean /> yang sudah Anda lihat di bab sebelumnya.

Definisi kacang berisi informasi yang disebut configuration metadata, yang diperlukan agar wadah mengetahui hal berikut -

  • Cara membuat kacang
  • Detail siklus hidup Bean
  • Ketergantungan kacang

Semua konfigurasi metadata di atas diterjemahkan ke dalam satu set properti berikut yang membentuk setiap definisi kacang.

Sr.No. Properti & Deskripsi
1

class

Atribut ini wajib dan menentukan kelas kacang yang akan digunakan untuk membuat kacang.

2

name

Atribut ini menetapkan pengenal kacang secara unik. Dalam konfigurasi metadata berbasis XML, Anda menggunakan atribut id dan / atau nama untuk menentukan pengenal kacang.

3

scope

Atribut ini menentukan ruang lingkup objek yang dibuat dari definisi kacang tertentu dan itu akan dibahas dalam bab cakupan kacang.

4

constructor-arg

Ini digunakan untuk memasukkan dependensi dan akan dibahas di bab-bab selanjutnya.

5

properties

Ini digunakan untuk memasukkan dependensi dan akan dibahas di bab-bab selanjutnya.

6

autowiring mode

Ini digunakan untuk memasukkan dependensi dan akan dibahas di bab-bab selanjutnya.

7

lazy-initialization mode

Kacang yang diinisialisasi malas memberi tahu container IoC untuk membuat instance kacang saat pertama kali diminta, bukan saat startup.

8

initialization method

Sebuah callback yang akan dipanggil setelah semua properti yang diperlukan pada bean telah disetel oleh container. Ini akan dibahas pada bab siklus hidup kacang.

9

destruction method

Callback yang akan digunakan saat wadah yang berisi kacang dihancurkan. Ini akan dibahas pada bab siklus hidup kacang.

Metadata Konfigurasi Musim Semi

Penampung Spring IoC benar-benar dipisahkan dari format tempat metadata konfigurasi ini sebenarnya ditulis. Berikut adalah tiga metode penting untuk menyediakan metadata konfigurasi ke Spring Container -

  • File konfigurasi berbasis XML.
  • Konfigurasi berbasis anotasi
  • Konfigurasi berbasis Java

Anda telah melihat bagaimana metadata konfigurasi berbasis XML diberikan ke penampung, tetapi mari kita lihat contoh lain dari file konfigurasi berbasis XML dengan definisi kacang yang berbeda termasuk inisialisasi malas, metode inisialisasi, dan metode penghancuran -

<?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>

Anda dapat memeriksa Contoh Spring Hello World untuk memahami cara menentukan, mengkonfigurasi, dan membuat Spring Beans.

Kami akan membahas tentang Konfigurasi Berbasis Anotasi dalam bab terpisah. Ini sengaja dibahas dalam bab terpisah karena kami ingin Anda memahami beberapa konsep Spring penting lainnya, sebelum Anda memulai pemrograman dengan Spring Dependency Injection with Annotations.

Saat mendefinisikan <bean> Anda memiliki pilihan untuk mendeklarasikan ruang lingkup untuk kacang itu. Misalnya, untuk memaksa Spring menghasilkan instance kacang baru setiap kali diperlukan, Anda harus mendeklarasikan atribut scope kacang menjadiprototype. Demikian pula, jika Anda ingin Spring mengembalikan instance kacang yang sama setiap kali dibutuhkan, Anda harus mendeklarasikan atribut scope kacang menjadisingleton.

Framework Spring mendukung lima cakupan berikut, tiga di antaranya hanya tersedia jika Anda menggunakan ApplicationContext yang sadar web.

Sr.No. Ruang Lingkup & Deskripsi
1

singleton

Ini mencakup definisi kacang ke satu instance per kontainer Spring IoC (default).

2

prototype

Ini mencakup definisi kacang tunggal untuk memiliki sejumlah contoh objek.

3

request

Ini mencakup definisi kacang ke permintaan HTTP. Hanya valid dalam konteks Spring ApplicationContext yang sadar web.

4

session

Ini mencakup definisi kacang ke sesi HTTP. Hanya valid dalam konteks Spring ApplicationContext yang sadar web.
5

global-session

Ini mencakup definisi kacang ke sesi HTTP global. Hanya valid dalam konteks Spring ApplicationContext yang sadar web.

Dalam bab ini, kita akan membahas tentang dua cakupan pertama dan tiga sisanya akan dibahas ketika kita membahas Spring ApplicationContext web-aware.

Ruang lingkup tunggal

Jika cakupan disetel ke tunggal, wadah Spring IoC membuat persis satu contoh objek yang ditentukan oleh definisi kacang itu. Contoh tunggal ini disimpan dalam cache dari kacang tunggal tersebut, dan semua permintaan dan referensi berikutnya untuk kacang bernama itu mengembalikan objek yang di-cache.

Cakupan default selalu tunggal. Namun, ketika Anda membutuhkan satu dan hanya satu contoh kacang, Anda dapat mengaturscope properti untuk singleton di file konfigurasi bean, seperti yang ditunjukkan pada potongan kode berikut -

<!-- A bean definition with singleton scope -->
<bean id = "..." class = "..." scope = "singleton">
   <!-- collaborators and configuration for this bean go here -->
</bean>

Contoh

Mari kita memiliki IDE Eclipse yang berfungsi dan mengambil langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java HelloWorld dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari 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);
   }
}

Berikut ini adalah konten dari MainApp.java file -

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();
   }
}

Berikut adalah file konfigurasinya Beans.xml diperlukan untuk lingkup tunggal -

<?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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

Your Message : I'm object A
Your Message : I'm object A

Ruang lingkup prototipe

Jika ruang lingkup disetel ke prototipe, wadah Spring IoC membuat turunan kacang baru dari objek setiap kali permintaan untuk kacang spesifik itu dibuat. Sebagai aturan, gunakan cakupan prototipe untuk semua kacang status-penuh dan cakupan tunggal untuk kacang tanpa status.

Untuk menentukan cakupan prototipe, Anda dapat mengatur scope properti untuk prototype di file konfigurasi bean, seperti yang ditunjukkan pada potongan kode berikut -

<!-- A bean definition with prototype scope -->
<bean id = "..." class = "..." scope = "prototype">
   <!-- collaborators and configuration for this bean go here -->
</bean>

Contoh

Mari kita siapkan Eclipse IDE dan ikuti langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java HelloWorld dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari HelloWorld.java mengajukan

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);
   }
}

Berikut ini adalah konten dari MainApp.java file -

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();
   }
}

Berikut adalah file konfigurasinya Beans.xml diperlukan untuk ruang lingkup prototipe -

<?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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

Your Message : I'm object A
Your Message : null

Siklus hidup kacang pegas mudah dimengerti. Ketika sebuah kacang dibuat, itu mungkin diperlukan untuk melakukan beberapa inisialisasi untuk membuatnya menjadi keadaan yang dapat digunakan. Demikian pula, jika biji tidak lagi diperlukan dan dikeluarkan dari wadah, pembersihan mungkin diperlukan.

Meskipun, ada daftar aktivitas yang terjadi di belakang layar antara waktu Instansiasi kacang dan penghancurannya, bab ini hanya akan membahas dua metode panggilan balik siklus hidup kacang yang penting, yang diperlukan pada saat inisialisasi kacang dan penghancurannya.

Untuk mendefinisikan setup dan teardown untuk bean, kita cukup mendeklarasikan <bean> dengan initmethod dan / atau destroy-methodparameter. Atribut init-method menentukan metode yang akan dipanggil pada bean segera setelah pembuatan instance. Demikian pula, destroymethod menentukan metode yang dipanggil tepat sebelum kacang dikeluarkan dari wadah.

Callback inisialisasi

Antarmuka org.springframework.beans.factory.InitializingBean menentukan metode tunggal -

void afterPropertiesSet() throws Exception;

Jadi, Anda cukup mengimplementasikan antarmuka di atas dan pekerjaan inisialisasi dapat dilakukan di dalam metode afterPropertiesSet () sebagai berikut -

public class ExampleBean implements InitializingBean {
   public void afterPropertiesSet() {
      // do some initialization work
   }
}

Dalam kasus metadata konfigurasi berbasis XML, Anda dapat menggunakan init-methodatribut untuk menentukan nama metode yang memiliki tanda tangan tanpa argumen kosong. Misalnya -

<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>

Berikut adalah definisi kelas -

public class ExampleBean {
   public void init() {
      // do some initialization work
   }
}

Callback kehancuran

The org.springframework.beans.factory.DisposableBean antarmuka menentukan metode tunggal -

void destroy() throws Exception;

Dengan demikian, Anda cukup mengimplementasikan antarmuka di atas dan pekerjaan finalisasi dapat dilakukan di dalam metode destroy () sebagai berikut -

public class ExampleBean implements DisposableBean {
   public void destroy() {
      // do some destruction work
   }
}

Dalam kasus metadata konfigurasi berbasis XML, Anda dapat menggunakan destroy-methodatribut untuk menentukan nama metode yang memiliki tanda tangan tanpa argumen kosong. Misalnya -

<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>

Berikut adalah definisi kelas -

public class ExampleBean {
   public void destroy() {
      // do some destruction work
   }
}

Jika Anda menggunakan container IoC Spring di lingkungan aplikasi non-web; misalnya, di lingkungan desktop klien yang kaya, Anda mendaftarkan hook shutdown dengan JVM. Melakukan hal itu memastikan pematian yang lancar dan memanggil metode penghancuran yang relevan pada kacang tunggal Anda sehingga semua sumber daya dilepaskan.

Anda disarankan untuk tidak menggunakan callback InitializingBean atau DisposableBean, karena konfigurasi XML memberikan banyak fleksibilitas dalam hal penamaan metode Anda.

Contoh

Mari kita memiliki IDE Eclipse yang berfungsi dan mengambil langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java HelloWorld dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari 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);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy() {
      System.out.println("Bean will destroy now.");
   }
}

Berikut ini adalah konten dari MainApp.javamengajukan. Di sini Anda perlu mendaftarkan hook penutupregisterShutdownHook()metode yang dideklarasikan pada kelas AbstractApplicationContext. Ini akan memastikan shutdown yang baik dan memanggil metode penghancuran yang relevan.

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();
   }
}

Berikut adalah file konfigurasinya Beans.xml diperlukan untuk metode init dan penghancuran -

<?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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

Bean is going through init.
Your Message : Hello World!
Bean will destroy now.

Inisialisasi default dan metode penghancuran

Jika Anda memiliki terlalu banyak kacang yang memiliki inisialisasi dan / atau menghancurkan metode dengan nama yang sama, Anda tidak perlu mendeklarasikan init-method dan destroy-methodpada setiap biji. Sebaliknya, kerangka kerja memberikan fleksibilitas untuk mengonfigurasi penggunaan situasi seperti itudefault-init-method dan default-destroy-method atribut pada elemen <beans> sebagai berikut -

<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>

Itu BeanPostProcessor interface mendefinisikan metode callback yang dapat Anda implementasikan untuk menyediakan logika instantiation Anda sendiri, logika resolusi dependensi, dll. Anda juga dapat mengimplementasikan beberapa logika kustom setelah container Spring selesai membuat instance, mengkonfigurasi, dan menginisialisasi bean dengan memasukkan satu atau lebih implementasi BeanPostProcessor .

Anda dapat mengkonfigurasi beberapa antarmuka BeanPostProcessor dan Anda dapat mengontrol urutan di mana antarmuka BeanPostProcessor ini dijalankan dengan mengatur order properti asalkan BeanPostProcessor mengimplementasikan Ordered antarmuka.

BeanPostProcessors beroperasi pada instance kacang (atau objek), yang berarti bahwa container IoC Spring membuat instance bean dan kemudian antarmuka BeanPostProcessor melakukan tugasnya.

Sebuah ApplicationContext otomatis mendeteksi kacang apa pun yang ditentukan dengan penerapan file BeanPostProcessor antarmuka dan mendaftarkan kacang ini sebagai postprocessor, untuk kemudian dipanggil secara tepat oleh wadah setelah pembuatan kacang.

Contoh

Contoh berikut ini menunjukkan cara menulis, mendaftar, dan menggunakan BeanPostProcessors dalam konteks ApplicationContext.

Mari kita memiliki IDE Eclipse yang berfungsi dan mengambil langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java HelloWorld , InitHelloWorld dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari 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);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

Ini adalah contoh yang sangat mendasar dari implementasi BeanPostProcessor, yang mencetak nama kacang sebelum dan sesudah inisialisasi kacang apa pun. Anda dapat mengimplementasikan logika yang lebih kompleks sebelum dan setelah menginisialisasi bean karena Anda memiliki akses pada objek bean di dalam kedua metode post processor.

Berikut adalah konten dari InitHelloWorld.java file -

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
   }
}

Berikut ini adalah konten dari MainApp.javamengajukan. Di sini Anda perlu mendaftarkan hook penutupregisterShutdownHook()metode yang dideklarasikan pada kelas AbstractApplicationContext. Ini akan memastikan shutdown yang baik dan memanggil metode penghancuran yang relevan.

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();
   }
}

Berikut adalah file konfigurasinya Beans.xml diperlukan untuk metode init dan penghancuran -

<?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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.

Definisi bean dapat berisi banyak informasi konfigurasi, termasuk argumen konstruktor, nilai properti, dan informasi khusus container seperti metode inisialisasi, nama metode pabrik statis, dan sebagainya.

Definisi kacang anak mewarisi data konfigurasi dari definisi induk. Definisi anak dapat mengganti beberapa nilai, atau menambahkan yang lain, sesuai kebutuhan.

Pewarisan definisi Spring Bean tidak ada hubungannya dengan pewarisan kelas Java tetapi konsep pewarisannya sama. Anda dapat mendefinisikan definisi kacang induk sebagai template dan kacang anak lainnya dapat mewarisi konfigurasi yang diperlukan dari kacang induk.

Saat Anda menggunakan metadata konfigurasi berbasis XML, Anda menunjukkan definisi kacang anak dengan menggunakan file parent atribut, menentukan kacang induk sebagai nilai atribut ini.

Contoh

Mari kita memiliki IDE Eclipse yang berfungsi dan mengambil langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java HelloWorld , HelloIndia dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah file konfigurasinya Beans.xmldimana kita mendefinisikan kacang "helloWorld" yang memiliki dua properti message1 dan message2 . Selanjutnya kacang "helloIndia" telah didefinisikan sebagai anak dari kacang "helloWorld" dengan menggunakanparentatribut. Kacang anak mewarisi properti message2 sebagaimana adanya, dan menimpa properti message1 dan memperkenalkan satu lagi properti message3 .

<?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>

Berikut adalah konten dari HelloWorld.java file -

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);
   }
}

Berikut adalah konten dari HelloIndia.java file -

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);
   }
}

Berikut ini adalah konten dari MainApp.java file -

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();
   }
}

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

World Message1 : Hello World!
World Message2 : Hello Second World!
India Message1 : Hello India!
India Message2 : Hello Second World!
India Message3 : Namaste India!

Jika Anda mengamati di sini, kami tidak melewatkan message2 saat membuat kacang "helloIndia", tetapi diteruskan karena Bean Definition Inheritance.

Templat Definisi Kacang

Anda dapat membuat template definisi Bean, yang dapat digunakan oleh definisi kacang turunan lainnya tanpa harus bersusah payah. Saat menentukan Templat Definisi Kacang, Anda tidak boleh menentukanclass atribut dan harus menentukan abstract atribut dan harus menentukan atribut abstrak dengan nilai true seperti yang ditunjukkan pada cuplikan kode berikut -

<?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>

Kacang induk tidak dapat dibuat instance-nya sendiri karena tidak lengkap, dan juga secara eksplisit ditandai sebagai abstrak . Ketika definisi bersifat abstrak seperti ini, itu hanya dapat digunakan sebagai definisi kacang templat murni yang berfungsi sebagai definisi induk untuk definisi anak.

Setiap aplikasi berbasis Java memiliki beberapa objek yang bekerja sama untuk menyajikan apa yang dilihat pengguna akhir sebagai aplikasi yang berfungsi. Saat menulis aplikasi Java yang kompleks, kelas aplikasi harus sebebas mungkin dari kelas Java lainnya untuk meningkatkan kemungkinan menggunakan kembali kelas-kelas ini dan mengujinya secara independen dari kelas lain saat pengujian unit. Dependency Injection (atau kadang disebut wiring) membantu dalam merekatkan kelas-kelas ini bersama-sama dan pada saat yang sama menjaganya tetap independen.

Pertimbangkan Anda memiliki aplikasi yang memiliki komponen editor teks dan Anda ingin memberikan pemeriksa ejaan. Kode standar Anda akan terlihat seperti ini -

public class TextEditor {
   private SpellChecker spellChecker;
   
   public TextEditor() {
      spellChecker = new SpellChecker();
   }
}

Apa yang kami lakukan di sini adalah, membuat ketergantungan antara TextEditor dan Pemeriksa Ejaan. Dalam skenario inversi kontrol, kami akan melakukan sesuatu seperti ini -

public class TextEditor {
   private SpellChecker spellChecker;
   
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }
}

Di sini, TextEditor tidak perlu mengkhawatirkan implementasi SpellChecker. Pemeriksa Ejaan akan diimplementasikan secara independen dan akan diberikan ke TextEditor pada saat Instansiasi TextEditor. Seluruh prosedur ini dikendalikan oleh Kerangka Pegas.

Di sini, kami telah menghapus kontrol total dari TextEditor dan menyimpannya di tempat lain (yaitu file konfigurasi XML) dan ketergantungan (yaitu kelas SpellChecker) dimasukkan ke dalam kelas TextEditor melalui Class Constructor. Jadi aliran kontrol telah "dibalik" oleh Dependency Injection (DI) karena Anda telah mendelegasikan ketergantungan secara efektif ke beberapa sistem eksternal.

Metode kedua untuk menyuntikkan ketergantungan adalah melalui Setter Methodsdari kelas TextEditor tempat kita akan membuat instance SpellChecker. Instance ini akan digunakan untuk memanggil metode penyetel untuk menginisialisasi properti TextEditor.

Dengan demikian, DI ada dalam dua varian utama dan dua sub-bab berikut akan membahas keduanya dengan contoh -

Sr.No. Jenis & Deskripsi Injeksi Ketergantungan
1 Injeksi ketergantungan berbasis konstruktor

DI berbasis konstruktor dicapai ketika wadah memanggil konstruktor kelas dengan sejumlah argumen, masing-masing mewakili ketergantungan pada kelas lain.

2 Injeksi ketergantungan berbasis penyetel

Setter-based DI dicapai dengan metode penyetel pemanggil kontainer pada kacang Anda setelah memanggil konstruktor tanpa argumen atau metode pabrik statis tanpa argumen untuk membuat contoh kacang Anda.

Anda dapat mencampur keduanya, DI berbasis Konstruktor dan Setter, tetapi merupakan aturan praktis yang baik untuk menggunakan argumen konstruktor untuk dependensi wajib dan setter untuk dependensi opsional.

Kode lebih bersih dengan prinsip DI dan decoupling lebih efektif ketika objek dilengkapi dengan dependensinya. Objek tidak mencari dependensinya dan tidak mengetahui lokasi atau kelas dependensinya, melainkan semuanya diurus oleh Spring Framework.

Seperti yang Anda ketahui, kelas dalam Java didefinisikan dalam cakupan kelas lain, demikian pula, inner beansadalah kacang yang didefinisikan dalam lingkup kacang lain. Jadi, elemen <bean /> di dalam elemen <property /> atau <constructor-arg /> disebut inner bean dan ditunjukkan di bawah ini.

<?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>

Contoh

Mari kita siapkan Eclipse IDE dan ikuti langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java TextEditor , SpellChecker dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari TextEditor.java file -

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();
   }
}

Berikut adalah konten file kelas dependen lainnya SpellChecker.java -

package com.tutorialspoint;

public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }
}

Berikut ini adalah konten dari MainApp.java file -

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();
   }
}

Berikut adalah file konfigurasinya Beans.xml yang memiliki konfigurasi untuk injeksi berbasis penyetel tetapi menggunakan 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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.

Anda telah melihat cara mengkonfigurasi tipe data primitif menggunakan value atribut dan referensi objek menggunakan refatribut dari tag <property> di file konfigurasi Bean Anda. Kedua kasus berhubungan dengan meneruskan nilai tunggal ke kacang.

Sekarang bagaimana jika Anda ingin meneruskan nilai jamak seperti jenis Koleksi Java seperti List, Set, Map, dan Properties. Untuk menangani situasi tersebut, Spring menawarkan empat jenis elemen konfigurasi kumpulan yaitu sebagai berikut -

Sr Tidak Elemen & Deskripsi
1

<list>

Ini membantu dalam pengkabelan yaitu memasukkan daftar nilai, memungkinkan duplikat.

2

<set>

Ini membantu dalam menghubungkan satu set nilai tetapi tanpa duplikat.

3

<map>

Ini dapat digunakan untuk memasukkan kumpulan pasangan nama-nilai di mana nama dan nilai dapat berupa jenis apa pun.

4

<props>

Ini dapat digunakan untuk memasukkan kumpulan pasangan nama-nilai di mana nama dan nilai keduanya adalah String.

Anda dapat menggunakan <list> atau <set> untuk mentransfer implementasi java.util.Collection atau file array.

Anda akan menemukan dua situasi (a) Meneruskan nilai langsung dari koleksi dan (b) Meneruskan referensi kacang sebagai salah satu elemen koleksi.

Contoh

Mari kita memiliki IDE Eclipse yang berfungsi dan mengambil langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java JavaCollection , dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari JavaCollection.java file -

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;
   }
}

Berikut ini adalah konten dari MainApp.java file -

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();
   }
}

Berikut adalah file konfigurasinya Beans.xml yang memiliki konfigurasi untuk semua jenis koleksi -

<?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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

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}

Referensi Injecting Bean

Definisi Bean berikut akan membantu Anda memahami cara memasukkan referensi kacang sebagai salah satu elemen koleksi. Bahkan Anda dapat menggabungkan semua referensi dan nilai seperti yang ditunjukkan dalam cuplikan kode berikut -

<?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>

Untuk menggunakan definisi kacang di atas, Anda perlu mendefinisikan metode penyetel sedemikian rupa sehingga metode tersebut juga dapat menangani referensi.

Menyuntikkan nilai string kosong dan nol

Jika Anda perlu meneruskan string kosong sebagai nilai, maka Anda dapat meneruskannya sebagai berikut -

<bean id = "..." class = "exampleBean">
   <property name = "email" value = ""/>
</bean>

Contoh sebelumnya sama dengan kode Java: exampleBean.setEmail ("")

Jika Anda perlu meneruskan nilai NULL, maka Anda dapat meneruskannya sebagai berikut -

<bean id = "..." class = "exampleBean">
   <property name = "email"><null/></property>
</bean>

Contoh sebelumnya sama dengan kode Java: exampleBean.setEmail (null)

Anda telah mempelajari cara mendeklarasikan bean menggunakan elemen <bean> dan memasukkan <bean> menggunakan elemen <constructor-arg> dan <property> dalam file konfigurasi XML.

Wadah pegas bisa autowire hubungan antara kacang berkolaborasi tanpa menggunakan elemen <constructor-arg> dan <property>, yang membantu mengurangi jumlah konfigurasi XML yang Anda tulis untuk aplikasi berbasis Spring yang besar.

Mode Autowiring

Berikut adalah mode autowiring, yang dapat digunakan untuk menginstruksikan container Spring agar menggunakan autowiring untuk injeksi dependensi. Anda menggunakan atribut autowire dari elemen <bean /> untuk menentukanautowire mode untuk definisi kacang.

Sr Tidak Mode & Deskripsi
1 no

Ini adalah pengaturan default yang berarti tidak ada autowiring dan Anda harus menggunakan referensi bean eksplisit untuk wiring. Anda tidak perlu melakukan apa-apa khusus untuk kabel ini. Inilah yang telah Anda lihat di bab Injeksi Ketergantungan.

2 dengan nama

Autowiring menurut nama properti. Penampung Spring melihat properti kacang tempat atribut autowire disetel ke byName dalam file konfigurasi XML. Ia kemudian mencoba untuk mencocokkan dan menyambungkan propertinya dengan kacang yang ditentukan oleh nama yang sama di file konfigurasi.

3 byType

Autowiring menurut tipe data properti. Penampung Spring melihat properti kacang tempat atribut autowire disetel ke byType dalam file konfigurasi XML. Kemudian mencoba untuk mencocokkan dan mentransfer properti jika itutypecocok dengan salah satu nama kacang di file konfigurasi. Jika ada lebih dari satu biji seperti itu, pengecualian fatal dilemparkan.

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);
}

Lifecycle Callbacks

Anotasi @Bean mendukung penentuan inisialisasi arbitrer dan metode callback pemusnahan, seperti atribut metode init dan metode perusakan Spring XML pada elemen kacang -

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();
   }
}

Menentukan Ruang Lingkup Kacang

Cakupan defaultnya adalah tunggal, tetapi Anda dapat menimpanya dengan anotasi @Scope sebagai berikut -

@Configuration
public class AppConfig {
   @Bean
   @Scope("prototype")
   public Foo foo() {
      return new Foo();
   }
}

Anda telah melihat di semua chapter bahwa inti dari Spring adalah ApplicationContext, yang mengatur siklus hidup biji secara lengkap. ApplicationContext menerbitkan jenis kejadian tertentu saat memuat kacang. Misalnya, ContextStartedEvent diterbitkan saat konteks dimulai dan ContextStoppedEvent diterbitkan saat konteks dihentikan.

Penanganan dalam acara ApplicationContext disediakan melalui ApplicationEvent kelas dan ApplicationListener antarmuka. Oleh karena itu, jika kacang mengimplementasikan ApplicationListener , maka setiap kali ApplicationEvent dipublikasikan ke ApplicationContext, kacang tersebut akan diberi tahu.

Musim semi menyediakan acara standar berikut -

Sr.No. Acara & Deskripsi Bawaan Musim Semi
1

ContextRefreshedEvent

Peristiwa ini diterbitkan ketika ApplicationContext diinisialisasi atau disegarkan. Ini juga bisa dimunculkan menggunakan metode refresh () pada antarmuka ConfigurableApplicationContext .

2

ContextStartedEvent

Peristiwa ini diterbitkan ketika ApplicationContext dimulai menggunakan metode start () pada antarmuka ConfigurableApplicationContext . Anda dapat meminta database Anda atau Anda dapat memulai ulang aplikasi apa pun yang terhenti setelah menerima acara ini.

3

ContextStoppedEvent

Peristiwa ini diterbitkan ketika ApplicationContext dihentikan menggunakan metode stop () pada antarmuka ConfigurableApplicationContext . Anda dapat melakukan pekerjaan rumah tangga yang diperlukan setelah menerima acara ini.

4

ContextClosedEvent

Peristiwa ini diterbitkan ketika ApplicationContext ditutup menggunakan metode close () pada antarmuka ConfigurableApplicationContext . Konteks tertutup mencapai akhir hidupnya; itu tidak dapat disegarkan atau dimulai ulang.

5

RequestHandledEvent

Ini adalah acara khusus web yang memberi tahu semua kacang bahwa permintaan HTTP telah dilayani.

Penanganan acara Spring bersifat single-threaded, jadi jika sebuah acara dipublikasikan, hingga dan kecuali semua penerima mendapatkan pesan, prosesnya diblokir dan aliran tidak akan dilanjutkan. Oleh karena itu, kehati-hatian harus diberikan saat mendesain aplikasi Anda jika penanganan acara akan digunakan.

Mendengarkan Kejadian Konteks

Untuk mendengarkan peristiwa konteks, kacang harus mengimplementasikan antarmuka ApplicationListener yang hanya memiliki satu metodeonApplicationEvent(). Jadi, mari kita tulis contoh untuk melihat bagaimana peristiwa menyebar dan bagaimana Anda dapat menempatkan kode Anda untuk melakukan tugas yang diperlukan berdasarkan peristiwa tertentu.

Mari kita memiliki IDE Eclipse yang berfungsi dan mengambil langkah-langkah berikut untuk membuat aplikasi Spring -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas Java HelloWorld , CStartEventHandler , CStopEventHandler dan MainApp di bawah paket com.tutorialspoint .
4 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
5 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari HelloWorld.java mengajukan

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);
   }
}

Berikut ini adalah konten dari CStartEventHandler.java mengajukan

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");
   }
}

Berikut ini adalah konten dari CStopEventHandler.java mengajukan

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");
   }
}

Berikut ini adalah konten dari MainApp.java mengajukan

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();
   }
}

Berikut adalah file konfigurasinya 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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent Received

Jika mau, Anda dapat memublikasikan acara khusus Anda sendiri dan nanti Anda dapat merekamnya untuk mengambil tindakan apa pun terhadap acara khusus tersebut. Jika Anda tertarik untuk membuat acara khusus Anda sendiri, Anda dapat memeriksa Acara Kustom di Musim Semi.

Ada beberapa langkah yang harus diambil untuk menulis dan menerbitkan acara khusus Anda sendiri. Ikuti instruksi yang diberikan dalam bab ini untuk menulis, menerbitkan, dan menangani Acara Musim Semi Kustom.

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrcfolder dalam proyek yang dibuat. Semua kelas akan dibuat di bawah paket ini.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Buat kelas acara, CustomEvent dengan memperluasApplicationEvent. Kelas ini harus mendefinisikan konstruktor default yang harus mewarisi konstruktor dari kelas ApplicationEvent.
4 Setelah kelas acara Anda ditentukan, Anda dapat menerbitkannya dari kelas mana pun, katakanlah EventClassPublisher yang mengimplementasikan ApplicationEventPublisherAware . Anda juga perlu mendeklarasikan kelas ini dalam file konfigurasi XML sebagai kacang sehingga wadah dapat mengidentifikasi kacang sebagai penerbit acara karena mengimplementasikan antarmuka ApplicationEventPublisherAware.
5 Peristiwa yang diterbitkan dapat ditangani dalam sebuah kelas, katakanlah EventClassHandler yang mengimplementasikan antarmuka ApplicationListener dan mengimplementasikan metode onApplicationEvent untuk peristiwa khusus.
6 Buat file konfigurasi kacang Beans.xml di bawahsrcfolder dan kelas MainApp yang akan berfungsi sebagai aplikasi Spring.
7 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari CustomEvent.java mengajukan

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";
   }
}

Berikut ini adalah konten dari CustomEventPublisher.java mengajukan

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);
   }
}

Berikut ini adalah konten dari CustomEventHandler.java mengajukan

package com.tutorialspoint;

import org.springframework.context.ApplicationListener;

public class CustomEventHandler implements ApplicationListener<CustomEvent> {
   public void onApplicationEvent(CustomEvent event) {
      System.out.println(event.toString());
   }
}

Berikut ini adalah konten dari MainApp.java mengajukan

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();
   }
}

Berikut adalah file konfigurasinya 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>

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, itu akan mencetak pesan berikut -

y Custom Event
y Custom Event

Salah satu komponen kunci dari Spring Framework adalah Aspect oriented programming (AOP)kerangka. Pemrograman Berorientasi Aspek memerlukan pemecahan logika program menjadi bagian-bagian berbeda yang disebut apa yang disebut masalah. Fungsi yang menjangkau banyak titik aplikasi disebutcross-cutting concernsdan masalah lintas bidang ini secara konseptual terpisah dari logika bisnis aplikasi. Ada berbagai contoh bagus dari aspek seperti logging, audit, transaksi deklaratif, keamanan, caching, dll.

Unit kunci dari modularitas di OOP adalah class, sedangkan di AOP unit modularity adalah aspeknya. Injeksi Ketergantungan membantu Anda memisahkan objek aplikasi dari satu sama lain dan AOP membantu Anda memisahkan masalah lintas sektor dari objek yang terpengaruh. AOP seperti pemicu dalam bahasa pemrograman seperti Perl, .NET, Java, dan lainnya.

Modul Spring AOP menyediakan interseptor untuk mencegat aplikasi. Misalnya, ketika sebuah metode dijalankan, Anda dapat menambahkan fungsionalitas tambahan sebelum atau setelah eksekusi metode.

Terminologi AOP

Sebelum kita mulai bekerja dengan AOP, marilah kita mengenal konsep dan terminologi AOP. Istilah ini tidak spesifik untuk Spring, melainkan terkait dengan AOP.

Sr Tidak Syarat & Deskripsi
1

Aspect

Ini adalah modul yang memiliki sekumpulan API yang menyediakan persyaratan lintas sektor. Misalnya, modul logging akan disebut aspek AOP untuk logging. Aplikasi dapat memiliki sejumlah aspek tergantung pada kebutuhan.

2

Join point

Ini mewakili titik dalam aplikasi Anda di mana Anda dapat memasukkan aspek AOP. Anda juga dapat mengatakan, ini adalah tempat sebenarnya dalam aplikasi tempat tindakan akan diambil menggunakan kerangka kerja Spring AOP.

3

Advice

Ini adalah tindakan aktual yang harus diambil sebelum atau sesudah eksekusi metode. Ini adalah bagian kode sebenarnya yang dipanggil selama eksekusi program oleh kerangka kerja Spring AOP.

4

Pointcut

Ini adalah satu set satu atau lebih titik penggabungan tempat saran harus dijalankan. Anda dapat menentukan titik potong menggunakan ekspresi atau pola seperti yang akan kita lihat di contoh AOP kami.

5

Introduction

Pengenalan memungkinkan Anda menambahkan metode atau atribut baru ke kelas yang ada.

6

Target object

Objek sedang dinasehati oleh satu atau lebih aspek. Objek ini akan selalu menjadi objek yang diproksikan, juga disebut sebagai objek yang disarankan.

7

Weaving

Weaving adalah proses menghubungkan aspek dengan objek atau tipe aplikasi lain untuk membuat objek yang disarankan. Ini dapat dilakukan pada waktu kompilasi, waktu muat, atau saat runtime.

Jenis Nasihat

Aspek musim semi dapat bekerja dengan lima jenis saran yang disebutkan sebagai berikut -

Sr Tidak Saran & Deskripsi
1

before

Jalankan saran sebelum eksekusi metode.

2

after

Jalankan saran setelah eksekusi metode, apa pun hasilnya.

3

after-returning

Jalankan saran setelah eksekusi metode hanya jika metode berhasil diselesaikan.

4

after-throwing

Jalankan saran setelah eksekusi metode hanya jika metode keluar dengan menampilkan pengecualian.

5

around

Jalankan saran sebelum dan setelah metode yang disarankan dipanggil.

Penerapan Aspek Kustom

Spring mendukung @AspectJ annotation style pendekatan dan schema-basedpendekatan untuk menerapkan aspek adat. Kedua pendekatan ini telah dijelaskan secara rinci pada bagian berikut.

Sr Tidak Pendekatan & Deskripsi
1 Berbasis XML Schema

Aspek diimplementasikan menggunakan kelas reguler bersama dengan konfigurasi berbasis XML.

2 Berbasis @Aspect

@AspectJ mengacu pada gaya mendeklarasikan aspek sebagai kelas Java reguler yang dianotasi dengan anotasi Java 5.

Saat bekerja dengan database menggunakan JDBC lama biasa, menjadi rumit untuk menulis kode yang tidak perlu untuk menangani pengecualian, membuka dan menutup koneksi database, dll. Namun, Spring JDBC Framework menangani semua detail tingkat rendah mulai dari membuka koneksi, mempersiapkan dan menjalankan pernyataan SQL, memproses pengecualian, menangani transaksi, dan akhirnya menutup koneksi.

Jadi yang harus Anda lakukan hanyalah menentukan parameter koneksi dan menentukan pernyataan SQL yang akan dieksekusi dan melakukan pekerjaan yang diperlukan untuk setiap iterasi sambil mengambil data dari database.

Spring JDBC menyediakan beberapa pendekatan dan kelas yang berbeda untuk berinteraksi dengan database. Saya akan mengambil pendekatan klasik dan paling populer yang memanfaatkanJdbcTemplatekelas kerangka. Ini adalah kelas kerangka kerja pusat yang mengelola semua komunikasi database dan penanganan pengecualian.

Kelas JdbcTemplate

Kelas Template JDBC mengeksekusi kueri SQL, memperbarui pernyataan, menyimpan panggilan prosedur, melakukan iterasi atas ResultSets, dan mengekstrak nilai parameter yang dikembalikan. Ini juga menangkap pengecualian JDBC dan menerjemahkannya ke hierarki pengecualian yang umum dan lebih informatif yang ditentukan dalam paket org.springframework.dao.

Contoh dari JdbcTemplate kelas yang benang- sekali dikonfigurasi. Jadi, Anda dapat mengonfigurasi satu contoh JdbcTemplate lalu memasukkan referensi bersama ini dengan aman ke beberapa DAO.

Praktik umum saat menggunakan kelas JDBC Template adalah untuk mengkonfigurasi DataSource dalam file konfigurasi Spring Anda, dan kemudian ketergantungan-inject yang berbagi DataSource kacang ke dalam kelas DAO Anda, dan JdbcTemplate dibuat dalam setter untuk DataSource.

Mengonfigurasi Sumber Data

Mari kita buat tabel database Student di database kami TEST. Kami berasumsi Anda bekerja dengan database MySQL, jika Anda bekerja dengan database lain, maka Anda dapat mengubah kueri DDL dan SQL Anda.

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

Sekarang kita perlu menyediakan Sumber Data ke JDBC Template sehingga dapat mengkonfigurasi dirinya sendiri untuk mendapatkan akses database. Anda dapat mengonfigurasi Sumber Data dalam file XML dengan potongan kode seperti yang ditunjukkan dalam cuplikan kode berikut -

<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>

Objek Akses Data (DAO)

DAO adalah singkatan dari Data Access Object, yang biasanya digunakan untuk interaksi database. DAO ada untuk menyediakan sarana untuk membaca dan menulis data ke database dan mereka harus mengekspos fungsionalitas ini melalui antarmuka yang dengannya aplikasi lainnya akan mengaksesnya.

Dukungan DAO di Spring memudahkan untuk bekerja dengan teknologi akses data seperti JDBC, Hibernate, JPA, atau JDO dengan cara yang konsisten.

Menjalankan pernyataan SQL

Mari kita lihat bagaimana kita dapat melakukan operasi CRUD (Buat, Baca, Perbarui dan Hapus) pada tabel database menggunakan objek Template SQL dan JDBC.

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} );

Menjalankan Pernyataan DDL

Anda bisa menggunakan execute(..)metode dari jdbcTemplate untuk menjalankan pernyataan SQL atau pernyataan DDL. Berikut adalah contoh penggunaan pernyataan CREATE untuk membuat tabel -

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 );

Contoh Kerangka JDBC Musim Semi

Berdasarkan konsep di atas, mari kita periksa beberapa contoh penting yang akan membantu Anda memahami penggunaan framework JDBC di Spring -

Sr.No. Contoh & Deskripsi
1 Contoh Musim Semi JDBC

Contoh ini akan menjelaskan cara menulis aplikasi Spring berbasis JDBC sederhana.

2 Prosedur Tersimpan SQL di Musim Semi

Pelajari cara memanggil prosedur tersimpan SQL saat menggunakan JDBC di Spring.

Transaksi database adalah urutan tindakan yang diperlakukan sebagai satu unit kerja. Tindakan ini harus selesai seluruhnya atau tidak berpengaruh sama sekali. Manajemen transaksi adalah bagian penting dari aplikasi perusahaan yang berorientasi RDBMS untuk memastikan integritas dan konsistensi data. Konsep transaksi dapat dijelaskan dengan empat properti utama berikut iniACID -

  • Atomicity - Transaksi harus diperlakukan sebagai satu unit operasi, yang berarti seluruh urutan operasi berhasil atau tidak berhasil.

  • Consistency - Ini mewakili konsistensi integritas referensial dari database, kunci utama unik dalam tabel, dll.

  • Isolation- Mungkin ada banyak pemrosesan transaksi dengan kumpulan data yang sama pada waktu yang sama. Setiap transaksi harus diisolasi dari yang lain untuk mencegah korupsi data.

  • Durability - Setelah transaksi selesai, hasil transaksi ini harus dibuat permanen dan tidak dapat dihapus dari database karena kegagalan sistem.

Sistem database RDBMS yang nyata akan menjamin keempat properti untuk setiap transaksi. Tampilan sederhana dari transaksi yang dikeluarkan ke database menggunakan SQL adalah sebagai berikut -

  • Mulailah transaksi menggunakan perintah mulai transaksi .

  • Lakukan berbagai operasi yang dihapus, perbarui, atau sisipkan menggunakan kueri SQL.

  • Jika semua operasi berhasil maka lakukan komit jika tidak, kembalikan semua operasi.

Framework Spring menyediakan lapisan abstrak di atas berbagai API manajemen transaksi yang mendasarinya. Dukungan transaksi Spring bertujuan untuk memberikan alternatif untuk transaksi EJB dengan menambahkan kemampuan transaksi ke POJO. Spring mendukung manajemen transaksi terprogram dan deklaratif. EJB membutuhkan server aplikasi, tetapi manajemen transaksi Spring dapat diimplementasikan tanpa memerlukan server aplikasi.

Transaksi Lokal vs. Global

Transaksi lokal dikhususkan untuk satu sumber daya transaksional seperti koneksi JDBC, sedangkan transaksi global dapat menjangkau beberapa sumber daya transaksional seperti transaksi dalam sistem terdistribusi.

Manajemen transaksi lokal dapat berguna dalam lingkungan komputasi terpusat di mana komponen dan sumber daya aplikasi berada di satu situs, dan manajemen transaksi hanya melibatkan pengelola data lokal yang berjalan pada satu mesin. Transaksi lokal lebih mudah diimplementasikan.

Manajemen transaksi global diperlukan dalam lingkungan komputasi terdistribusi di mana semua sumber daya didistribusikan ke berbagai sistem. Dalam kasus seperti itu, manajemen transaksi perlu dilakukan baik di tingkat lokal maupun global. Transaksi terdistribusi atau global dijalankan di beberapa sistem, dan pelaksanaannya memerlukan koordinasi antara sistem manajemen transaksi global dan semua pengelola data lokal dari semua sistem yang terlibat.

Terprogram vs. Deklaratif

Spring mendukung dua jenis manajemen transaksi -

  • Manajemen transaksi terprogram - Ini berarti Anda harus mengelola transaksi dengan bantuan pemrograman. Itu memberi Anda fleksibilitas ekstrim, tetapi sulit untuk dipelihara.

  • Manajemen transaksi deklaratif - Ini berarti Anda memisahkan manajemen transaksi dari kode bisnis. Anda hanya menggunakan anotasi atau konfigurasi berbasis XML untuk mengelola transaksi.

Pengelolaan transaksi deklaratif lebih disukai daripada pengelolaan transaksi terprogram meskipun kurang fleksibel dibandingkan pengelolaan transaksi terprogram, yang memungkinkan Anda mengontrol transaksi melalui kode Anda. Tetapi sebagai semacam masalah lintas sektor, manajemen transaksi deklaratif dapat dimodulasi dengan pendekatan AOP. Spring mendukung manajemen transaksi deklaratif melalui kerangka Spring AOP.

Abstraksi Transaksi Musim Semi

Kunci abstraksi transaksi Spring ditentukan oleh antarmuka org.springframework.transaction.PlatformTransactionManager , yaitu sebagai berikut -

public interface PlatformTransactionManager {
   TransactionStatus getTransaction(TransactionDefinition definition);
   throws TransactionException;
   
   void commit(TransactionStatus status) throws TransactionException;
   void rollback(TransactionStatus status) throws TransactionException;
}

Sr Tidak Metode & Deskripsi
1

TransactionStatus getTransaction(TransactionDefinition definition)

Metode ini mengembalikan transaksi yang sedang aktif atau membuat yang baru, sesuai dengan perilaku propagasi yang ditentukan.

2

void commit(TransactionStatus status)

Metode ini melakukan transaksi yang diberikan, sehubungan dengan statusnya.

3

void rollback(TransactionStatus status)

Metode ini melakukan rollback dari transaksi yang diberikan.

The TransactionDefinition adalah antarmuka inti dari dukungan transaksi di musim semi dan itu didefinisikan sebagai berikut -

public interface TransactionDefinition {
   int getPropagationBehavior();
   int getIsolationLevel();
   String getName();
   int getTimeout();
   boolean isReadOnly();
}

Sr Tidak Metode & Deskripsi
1

int getPropagationBehavior()

Metode ini mengembalikan perilaku propagasi. Spring menawarkan semua opsi propagasi transaksi yang familiar dari EJB CMT.

2

int getIsolationLevel()

Metode ini mengembalikan sejauh mana transaksi ini diisolasi dari pekerjaan transaksi lainnya.

3

String getName()

Metode ini mengembalikan nama transaksi ini.

4

int getTimeout()

Metode ini mengembalikan waktu dalam detik saat transaksi harus diselesaikan.

5

boolean isReadOnly()

Metode ini mengembalikan apakah transaksi hanya-baca.

Berikut ini adalah nilai yang mungkin untuk tingkat isolasi -

Sr Tidak Isolasi & Deskripsi
1

TransactionDefinition.ISOLATION_DEFAULT

Ini adalah tingkat isolasi default.

2

TransactionDefinition.ISOLATION_READ_COMMITTED

Menunjukkan bahwa pembacaan kotor dicegah; pembacaan yang tidak berulang dan pembacaan bayangan dapat terjadi.

3

TransactionDefinition.ISOLATION_READ_UNCOMMITTED

Menunjukkan bahwa pembacaan kotor, pembacaan yang tidak dapat diulangi, dan pembacaan bayangan dapat terjadi.

4

TransactionDefinition.ISOLATION_REPEATABLE_READ

Menunjukkan bahwa pembacaan kotor dan pembacaan yang tidak berulang dapat dicegah; pembacaan hantu dapat terjadi.

5

TransactionDefinition.ISOLATION_SERIALIZABLE

Menunjukkan bahwa pembacaan kotor, pembacaan tidak berulang, dan pembacaan bayangan dicegah.

Berikut adalah nilai yang mungkin untuk jenis propagasi -

Sr.No. Propagasi & Deskripsi
1

TransactionDefinition.PROPAGATION_MANDATORY

Mendukung transaksi saat ini; melempar pengecualian jika tidak ada transaksi saat ini.

2

TransactionDefinition.PROPAGATION_NESTED

Eksekusi dalam transaksi bersarang jika ada transaksi saat ini.

3

TransactionDefinition.PROPAGATION_NEVER

Tidak mendukung transaksi saat ini; melempar pengecualian jika ada transaksi saat ini.

4

TransactionDefinition.PROPAGATION_NOT_SUPPORTED

Tidak mendukung transaksi saat ini; lebih baik selalu mengeksekusi secara nontransaksional.

5

TransactionDefinition.PROPAGATION_REQUIRED

Mendukung transaksi saat ini; membuat yang baru jika tidak ada.

6

TransactionDefinition.PROPAGATION_REQUIRES_NEW

Membuat transaksi baru, menangguhkan transaksi saat ini jika ada.

7

TransactionDefinition.PROPAGATION_SUPPORTS

Mendukung transaksi saat ini; dieksekusi secara non-transaksional jika tidak ada.

8

TransactionDefinition.TIMEOUT_DEFAULT

Menggunakan batas waktu default dari sistem transaksi yang mendasarinya, atau tidak ada jika batas waktu tidak didukung.

The TransactionStatus antarmuka memberikan cara mudah untuk kode transaksional untuk eksekusi transaksi kontrol dan status transaksi query.

public interface TransactionStatus extends SavepointManager {
   boolean isNewTransaction();
   boolean hasSavepoint();
   void setRollbackOnly();
   boolean isRollbackOnly();
   boolean isCompleted();
}

Sr.No. Metode & Deskripsi
1

boolean hasSavepoint()

Metode ini mengembalikan apakah transaksi ini secara internal membawa savepoint, yaitu, telah dibuat sebagai transaksi bersarang berdasarkan savepoint.

2

boolean isCompleted()

Metode ini mengembalikan apakah transaksi ini selesai, yaitu apakah sudah dilakukan atau dibatalkan.

3

boolean isNewTransaction()

Metode ini mengembalikan nilai true jika transaksi saat ini baru.

4

boolean isRollbackOnly()

Metode ini mengembalikan apakah transaksi telah ditandai sebagai rollback-only.

5

void setRollbackOnly()

Metode ini menetapkan transaksi sebagai hanya rollback.

Framework Spring Web MVC menyediakan arsitektur Model-View-Controller (MVC) dan komponen siap pakai yang dapat digunakan untuk mengembangkan aplikasi web yang fleksibel dan digabungkan secara longgar. Hasil pola MVC memisahkan berbagai aspek aplikasi (logika input, logika bisnis, dan logika UI), sekaligus menyediakan kopling longgar antara elemen-elemen ini.

  • Itu Model merangkum data aplikasi dan secara umum terdiri dari POJO.

  • Itu View bertanggung jawab untuk menampilkan data model dan secara umum menghasilkan keluaran HTML yang dapat diinterpretasikan oleh browser klien.

  • Itu Controller bertanggung jawab untuk memproses permintaan pengguna dan membangun model yang sesuai dan meneruskannya ke tampilan untuk rendering.

DispatcherServlet

Framework model-view-controller (MVC) Spring Web dirancang dengan DispatcherServlet yang menangani semua permintaan dan respons HTTP. Alur kerja pemrosesan permintaan dari Spring Web MVC DispatcherServlet diilustrasikan dalam diagram berikut -

Berikut adalah urutan kejadian yang sesuai dengan permintaan HTTP yang masuk ke DispatcherServlet -

  • Setelah menerima permintaan HTTP, DispatcherServlet berkonsultasi dengan HandlerMapping untuk memanggil Controller yang sesuai .

  • The Pengendali mengambil permintaan dan panggilan metode layanan yang sesuai berdasarkan GET digunakan atau metode POST. Metode layanan akan menyetel data model berdasarkan logika bisnis yang ditentukan dan mengembalikan nama tampilan ke DispatcherServlet .

  • The DispatcherServlet akan mengambil bantuan dari ViewResolver untuk pickup didefinisikan tampilan untuk permintaan.

  • Setelah tampilan diselesaikan, DispatcherServlet meneruskan data model ke tampilan yang akhirnya dirender di browser.

Semua komponen yang disebutkan di atas, yaitu HandlerMapping, Controller, dan ViewResolver adalah bagian dari WebApplicationContext w yang merupakan perpanjangan dari ApplicationContext biasa dengan beberapa fitur tambahan yang diperlukan untuk aplikasi web.

Konfigurasi yang Diperlukan

Anda perlu memetakan permintaan yang Anda inginkan agar ditangani DispatcherServlet , dengan menggunakan pemetaan URL di fileweb.xmlmengajukan. Berikut ini adalah contoh deklarasi dan pemetaanHelloWeb Contoh DispatcherServlet -

<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>

Itu web.xmlfile akan disimpan di direktori WebContent / WEB-INF aplikasi web Anda. Setelah inisialisasiHelloWeb DispatcherServlet, kerangka kerja akan mencoba memuat konteks aplikasi dari file bernama [servlet-name]-servlet.xmlterletak di webContent / WEB-INFdirectory aplikasi. Dalam hal ini, file kami adalahHelloWebservlet.xml.

Selanjutnya, tag <servlet-mapping> menunjukkan URL apa yang akan ditangani oleh DispatcherServlet. Di sini semua permintaan HTTP diakhiri dengan.jsp akan ditangani oleh HelloWeb DispatcherServlet.

Jika Anda tidak ingin menggunakan nama file default sebagai [servlet-name] -servlet.xml dan lokasi default sebagai WebContent / WEB-INF , Anda dapat menyesuaikan nama dan lokasi file ini dengan menambahkan pendengar servlet ContextLoaderListener di file web.xml Anda sebagai berikut -

<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>

Sekarang, mari kita periksa konfigurasi yang diperlukan untuk HelloWeb-servlet.xmlfile, ditempatkan di direktori WebContent / WEB-INF aplikasi web Anda -

<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>

Berikut adalah poin-poin penting tentang HelloWeb-servlet.xml file -

  • File [servlet-name] -servlet.xml akan digunakan untuk membuat kacang yang didefinisikan, menimpa definisi kacang apa pun yang didefinisikan dengan nama yang sama dalam lingkup global.

  • The <konteks: komponen-scan ...> tag akan digunakan untuk mengaktifkan Spring MVC penjelasan scanning kemampuan yang memungkinkan untuk menggunakan penjelasan seperti @Controller dan @RequestMapping dll

  • The InternalResourceViewResolver akan memiliki aturan yang ditetapkan untuk menyelesaikan nama tampilan. Sesuai aturan yang ditentukan di atas, tampilan logis bernamahellodidelegasikan ke implementasi tampilan yang terletak di /WEB-INF/jsp/hello.jsp .

Bagian berikut akan menunjukkan cara membuat komponen Anda yang sebenarnya, yaitu Controller, Model, dan View.

Mendefinisikan Kontroler

DispatcherServlet mendelegasikan permintaan ke pengontrol untuk menjalankan fungsionalitas khusus untuk itu. Itu@Controlleranotasi menunjukkan bahwa kelas tertentu berfungsi sebagai pengontrol. Itu@RequestMapping anotasi digunakan untuk memetakan URL ke seluruh kelas atau metode penanganan tertentu.

@Controller
@RequestMapping("/hello")
public class HelloController { 
   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Itu @Controlleranotasi mendefinisikan kelas sebagai pengontrol MVC Spring. Di sini, penggunaan pertama@RequestMapping menunjukkan bahwa semua metode penanganan pada pengontrol ini relatif terhadap /hellojalan. Anotasi berikutnya@RequestMapping(method = RequestMethod.GET)digunakan untuk mendeklarasikan metode printHello () sebagai metode layanan default pengontrol untuk menangani permintaan HTTP GET. Anda dapat menentukan metode lain untuk menangani permintaan POST apa pun di URL yang sama.

Anda dapat menulis pengontrol di atas dalam bentuk lain di mana Anda dapat menambahkan atribut tambahan di @RequestMapping sebagai berikut -

@Controller
public class HelloController {
   @RequestMapping(value = "/hello", method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Itu value atribut menunjukkan URL tempat metode penangan dipetakan dan methodatribut mendefinisikan metode layanan untuk menangani permintaan HTTP GET. Poin penting berikut harus diperhatikan tentang pengontrol yang ditentukan di atas -

  • Anda akan menentukan logika bisnis yang diperlukan di dalam metode layanan. Anda dapat memanggil metode lain di dalam metode ini sesuai kebutuhan.

  • Berdasarkan logika bisnis yang ditentukan, Anda akan membuat model dalam metode ini. Anda dapat menggunakan penyetel atribut model yang berbeda dan atribut ini akan diakses oleh tampilan untuk menyajikan hasil akhir. Contoh ini membuat model dengan atribut "message" -nya.

  • Metode layanan yang ditentukan dapat mengembalikan String, yang berisi nama file viewuntuk digunakan untuk merender model. Contoh ini mengembalikan "halo" sebagai nama tampilan logis.

Membuat Tampilan JSP

Spring MVC mendukung banyak jenis tampilan untuk teknologi presentasi yang berbeda. Ini termasuk - JSP, HTML, PDF, lembar kerja Excel, XML, template Velocity, XSLT, JSON, Atom dan RSS feeds, JasperReports, dll. Tetapi yang paling umum kami menggunakan template JSP yang ditulis dengan JSTL.

Mari kita tulis sederhana hello lihat di /WEB-INF/hello/hello.jsp -

<html>
   <head>
      <title>Hello Spring MVC</title>
   </head>
   
   <body>
      <h2>${message}</h2>
   </body>
</html>

Sini ${message}adalah atribut yang telah kita siapkan di dalam Controller. Anda dapat memiliki beberapa atribut untuk ditampilkan di dalam tampilan Anda.

Contoh Kerangka MVC Spring Web

Berdasarkan konsep di atas, mari kita periksa beberapa contoh penting yang akan membantu Anda dalam membangun Aplikasi Web Musim Semi -

Sr.No. Contoh & Deskripsi
1 Contoh MVC Musim Semi Hello World

Contoh ini akan menjelaskan cara menulis aplikasi Spring Web Hello World sederhana.

2 Contoh Penanganan Formulir Spring MVC

Contoh ini akan menjelaskan cara menulis aplikasi Spring Web menggunakan formulir HTML untuk mengirimkan data ke pengontrol dan menampilkan hasil yang diproses.

3 Contoh Pengalihan Halaman Musim Semi

Pelajari cara menggunakan fungsionalitas pengalihan halaman di Spring MVC Framework.

4 Contoh Spring Static Pages

Pelajari cara mengakses halaman statis bersama dengan halaman dinamis di Spring MVC Framework.

5 Contoh Penanganan Pengecualian Musim Semi

Pelajari cara menangani pengecualian di Spring MVC Framework.

Ini adalah fungsionalitas Log4J yang sangat mudah digunakan di dalam aplikasi Spring. Contoh berikut akan memandu Anda melalui langkah-langkah sederhana untuk menjelaskan integrasi sederhana antara Log4J dan Spring.

Kami menganggap Anda sudah memilikinya log4Jdipasang di mesin Anda. Jika Anda tidak memilikinya maka Anda dapat mengunduhnya darihttps://logging.apache.org/dan cukup ekstrak file zip tersebut di folder mana saja. Kami hanya akan menggunakanlog4j-x.y.z.jar dalam proyek kami.

Selanjutnya, mari kita memiliki IDE Eclipse yang berfungsi dan mengambil langkah-langkah berikut untuk mengembangkan Aplikasi Web berbasis Formulir Dinamis menggunakan Spring Web Framework -

Langkah Deskripsi
1 Buat proyek dengan nama SpringExample dan buat paket com.tutorialspoint di bawahsrc folder dalam proyek yang dibuat.
2 Tambahkan pustaka Spring yang diperlukan menggunakan opsi Add External JARs seperti yang dijelaskan di bab Contoh Spring Hello World .
3 Tambahkan juga perpustakaan log4j log4j-xyzjar di proyek Anda menggunakan Tambahkan JAR Eksternal .
4 Buat kelas Java HelloWorld dan MainApp di bawah paket com.tutorialspoint .
5 Buat file konfigurasi Beans Beans.xml di bawahsrc map.
6 Buat file konfigurasi log4J log4j.properties di bawahsrc map.
7 Langkah terakhir adalah membuat konten dari semua file Java dan file Konfigurasi Bean dan menjalankan aplikasi seperti yang dijelaskan di bawah ini.

Berikut adalah konten dari HelloWorld.java mengajukan

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);
   }
}

Berikut adalah isi dari file kedua 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");
   }
}

Anda bisa menghasilkan debug dan errorpesan dengan cara yang sama seperti yang kita buat pesan info. Sekarang mari kita lihat isinyaBeans.xml mengajukan

<?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>

Berikut ini adalah konten dari log4j.properties yang mendefinisikan aturan standar yang diperlukan untuk Log4J untuk menghasilkan pesan log

# 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%n

Setelah Anda selesai membuat file konfigurasi source dan bean, mari kita jalankan aplikasi. Jika semuanya baik-baik saja dengan aplikasi Anda, ini akan mencetak pesan berikut di konsol Eclipse -

Your Message : Hello World!

Jika Anda memeriksa drive C: \\, Anda akan menemukan file log Anda log.out dengan berbagai pesan log, seperti sebagai berikut -

<!-- initialization log messages -->

Going to create HelloWord Obj
Returning cached instance of singleton bean 'helloWorld'
Exiting the program

API Jakarta Commons Logging (JCL)

Atau Anda bisa menggunakan Jakarta Commons Logging (JCL)API untuk menghasilkan log di aplikasi Spring Anda. JCL dapat diunduh darihttps://jakarta.apache.org/commons/logging/. Satu-satunya file yang secara teknis kami butuhkan dari paket ini adalah file commons-logging-xyzjar , yang perlu ditempatkan di classpath Anda dengan cara yang sama seperti yang Anda lakukan pada log4j-xyzjar pada contoh di atas.

Untuk menggunakan fungsionalitas pencatatan Anda memerlukan objek org.apache.commons.logging.Log dan kemudian Anda dapat memanggil salah satu dari metode berikut sesuai kebutuhan Anda -

  • fatal (Objek pesan)
  • kesalahan (Objek pesan)
  • memperingatkan (Objek pesan)
  • info (Objek pesan)
  • debug (Objek pesan)
  • jejak (Objek pesan)

Berikut ini adalah penggantian MainApp.java yang memanfaatkan JCL API

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");
   }
}

Anda harus memastikan bahwa Anda telah menyertakan file commons-logging-xyzjar dalam proyek Anda, sebelum menyusun dan menjalankan program.

Sekarang dengan menjaga konfigurasi dan konten lainnya tidak berubah pada contoh di atas, jika Anda mengkompilasi dan menjalankan aplikasi Anda, Anda akan mendapatkan hasil yang sama seperti yang Anda dapatkan menggunakan Log4J API.