Dasar musim semi untuk orang malas, konsep dasar, dan contoh dengan kode. Bagian 2

Pada artikel sebelumnya , saya menjelaskan secara singkat apa itu Spring dan apa itu kacang dan konteksnya. Sekarang saatnya untuk mencobanya. Saya akan melakukannya menggunakan IntelliJ IDEA Enterprise Edition. Tetapi semua contoh saya juga harus berfungsi di Edisi Komunitas IntelliJ IDEA gratis. Di tangkapan layar, jika Anda melihat bahwa saya memiliki beberapa jendela yang tidak Anda miliki, jangan khawatir — itu tidak penting untuk proyek ini :) Pertama, buat proyek Maven kosong. Saya menunjukkan bagaimana melakukan ini di artikel di tautan ini . Baca kata-kata " Saatnya kita mengubah proyek Maven kita menjadi proyek web. " — setelah itu, artikel tersebut menunjukkan cara membuat proyek web, tetapi kita tidak membutuhkannya sekarang. Di file src/main/javafolder, buat paket (dalam kasus saya, saya menyebutnya " en.codegym.info.fatfaggy.animals. Anda dapat menyebutnya apa pun yang Anda inginkan. Jangan lupa untuk mengganti nama paket saya dengan nama paket Anda di semua tempat yang tepat. Sekarang buat kelas Maindan tambahkan metode

public static void main(String[] args) {
    ...
}

Setelah itu, buka file pom.xml dan tambahkan dependenciesbagian tersebut. Sekarang buka repositori Maven dan temukan konteks Spring untuk versi stabil terbaru. Masukkan apa yang kami temukan ke dalam dependenciesbagian. Saya menjelaskan proses ini lebih detail di artikel CodeGym lainnya (lihat bagian berjudul " Menghubungkan dependensi di Maven "). Kemudian Maven sendiri akan menemukan dan mengunduh dependensi yang diperlukan. Pada akhirnya, Anda akan mendapatkan sesuatu seperti ini: Di ​​jendela sebelah kiri, Anda dapat melihat struktur proyek dengan paket dan kelasnya Main. Jendela tengah menunjukkan bagaimana tampilan pom.xml untuk saya. Saya juga menambahkan propertibagian untuk itu. Bagian ini memberi tahu Maven versi Java mana yang saya gunakan di file sumber saya dan versi mana yang akan dikompilasi. Ini agar IDEA tidak memperingatkan saya bahwa saya menggunakan Java versi lama. Ini adalah opsional :) Jendela kanan memperjelas bahwa meskipun kami hanya menghubungkan modul konteks pegas, secara otomatis menarik modul pegas-inti, kacang-kacangan, pegas-aop, dan ekspresi pegas. Kami dapat menghubungkan setiap modul secara terpisah, menuliskan dependensi untuk setiap modul dengan versi eksplisit di file pom.xml, tetapi untuk saat ini kami senang dengan hal-hal sebagaimana adanya. Sekarang buat entitiespaket dan buat 3 kelas di dalamnya: Cat, Dog, Parrot. Mari beri nama setiap hewan (private String name- Anda dapat meng-hardcode beberapa nilai di sana). Getter/setter bersifat publik. Sekarang kita beralih ke Mainkelas dan metodenya main(), dan kita menulis sesuatu seperti ini:

public static void main(String[] args) {
	// Create an empty Spring context that will look for its own beans based on the annotations in the specified package
	ApplicationContext context = 
		new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals.entities");

	Cat cat = context.getBean(Cat.class);
	Dog dog = (Dog) context.getBean("dog");
	Parrot parrot = context.getBean("parrot-polly", Parrot.class);

	System.out.println(cat.getName());
	System.out.println(dog.getName());
	System.out.println(parrot.getName());
}

