Saya menyambut Anda, Habr!
Artikel ini akan bermanfaat bagi mereka yang sudah mulai belajar Java dan bahkan berhasil mencapai beberapa keberhasilan dalam memahami Java Core, dan sekarang saya mendengar kata Spring. Dan, mungkin, lebih dari sekali: pengetahuan tentang Kerangka Kerja Musim Semi, setidaknya, muncul dalam deskripsi banyak lowongan untuk para ahli jav. Artikel ini akan membantu Anda mendaki langkah pertama: untuk memahami ide umum kerangka kerja yang populer.
Mari kita mulai dari jauh. Ada yang namanya Inversion of Control, dalam bahasa Rusia - Inversion of control, dalam bentuk disingkat - IoC. IoC adalah salah satu prinsip yang membawa kode kita lebih dekat dengan kelonggaran. IoC adalah pelimpahan bagian dari tanggung jawab kami ke komponen eksternal.
Ada implementasi yang berbeda dari pendekatan IoC, kami tertarik pada salah satunya - Dependency Injection, dependency injection. Apa ini, namanya berbicara untuk dirinya sendiri, jadi saya akan mencoba mengungkapkannya menggunakan contoh. Kami sedang menulis aplikasi yang mengotomatiskan operasi rantai toko. Ada kelas Shop (toko) dan Seller (penjual). Penjual kelas memiliki bidang jenis Toko - toko di mana penjual bekerja. Jadi kita dihadapkan dengan kecanduan: Penjual bergantung pada Toko. Sekarang mari kita pikirkan tentang bagaimana objek Toko masuk ke objek Penjual? Ada beberapa pilihan:
- Menerapkannya melalui desainer dan segera, saat membuat penjual, tentukan toko tempat dia bekerja:
public class Seller { private Shop shop; public Seller(Shop shop) { this.shop = shop; } }
- Buat setter dan, menggunakan panggilannya, atur toko untuk penjual:
public class Seller { private Shop shop; public void setShop(Shop shop) { this.shop = shop; } }
Dua metode yang tercantum adalah penerapan Injeksi Ketergantungan. Dan akhirnya, kami sampai ke pegas: itu menyediakan cara lain untuk menyuntikkan dependensi.
Secara umum, Spring adalah perpustakaan yang sangat luas untuk banyak kesempatan. Ada Spring MVC untuk membuat aplikasi web dengan cepat, dan Spring Security untuk mengimplementasikan otorisasi dalam aplikasi, dan Spring Data untuk bekerja dengan database dan banyak lagi. Tetapi Spring IoC berdiri sendiri - ini adalah tipe dasar dari pegas yang mengimplementasikan topik yang sedang kita pelajari - injeksi ketergantungan. Spring IoC patut mendapat perhatian di awal studi perpustakaan musim semi karena alasan lain. Seperti yang akan Anda lihat dalam proses kerja praktek dengan jenis pegas lain, untuk semua pegas lainnya, Pegas IoC digunakan sebagai kerangka kerja.
Kami akan memulai pengantar kami ke Spring IoC dengan istilah utama: bean. Dalam kata yang paling sederhana
Kacang adalah objek kelas yang dibuat oleh Spring yang dapat disematkan sebagai nilai bidang ke objek lain.
Apakah Anda ingin kata-kata yang lebih rumit? Dan tolong:
Kacang adalah objek kelas, yang merupakan elemen program lengkap dengan fungsi bisnis tertentu atau fungsi pegas internal, yang siklus hidupnya dikendalikan oleh wadah bin.
Seperti yang sudah Anda pahami, agar Shop dapat mengimplementasikan Shop, Shop harus menjadi tempat sampah. Ada beberapa cara untuk memberi tahu aplikasi objek mana yang memiliki hak bangga untuk disebut kacang, yang semuanya membawa kita pada konsep ApplicationContext.
ApplicationContext adalah jantung musim semi. Sebagai aturan, itu dibuat pada awal aplikasi ("naik") dan mengendalikan siklus hidup kacang. Oleh karena itu, ini juga disebut wadah sampah.
Kita sampai pada hal utama. Bagaimana kita perlu menulis ulang kelas kita sehingga Spring IoC dan pelayan ApplicationContextnya menggantikan bidang Toko untuk objek Penjual? Seperti ini:
@Component public class Shop { }
@Component public class Seller { @Autowired private Shop shop; }
Apakah ini sederhana? Jauh lebih mudah! Elegan? Cukup. Berikut ini terjadi: anotasi Komponen mengatakan kepada Spring bahwa kelas yang dianotasinya adalah bin. Anotasi Autowired meminta Spring untuk mengganti nilai di bidang yang dianotasinya. Operasi ini disebut inject. Nilai pasti apa yang akan diganti? Kita akan membicarakan hal ini nanti, pertama, kita akan mencari tahu bagaimana kelas menjadi kacang pada umumnya.
Kita sudah tahu bahwa di awal aplikasi, wali dari semua kacang ApplicationContext harus naik. Dia menciptakan semua tempat sampah sekaligus. Hampir semuanya. Faktanya adalah bahwa secara default, setiap kacang memiliki ruang lingkup properti intraspring dalam nilai tunggal. Intraspringovoe, karena dalam arti harfiah kata itu bukan singleton. Ini adalah singleton untuk pegas: ketika konteks dimunculkan, Spring akan membuat tepat satu objek bin dari kelas yang ditentukan. Jika Anda ingin mengubah perilaku ini - tolong, Spring memungkinkan Anda untuk mengontrol waktu pembuatan kacang dan nomor mereka untuk satu kelas, tetapi sekarang bukan tentang itu.
Jadi, saat menaikkan ApplicationContext semua nampan dibuat. Mari kita cari tahu di mana konteksnya tinggal dan yang paling penting: bagaimana ia menentukan kelas tempat membuat sampah. Ada beberapa opsi, untuk kesederhanaan, kita akan berbicara tentang salah satunya: konfigurasi menggunakan file xml. Berikut ini contohnya:
<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" xmlns:beans="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <bean id="product" class="main.java.Product"></bean> <context:component-scan base-package="main"/> </beans>
File ini menunjukkan cara membuat kacang dengan dua cara. Yang pertama, katakanlah, adalah manual. Anda lihat, ada tag
kacang dengan indikasi kelas. Ini buncisnya. Dari semua yang terdaftar dalam file ini dengan tag
kacang ,
kacang akan dibuat.
Cara kedua kurang verbose. Ingat, selama kelas kita menempatkan anotasi Komponen. Dari semua kelas yang diberi penjelasan dengan penjelasan ini, kacang akan dibuat. Berkat baris ini dari file xml:
<context:component-scan base-package="main"/>
Dia memberi tahu pegas: pindai seluruh paket utama dan dari semua yang ada, anotasi Komponen (atau anotasi lain yang merupakan komponen dari Komponen) akan berdiri, buat nampan. Ringkas, bukan? Kami hanya mengatakan paket mana yang berisi kelas-kelas dari mana membuat kacang, dan membubuhi keterangan kelas-kelas ini.
Anda dapat meningkatkan konteks menggunakan file xml dengan baris kode berikut:
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
di mana beans.xml adalah jalur ke nama panggilan xml yang dibahas di atas.
Dengan penciptaan kacang tahu. Bagaimana Spring mengisi bidang Toko saat membuat Penjual? Saat memunculkan konteks, objek nampan dari kelas Toko dibuat. Objek bin dari kelas Penjual juga dibuat, itu juga dijelaskan oleh Komponen. Ini memiliki jenis Toko yang dianotasi oleh Autowired. Anotasi otomatis memberi tahu pegas: Anda perlu menyuntikkan bin ke bidang ini. Dalam kasus kami, kami hanya memiliki satu nampan yang cocok untuk peran ini, yaitu, jenis yang cocok dengan jenis bidang: ini adalah nampan - turunan dari kelas Toko. Ini akan disuntikkan ke objek Penjual, sesuai kebutuhan. Saya mengerti bahwa sekarang pertanyaannya telah naik seperti cacing: apa yang akan terjadi jika Spring tidak menemukan kacang yang diinginkan, atau menemukan beberapa yang cocok (terutama mengingat Anda juga dapat menyuntikkan melalui antarmuka, dan bukan berdasarkan kelas). Musim semi itu pintar, tapi itu membutuhkan hal yang sama dari kita. Kami harus memiliki satu kacang tepat di sistem yang sesuai untuk masing-masing yang Autowired, atau untuk melatih Spring untuk bertindak dalam konflik semacam itu (kami tidak akan membicarakan hal ini sekarang, Anda sudah lelah, kencangkan, artikelnya akan segera berakhir).
Perhatikan bahwa Penjual juga merupakan tempat sampah. Jika itu bukan tempat sampah, tetapi dibuat melalui yang baru, maka tidak ada yang secara otomatis akan memasukkannya ke dalamnya.
Mungkin sekarang Anda berpikir mengapa semua kesulitan ini diperlukan. Tapi bayangkan aplikasi kita bukan dari 2 kelas, tetapi beberapa urutan besarnya lebih besar dan manajemen ketergantungan bukan lagi tugas yang paling sepele.
Mungkin sekarang Anda berpikir betapa Musim Semi yang indah, sederhana dan ringkas memungkinkan Anda untuk menerapkan dependensi. Tapi bayangkan ada sesuatu yang salah dan Anda perlu men-debug aplikasi. Dan itu tidak mudah lagi ...
Akhirnya, beberapa petunjuk:
- Jika Anda telah mengimplementasikan proyek dan sekarang bingung bagaimana cara mendapatkan bin dari pegas untuk melihatnya, lakukan ini:
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Seller seller = (Seller) context.getBean(Seller.class);
Ini adalah cara legal untuk mendapatkan tempat sampah, meskipun dalam kenyataan modern ini biasanya tidak dilakukan. Tapi untuk studi kasus kamu bisa.
- Karena Spring adalah kerangka kerja, Anda perlu memasukkannya ke dalam proyek Anda. Saya membuat aplikasi menggunakan maven dan menambahkan spring-core dan dependensi konteks-musim semi ke file pom.xml.
Spring IoC berisi peluang luar biasa untuk membuat, mengonfigurasi, dan menyuntikkan kacang. Kami memeriksa sebagian kecil dari ujung gunung es, salah satu cara untuk bekerja dengan pegas, tetapi saya berharap kami dapat melihatnya dengan tajam dan mendapatkan gambaran umum tentang apa yang terjadi.