Pertama, kita membuat objek konteks, memberi tahu konstruktor paket mana yang harus dicari untuk menemukan kacang. Dengan kata lain, Spring akan melalui paket ini dan mencoba menemukan kelas yang ditandai dengan anotasi khusus yang menunjukkan bahwa mereka adalah kacang. Kemudian ia membuat objek dari kelas-kelas ini dan menempatkannya dalam konteksnya. Setelah itu, kami mendapatkan kucing dari konteks ini. Kami memanggil objek konteks untuk memberi kami kacang (objek), yang menunjukkan kelas objek yang kami inginkan (omong-omong, kami juga dapat menentukan antarmuka, bukan hanya kelas). Setelah itu, Spring mengembalikan objek dari kelas yang diminta, yang kemudian kita simpan dalam sebuah variabel. Selanjutnya, kami meminta Spring untuk memberi kami kacang yang disebut "anjing". Saat Musim Semi menciptakan aDogobjek, itu memberi objek nama standar (kecuali kacang yang dibuat telah secara eksplisit diberi nama), yang merupakan nama kelas tetapi dengan huruf kecil awal. Dalam hal ini, kelas kita disebut Dog, jadi nama kacangnya adalah "anjing". Jika kita membutuhkan BufferedReaderobjek di sana, maka Spring akan menamakannya "bufferedReader". Dan karena Java tidak bisa 100% yakin kelas mana yang kita inginkan, ia mengembalikan sebuah Objectobjek, yang kemudian kita lemparkan secara manual ke tipe yang diinginkan, yaituDog. Opsi di mana kelas ditunjukkan secara eksplisit lebih nyaman. Opsi ketiga adalah mendapatkan kacang dengan nama kelas dan dengan nama kacang. Mungkin saja konteksnya memiliki beberapa kacang dari satu kelas. Untuk menunjukkan kacang tertentu yang kita butuhkan, kita menunjukkan namanya. Karena kami juga secara eksplisit menunjukkan kelas di sini, kami tidak lagi harus melakukan pemeran. PENTING!Jika Spring menemukan beberapa kacang yang cocok dengan persyaratan kami, maka ia tidak dapat menentukan kacang mana yang akan diberikan kepada kami, sehingga akan mengeluarkan pengecualian. Oleh karena itu, untuk menghindari situasi ini, Anda harus berusaha sespesifik mungkin dalam memberi tahu Spring kacang mana yang Anda butuhkan. Jika Spring mencari konteksnya dan gagal menemukan satu kacang yang cocok dengan persyaratan kami, maka itu juga akan mengeluarkan pengecualian. Terakhir, kami cukup menampilkan nama hewan kami untuk memverifikasi bahwa kami benar-benar mendapatkan objek yang kami butuhkan. Tetapi jika kita menjalankan program sekarang, kita akan melihat bahwa Spring tidak bahagia — dia tidak dapat menemukan hewan yang kita butuhkan dalam konteksnya. Hal ini karena belum menciptakan kacang ini. Seperti yang saya katakan sebelumnya, ketika Spring memindai kelas, ia mencari anotasi Spring-nya sendiri. Dan jika Spring tidak menemukan anotasi ini, maka tidak t berpikir bahwa kelas-kelas ini sesuai dengan kacang yang perlu dibuat. Memperbaiki ini hanya membutuhkan penambahan@Componentanotasi di depan setiap kelas hewan kita.

@Component
public class Cat {
	private String name = "Oscar";
	...
}

Tapi masih ada lagi. Jika kita perlu secara eksplisit memberi tahu Spring bahwa kacang untuk kelas ini harus memiliki nama tertentu, kita menunjukkan nama dalam tanda kurung setelah anotasi. Misalnya, untuk memberi tahu Spring agar memberi nama " parrot-polly" pada kacang beo, yang merupakan nama yang akan kita gunakan untuk memasukkan burung beo ini ke dalam mainmetode, kita harus melakukan sesuatu seperti ini:

@Component("parrot-polly")
public class Parrot {
	private String name = "Polly";
	...
}

Inilah inti dari konfigurasi otomatis . Anda menulis kelas Anda, menandainya dengan anotasi yang diperlukan, dan memberi tahu Spring paket yang berisi kelas Anda. Ini adalah paket yang akan dijalankan kerangka kerja untuk menemukan anotasi dan membuat objek dari kelas-kelas ini. Omong-omong, Spring tidak hanya mencari @Componentanotasi, tetapi juga semua anotasi lain yang mewarisi anotasi ini. Misalnya, @Controller, @RestController, @Service, @Repository, dan lainnya, yang akan kami perkenalkan di artikel mendatang. Sekarang kita akan mencoba melakukan hal yang sama menggunakan konfigurasi berbasis Java . Untuk memulai, hapus@Componentanotasi dari kelas kami. Untuk membuatnya lebih menantang, bayangkan kita tidak menulis kelas-kelas ini, sehingga kita tidak dapat dengan mudah memodifikasinya, yang berarti kita tidak dapat menambahkan anotasi. Sepertinya kelas-kelas ini dikemas dalam beberapa perpustakaan. Dalam hal ini, tidak ada cara bagi kami untuk mengedit kelas-kelas ini agar dikenali oleh Spring. Tapi kita membutuhkan objek dari kelas-kelas ini! Di sini kita membutuhkan konfigurasi berbasis Java untuk membuat objek. Untuk memulai, buat sebuah paket dengan nama seperti configs. Dalam paket ini, buat kelas Java biasa, seperti MyConfig, dan tandai dengan @Configurationanotasi.

@Configuration
public class MyConfig {
}

Sekarang kita perlu men-tweak main()metodenya, mengubah cara kita membuat konteksnya. Kami dapat secara eksplisit menunjukkan kelas mana yang memiliki konfigurasi kami:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class);

Jika kita memiliki beberapa kelas berbeda yang membuat kacang dan kita ingin menghubungkan beberapa di antaranya secara bersamaan, kita cukup menunjukkan semuanya di sana, dipisahkan dengan koma:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class, MyAnotherConfig.class);

Dan jika kami memiliki terlalu banyak dari mereka dan kami ingin menghubungkan semuanya secara bersamaan, maka kami cukup menunjukkan nama paket yang terkandung di dalamnya:

ApplicationContext context =
	new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals.configs");

Dalam hal ini, Spring akan menelusuri paket dan menemukan semua kelas yang ditandai dengan anotasi @Configuration. Nah, dan jika kita memiliki program yang sangat besar di mana konfigurasi dibagi menjadi beberapa paket, maka kita cukup menunjukkan daftar nama paket yang dipisahkan koma yang berisi konfigurasi:

ApplicationContext context =
	new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals.database.configs",
		"en.codegym.info.fatfaggy.animals.root.configs",
		"en.codegym.info.fatfaggy.animals.web.configs");

Atau nama paket yang umum untuk mereka semua:

ApplicationContext context =
	new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals");

Anda dapat melakukannya sesuka Anda, tetapi menurut saya opsi pertama, yang hanya menunjukkan kelas dengan konfigurasi, akan paling sesuai dengan program kami. Saat membuat konteks, Spring mencari kelas yang ditandai dengan @Configurationanotasi dan akan membuat objeknya sendiri dari kelas tersebut. Ini mencoba memanggil metode yang ditandai dengan @Beananotasi, yang berarti bahwa metode ini mengembalikan kacang (objek) yang akan ditambahkan Spring ke konteks. Dan sekarang kita akan membuat kacang untuk kucing, anjing, dan burung beo di kelas kita dengan konfigurasi berbasis Java. Ini cukup sederhana untuk dilakukan:

@Bean
public Cat getCat() {
	return new Cat();
}

Di sini kita membuat kucing kita secara manual dan menyerahkannya ke Spring, yang kemudian menyimpan objek kita dalam konteksnya. Karena kita tidak secara eksplisit memberi nama pada bean kita, Spring akan memberikannya nama yang sama dengan nama metodenya. Dalam kasus kami, kacang kucing akan disebut " getCat". Tetapi karena kita menggunakan kelas, bukan nama, untuk mendapatkan kacang kucing di dalam mainmetode, nama kacang tidak penting bagi kita. Demikian pula, buat kacang anjing, perlu diingat bahwa Spring akan memberikan nama metode ke kacang. Untuk secara eksplisit memberi nama kacang beo kami, kami cukup menunjukkan namanya dalam tanda kurung setelah @Beananotasi:

@Bean("parrot-polly")
public Object weNeedMoreParrots() {
	return new Parrot();
}

Seperti yang Anda lihat, di sini saya menunjukkan Objecttipe pengembalian dan memberi metode nama yang sewenang-wenang. Ini tidak memengaruhi nama kacang, karena kami secara eksplisit menentukan namanya di sini. Tetap saja, lebih baik menunjukkan nilai pengembalian dan nama metode yang kurang lebih berarti. Lakukan ini jika tidak ada alasan lain selain untuk membantu diri Anda sendiri saat Anda membuka kembali proyek dalam setahun. :) Sekarang pertimbangkan situasi di mana kita membutuhkan satu kacang untuk membuat kacang lainnya . Misalnya, kita ingin nama kucing di kacang kucing menjadi nama burung beo ditambah string "-killer". Tidak masalah!

@Bean
public Cat getCat(Parrot parrot) {
	Cat cat = new Cat();
	cat.setName(parrot.getName() + "-killer");
	return cat;
}

Di sini Spring akan melihat bahwa untuk membuat kacang ini, kerangka kerja harus melewati kacang beo yang dibuat sebelumnya. Oleh karena itu, ini akan mengatur rangkaian pemanggilan metode yang diperlukan: pertama, metode pembuatan burung beo dipanggil dan kemudian kerangka kerja meneruskan burung beo baru ke metode pembuatan kucing. Di sinilah injeksi dependensi berperan: Spring sendiri meneruskan kacang beo yang diperlukan ke metode kami. Jika IDEA kecewa dengan parrotvariabel tersebut, jangan lupa untuk mengubah jenis kembalian metode pembuatan burung beo dari Objectmenjadi Parrot. Selain itu, konfigurasi berbasis Java memungkinkan Anda menjalankan semua kode Java sepenuhnyadalam metode pembuatan kacang Anda. Anda benar-benar dapat melakukan apa saja: membuat objek tambahan lainnya, memanggil metode lain, bahkan yang tidak ditandai dengan anotasi Spring, membuat loop, kondisi Boolean — apa pun yang terlintas dalam pikiran! Ini tidak semuanya mungkin dengan konfigurasi otomatis, dan terlebih lagi dengan konfigurasi XML. Sekarang mari kita pertimbangkan masalah yang sedikit lebih menyenangkan. Polimorfisme dan antarmuka :) Kita akan membuat WeekDayantarmuka dan membuat 7 kelas yang mengimplementasikan antarmuka ini: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday. Kami akan memberikan antarmuka sebuah String getWeekDayName()metode, yang akan mengembalikan nama hari dalam seminggu untuk kelas yang sesuai. Dengan kata lain, Mondaykelas akan kembali "Monday", dll. Saat memulai aplikasi, misalkan tugas kita adalah memasukkan kacang yang sesuai dengan hari ini dalam seminggu ke dalam konteks. Bukan kacang untuk semua kelas yang mengimplementasikan antarmuka — hanya satu kacang yang kita butuhkan. Anda WeekDaybisa lakukan itu seperti ini:

@Bean
public WeekDay getDay() {
	DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
	switch (dayOfWeek) {
		case MONDAY: return new Monday();
		case TUESDAY: return new Tuesday();
		case WEDNESDAY: return new Wednesday();
		case THURSDAY: return new Thursday();
		case FRIDAY: return new Friday();
		case SATURDAY: return new Saturday();
		default: return new Sunday();
	}
}

Di sini tipe pengembalian adalah antarmuka kami. Metode mengembalikan objek bonafid dari salah satu kelas yang mengimplementasikan antarmuka, bergantung pada hari ini dalam seminggu. Sekarang kita dapat melakukan hal berikut dalam main()metode ini:

WeekDay weekDay = context.getBean(WeekDay.class);
System.out.println("Today is " + weekDay.getWeekDayName() + "!");

Bagi saya, program memberi tahu saya bahwa ini hari Minggu :) Saya yakin jika saya menjalankan program besok, konteksnya akan berisi objek yang sama sekali berbeda. Perhatikan bahwa kita mendapatkan kacang hanya dengan menggunakan antarmuka: context.getBean(WeekDay.class). Spring akan mencari konteksnya untuk kacang yang mengimplementasikan antarmuka, dan akan mengembalikannya. Kemudian ternyata WeekDayvariabel kita berakhir dengan objek hari Minggu, dan konsep polimorfisme yang sudah dikenal berlaku saat kita bekerja dengan variabel ini. :) Sekarang beberapa kata tentang pendekatan gabungan , di mana beberapa kacang dibuat secara otomatis oleh Spring, beberapa dengan memindai paket untuk kelas dengan anotasi @Component, dan lainnya dengan konfigurasi berbasis Java. Saat kami mempertimbangkan ini, kami akan kembali ke versi aslinya, di mana Cat, Dog, danParrotkelas ditandai dengan @Componentanotasi. Misalkan kita ingin membuat kacang untuk hewan kita dengan meminta Spring memindai paket secara otomatis , entitiestetapi kita juga ingin membuat kacang dengan hari dalam seminggu, seperti yang baru saja kita lakukan. Yang perlu Anda lakukan hanyalah menambahkan @ComponentScananotasi pada tingkat kelas MyConfig, yang kami tunjukkan saat membuat konteks di main(), dan menunjukkan dalam tanda kurung paket yang perlu dipindai dan membuat kacang dari kelas yang diperlukan secara otomatis:

@Configuration
@ComponentScan("en.codegym.info.fatfaggy.animals.entities")
public class MyConfig {
	@Bean
	public WeekDay getDay() {
		DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
		switch (dayOfWeek) {
			case MONDAY: return new Monday();
			case TUESDAY: return new Tuesday();
			case WEDNESDAY: return new Wednesday();
			case THURSDAY: return new Thursday();
			case FRIDAY: return new Friday();
			case SATURDAY: return new Saturday();
			default: return new Sunday();
		}
	}
}

Saat membuat konteks, Spring melihat bahwa ia perlu memproses MyConfigkelas. Ia memasuki kelas dan melihat bahwa ia perlu memindai en.codegym.info.fatfaggy.animals.entitiespaket " " dan membuat kacang dari kelas tersebut, setelah itu ia mengeksekusi metode MyConfigkelas getDay()dan menambahkan WeekDaykacang ke dalam konteks. Dalam main()metode ini, kami sekarang memiliki akses ke semua kacang yang kami butuhkan: objek hewan dan kacang dengan hari dalam seminggu. Jika Anda perlu membuat Spring juga mengambil beberapa file konfigurasi XML, Anda dapat melakukan pencarian web Anda sendiri untuk menemukan penjelasan :) Ringkasan:

• Coba gunakan konfigurasi otomatis
• Selama konfigurasi otomatis, tunjukkan nama paket yang berisi kelas yang kacangnya perlu dibuat
• Kelas-kelas ini ditandai dengan @Componentanotasi
• Musim semi berjalan melalui semua kelas ini, membuat objek, dan menempatkannya dalam konteks;
• Jika konfigurasi otomatis tidak cocok untuk kami karena suatu alasan, kami menggunakan konfigurasi berbasis Java
• Dalam hal ini, kami membuat kelas Java biasa yang metodenya mengembalikan objek yang kami butuhkan. Kami menandai kelas ini dengan @Configurationanotasi jika kami akan memindai seluruh paket daripada menunjukkan kelas tertentu dengan konfigurasi saat membuat konteks
• Metode kelas ini yang mengembalikan kacang ditandai dengan @Beananotasi
Jika kami ingin mengaktifkan pemindaian otomatis saat menggunakan konfigurasi berbasis Java, kami menggunakan anotasi @ComponentScan.

Jika artikel ini benar-benar membingungkan, cobalah membacanya dalam beberapa hari. Atau jika Anda berada di salah satu level awal CodeGym, mungkin terlalu dini bagi Anda untuk mempelajari Musim Semi. Anda selalu dapat kembali ke artikel ini nanti ketika Anda merasa lebih percaya diri dengan keterampilan pemrograman Java Anda. Jika semuanya jelas, maka Anda dapat mencoba mengonversi beberapa proyek hewan peliharaan Anda ke Spring :) Jika ada yang jelas tetapi ada yang tidak, silakan tinggalkan komentar :) Beri tahu saya saran dan kritik Anda, jika saya salah di suatu tempat atau menulis sesuatu yang tidak masuk akal :) Di artikel berikutnya, kita akan tiba-tiba terjun ke spring-web-mvc dan membuat aplikasi web sederhana menggunakan Spring.