ฤดูใบไม้ผลิมีไว้สำหรับคนขี้เกียจ ความรู้พื้นฐาน แนวคิดพื้นฐาน และตัวอย่างพร้อมโค้ด ส่วนที่ 2

ในบทความที่แล้วฉันได้อธิบายโดยสรุปว่าสปริงคืออะไร ถังขยะคืออะไร และบริบท ตอนนี้ได้เวลาลองดูวิธีการทำงานทั้งหมดแล้ว ฉันจะทำมันเองใน Intellij Idea Enterprise Edition แต่ตัวอย่างทั้งหมดของฉันควรใช้ได้ใน Intellij Idea Community Edition ที่ให้บริการฟรี แค่คุณเห็นในภาพหน้าจอว่าฉันมีหน้าต่างบางประเภทที่คุณไม่มี ไม่ต้องกังวล มันไม่สำคัญสำหรับโปรเจ็กต์นี้ :) ก่อนอื่น มาสร้างโปรเจ็กต์ Maven ว่างๆ กัน ฉันแสดงวิธีการทำเช่นนี้ในบทความ (อ่านจนกระทั่งคำว่า " ถึงเวลาเปลี่ยนโครงการ maven ของเราให้เป็นโครงการเว็บ " หลังจากนั้นก็แสดงวิธีสร้างโครงการเว็บแล้ว และตอนนี้เราไม่ต้องการสิ่งนี้แล้ว) มาสร้างมันขึ้นมาในโฟลเดอร์ src/main /javaกันดีกว่า (ในกรณีของฉันฉันเรียกมันว่า “ ru.javarush.info.fatfaggy.animals” คุณสามารถตั้งชื่อมันได้ตามต้องการ แค่อย่าลืมแทนที่มันด้วยชื่อของคุณในตำแหน่งที่ถูกต้อง) และมาสร้างคลาสMainที่เราจะสร้างเมธอดกัน

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

dependenciesจากนั้นเปิด ไฟล์ pom.xml และเพิ่มส่วนตรงนั้น ตอนนี้เราไปที่พื้นที่เก็บข้อมูล Mavenและมองหาบริบทฤดูใบไม้ผลิของเวอร์ชันเสถียรล่าสุดที่นั่น และวางสิ่งที่เราได้รับไว้ในส่วนdependenciesนั้น ฉันอธิบายกระบวนการนี้โดยละเอียดเพิ่มเติมเล็กน้อยในบทความนี้ (ดูหัวข้อ " การเชื่อมต่อการพึ่งพาใน Maven ") จากนั้น Maven จะค้นหาและดาวน์โหลดการขึ้นต่อกันที่จำเป็นและในที่สุดคุณควรได้รับสิ่งนี้: ในหน้าต่างด้านซ้าย คุณจะเห็นโครงสร้างของโปรเจ็กต์พร้อมแพ็กเกจและMainคลาส หน้าต่างตรงกลางจะแสดงลักษณะของ pom.xml ของฉัน ฉันยังเพิ่ม ส่วนคุณสมบัติ ที่นั่น ซึ่งฉันได้ระบุให้ Maven ทราบว่าฉันใช้ Java เวอร์ชันใดในซอร์สโค้ดและเวอร์ชันใดที่จะคอมไพล์ นี่เป็นเพียงเพื่อที่ฉันจะได้ไม่ได้รับคำเตือนเมื่อเริ่มต้นใช้งาน Java เวอร์ชันเก่า คุณสามารถทำได้ คุณไม่สามารถ) ในหน้าต่างด้านขวา - คุณจะเห็นว่าแม้ว่าเราจะเชื่อมต่อเฉพาะบริบทของสปริงเท่านั้น - มันเพิ่ม core, bean, aop และ expression โดยอัตโนมัติ เป็นไปได้ที่จะเชื่อมต่อแต่ละโมดูลแยกกัน โดยลงทะเบียนการขึ้นต่อกันสำหรับแต่ละโมดูลในหน่วยความจำพร้อมการระบุเวอร์ชันอย่างชัดเจน แต่ตอนนี้เราพอใจกับตัวเลือกที่เป็นอยู่ตอนนี้ ตอนนี้เรามาสร้างแพ็คเกจentities(เอนทิตี) และสร้าง 3 คลาสในนั้น: Cat, Dog, Parrot. ปล่อยให้สัตว์แต่ละตัวมีชื่อ ( private String nameคุณสามารถฮาร์ดโค้ดบางค่าที่นั่นได้) และ getters/setters จะเป็นสาธารณะ ไปที่ชั้นเรียนMainแล้วmain()เขียนสิ่งนี้ในวิธีการ:

public static void main(String[] args) {
	// create an empty spring context that will search for its beans by annotations in the specified package
	ApplicationContext context =
		new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.entities");

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

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

ขั้นแรก เราสร้างวัตถุบริบท และในตัวสร้าง เราตั้งชื่อแพ็คเกจที่ต้องสแกนหาว่ามี bean อยู่หรือไม่ นั่นคือ Spring จะพิจารณาแพ็คเกจนี้และพยายามค้นหาคลาสที่ทำเครื่องหมายด้วยคำอธิบายประกอบพิเศษที่ทำให้ Spring รู้ว่านี่คือ bean หลังจากนั้นจะสร้างอ็อบเจ็กต์ของคลาสเหล่านี้และวางไว้ในบริบท หลังจากนั้นเราก็ได้แมวจากบริบทนี้ เมื่อกล่าวถึงวัตถุบริบท เราขอให้มันให้ bean (วัตถุ) แก่เรา และระบุคลาสของวัตถุที่เราต้องการ (ที่นี่ คุณสามารถระบุได้ไม่เพียงแต่คลาสเท่านั้น แต่ยังรวมถึงอินเทอร์เฟซด้วย) หลังจากนั้น Spring จะส่งอ็อบเจ็กต์ของคลาสนี้กลับมาให้เรา ซึ่งเราจะบันทึกลงในตัวแปร ต่อไป เราขอให้สปริงเอาถั่วชื่อ "สุนัข" มาให้เรา เมื่อ Spring สร้างคลาสอ็อบเจ็กต์Dogมันจะตั้งชื่อมาตรฐานให้กับมัน (หากไม่ได้ระบุชื่อของ bean ที่กำลังสร้างไว้อย่างชัดเจน) ซึ่งเป็นชื่อของคลาสของอ็อบเจ็กต์โดยใช้ตัวอักษรตัวเล็กเท่านั้น ดังนั้นเนื่องจากคลาสของเราDogชื่อ ชื่อของถั่วชนิดนี้จึงจะเป็น "สุนัข" หากเรามีวัตถุอยู่ที่นั่นBufferedReaderSpring จะตั้งชื่อเริ่มต้นให้กับมันว่า "bufferedReader" และเนื่องจากในกรณีนี้ (ใน Java) ไม่มีความแน่นอนที่แน่ชัดว่าวัตถุดังกล่าวจะเป็นคลาสใด ดังนั้นเพียงวัตถุบางอย่างจะถูกส่งกลับObjectซึ่งจากนั้นเราจะส่งไปยังประเภทที่เราต้องการด้วยDogตนเอง ตัวเลือกที่มีการบ่งชี้คลาสอย่างชัดเจนจะสะดวกกว่า ในกรณีที่สาม เราได้ถั่วตามคลาสและชื่อ อาจมีสถานการณ์ที่ในบริบทจะมี bean หลายอันในคลาสเดียว และเพื่อระบุว่าเราต้องการ bean ตัวใด เราจึงระบุชื่อของมัน เนื่องจากเราได้ระบุคลาสไว้อย่างชัดเจนที่นี่ เราจึงไม่จำเป็นต้องร่ายอีกต่อไป สำคัญ!หากปรากฎว่า Spring พบ bean หลายตัวตามข้อกำหนดที่เราระบุไว้ มันจะไม่สามารถระบุได้ว่าจะให้ bean ใดแก่เราและจะโยนข้อยกเว้น ดังนั้นพยายามระบุให้เขาชัดเจนที่สุดเท่าที่จะเป็นไปได้ว่าคุณต้องการถังขยะชนิดใดเพื่อไม่ให้สถานการณ์ดังกล่าวเกิดขึ้น หาก Spring ไม่พบ bean ตัวเดียวในบริบทตามเงื่อนไขของคุณ ฤดูใบไม้ผลินั้นก็จะเกิดข้อยกเว้นเช่นกัน ถ้าอย่างนั้น เราก็แสดงชื่อสัตว์ของเราบนหน้าจอเพื่อให้แน่ใจว่าสิ่งเหล่านี้เป็นวัตถุที่เราต้องการจริงๆ แต่ถ้าเรารันโปรแกรมตอนนี้ เราจะเห็นว่า Spring สาบานว่าจะไม่พบสัตว์ที่เราต้องการในบริบทของมัน สิ่งนี้เกิดขึ้นเพราะเขาไม่ได้สร้างถั่วเหล่านี้ อย่างที่ฉันบอกไปแล้ว เมื่อ Spring สแกนคลาส มันจะมองหาคำอธิบายประกอบของ Spring ที่นั่น และถ้ามันไม่พบมัน มันก็จะไม่รับรู้ถึงคลาสอย่างเช่นคลาสที่เขาต้องการสร้าง เพื่อแก้ไขปัญหานี้ เพียงเพิ่มคำอธิบาย@Componentประกอบหน้าชั้นเรียนในชั้นเรียนสัตว์ของเรา

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

แต่นั่นไม่ใช่ทั้งหมด หากเราจำเป็นต้องระบุอย่างชัดเจนกับ Spring ว่า bean สำหรับคลาสนี้ควรมีชื่อเฉพาะ ชื่อนี้สามารถระบุในวงเล็บหลังคำอธิบายประกอบได้ ตัวอย่างเช่น เพื่อให้ Spring ตั้งชื่อที่เราต้องการให้กับparrot-keshaParrot Bean ซึ่งmainต่อมาเราจะได้รับนกแก้วตัวนี้ เราต้องดำเนินการดังนี้:

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

นี่คือจุดรวมของการกำหนดค่าอัตโนมัติ คุณเขียนคลาสของคุณ ทำเครื่องหมายด้วยคำอธิบายประกอบที่จำเป็น และระบุให้ Spring แพ็คเกจกับคลาสของคุณค้นหาคำอธิบายประกอบและสร้างอ็อบเจ็กต์ของคลาสดังกล่าว อย่างไรก็ตาม Spring จะค้นหาไม่เพียงแต่คำอธิบายประกอบ@Componentแต่ยังรวมถึงคำอธิบายประกอบอื่นๆ ทั้งหมดที่สืบทอดมาจากคำอธิบายประกอบนี้ด้วย ตัวอย่างเช่น , @Controller, @RestController, @Serviceและ@Repositoryอื่นๆ ซึ่งเราจะพบกันในบทความต่อไป ตอนนี้เรามาลองทำแบบเดียวกัน แต่ใช้การกำหนดค่า java ขั้นแรก ให้ลบคำอธิบายประกอบออก@Componentจากชั้นเรียนของเรา เพื่อให้งานซับซ้อน ลองจินตนาการว่าคลาสเหล่านี้ไม่ใช่คลาสที่เราเขียนเอง ซึ่งเราสามารถแก้ไข เพิ่มบางอย่าง รวมถึงคำอธิบายประกอบได้อย่างง่ายดาย ราวกับว่าชั้นเรียนเหล่านี้อัดแน่นอยู่ในห้องสมุดบางแห่ง ในกรณีนี้ เราไม่สามารถแก้ไขคลาสเหล่านี้ในทางใดทางหนึ่งเพื่อให้ได้รับการยอมรับภายในฤดูใบไม้ผลิ แต่เราต้องการวัตถุของคลาสเหล่านี้! ที่นี่เราจะต้องมีการกำหนดค่าจาวาเพื่อสร้างวัตถุดังกล่าว ขั้นแรก เรามาสร้างแพ็คเกจกันก่อนconfigsและในนั้น - คลาส Java ปกติ เป็นต้นMyConfigและทำเครื่องหมายด้วยคำอธิบายประกอบ@Configuration

@Configuration
public class MyConfig {
}

ตอนนี้เราจำเป็นต้องปรับเปลี่ยนmain()วิธีการสร้างบริบทในวิธีการ เล็กน้อย เราสามารถระบุคลาสของเราโดยตรงด้วยการกำหนดค่าที่นั่น:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class);

หากเรามีคลาสที่แตกต่างกันหลายคลาสที่เราสร้าง bean และเราต้องการเชื่อมต่อหลายคลาสในคราวเดียว เราก็ระบุคลาสเหล่านั้นด้วยเครื่องหมายจุลภาค:

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

หากเรามีจำนวนมากเกินไปและเราต้องการเชื่อมต่อพวกมันทั้งหมดในคราวเดียว เราก็เพียงระบุชื่อแพ็คเกจที่เรามีไว้ที่นี่:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.configs");

ในกรณีนี้ Spring จะผ่านแพ็คเกจนี้และค้นหาคลาสทั้งหมดที่มีเครื่องหมาย@Configurationประกอบ ในกรณีที่เรามีโปรแกรมขนาดใหญ่มากที่การกำหนดค่าถูกแบ่งออกเป็นแพ็คเกจที่แตกต่างกัน เราเพียงระบุชื่อของแพ็คเกจด้วยการกำหนดค่าคั่นด้วยเครื่องหมายจุลภาค:

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

หรือชื่อของแพ็คเกจทั่วไปสำหรับทุกคน:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals");

คุณสามารถทำได้ตามที่คุณต้องการ แต่สำหรับฉันแล้วดูเหมือนว่าตัวเลือกแรกที่คุณระบุคลาสด้วยการกำหนดค่าจะเหมาะกับโปรแกรมของเรามากที่สุด เมื่อสร้างบริบท Spring จะค้นหาคลาสที่ถูกทำเครื่องหมายด้วยคำอธิบายประกอบ@Configurationและสร้างอ็อบเจ็กต์ของคลาสเหล่านี้ในตัวเอง หลังจากนั้นจะพยายามเรียกเมธอดในคลาสเหล่านี้ซึ่งมีเครื่องหมายกำกับไว้@Beanซึ่งหมายความว่าเมธอดดังกล่าวจะส่งคืน bean (อ็อบเจ็กต์) ที่ได้วางไว้ในบริบทแล้ว ทีนี้มาสร้าง cat, dog และ Parrot bean ในคลาสของเราด้วยการกำหนดค่า java กันดีกว่า สิ่งนี้ทำได้ค่อนข้างง่าย:

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

ปรากฎว่าเราสร้างแมวของเราด้วยตนเองและมอบให้กับ Spring และเขาได้วางวัตถุนี้ของเราไว้ในบริบทของเขาแล้ว เนื่องจากเราไม่ได้ระบุชื่อ bean ของเราอย่างชัดเจน Spring จะให้ชื่อ bean เหมือนกับชื่อของ method ในกรณีของเรา ถั่วแมวจะมีชื่อว่า " getCat" แต่เนื่องจากในmain-e เรายังคงได้แมวไม่ใช่ตามชื่อ แต่ตามคลาส ในกรณีนี้ ชื่อของถังขยะนี้จึงไม่สำคัญสำหรับเรา ทำถั่วกับสุนัขด้วยวิธีเดียวกัน แต่โปรดจำไว้ว่า Spring จะตั้งชื่อถั่วตามชื่อของวิธีการ หากต้องการตั้งชื่อถั่วของเราด้วยนกแก้วอย่างชัดเจน เพียงระบุชื่อของมันในวงเล็บหลังคำอธิบายประกอบ@Bean:

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

อย่างที่คุณเห็น ที่นี่ฉันระบุประเภทของค่าที่ส่งคืนObjectและเรียกวิธีการอะไรก็ได้ สิ่งนี้จะไม่ส่งผลกระทบต่อชื่อของ bean แต่อย่างใด เพราะเรากำหนดไว้อย่างชัดเจนที่นี่ แต่จะเป็นการดีกว่าถ้าระบุประเภทค่าส่งคืนและชื่อวิธีการโดยไม่อยู่ในสีน้ำเงิน แต่ให้ชัดเจนไม่มากก็น้อย แม้กระทั่งเพื่อตัวคุณเองเมื่อคุณเปิดโครงการนี้ในหนึ่งปี :) ทีนี้ลองพิจารณาสถานการณ์ที่ จะสร้าง bean หนึ่ง อันที่เราจำเป็นต้องใช้ bean อีกอันหนึ่ง ตัวอย่างเช่น เราต้องการให้ชื่อของแมวใน cat bean ประกอบด้วยชื่อของนกแก้วและสตริง "-killer" ไม่มีปัญหา!

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

ที่นี่ฤดูใบไม้ผลิจะเห็นว่าก่อนที่จะสร้างถั่วนี้ เขาจะต้องโอนถั่วนกแก้วที่สร้างไว้แล้วที่นี่ ดังนั้นเขาจะสร้างสายโซ่ของการเรียกวิธีการของเราเพื่อให้เรียกวิธีสร้างนกแก้วก่อนแล้วจึงส่งต่อนกแก้วนี้ไปยังวิธีสร้างแมว นี่คือสิ่งที่เรียกว่าdependency injection ทำงาน : Spring เองส่งผ่าน Parrot bean ที่จำเป็นไปยังวิธีการของเรา หากแนวคิด นี้บ่นเกี่ยวกับตัวแปรparrotอย่าลืมเปลี่ยนประเภทการส่งคืนในวิธีการสร้างนกแก้วจากObjectเป็น Parrotนอกจากนี้ การกำหนดค่า Java ยังช่วยให้คุณสามารถรันโค้ด Java ใดๆ ก็ได้อย่างแน่นอนในวิธีการสร้าง bean คุณสามารถทำอะไรก็ได้จริงๆ: สร้างอ็อบเจ็กต์เสริมอื่นๆ, เรียกใช้เมธอดอื่นใด, แม้แต่เมธอดที่ไม่ได้ทำเครื่องหมายด้วยคำอธิบายประกอบแบบสปริง, สร้างลูป, เงื่อนไข - อะไรก็ได้ที่อยู่ในใจ! ทั้งหมดนี้ไม่สามารถทำได้โดยใช้การกำหนดค่าอัตโนมัติ แต่จะน้อยกว่ามากเมื่อใช้การกำหนดค่า xml ทีนี้เรามาดูปัญหาที่สนุกกว่านี้กันดีกว่า ด้วยความหลากหลายและอินเทอร์เฟซ :) มาสร้างอินเทอร์เฟซWeekDayและสร้าง 7 คลาสที่จะใช้อินเทอร์เฟซนี้: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday. มาสร้างวิธีการในอินเทอร์เฟซString getWeekDayName()ที่จะส่งคืนชื่อวันในสัปดาห์ของคลาสที่เกี่ยวข้อง นั่นคือคลาสMondayจะส่งคืน " monday" เป็นต้น สมมติว่างานเมื่อเปิดตัวแอปพลิเคชันของเราคือการวาง bean ในบริบทที่จะสอดคล้องกับวันปัจจุบันของสัปดาห์ ไม่ใช่ถั่วทั้งหมดในทุกคลาสที่ใช้WeekDayอินเทอร์เฟซ แต่เป็นเพียงอันที่เราต้องการเท่านั้น สามารถทำได้ดังนี้:

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

ที่นี่ประเภทค่าตอบแทนคืออินเทอร์เฟซของเรา และวิธีการส่งคืนอ็อบเจ็กต์จริงของคลาสการใช้งานอินเทอร์เฟซ ขึ้นอยู่กับวันปัจจุบันของสัปดาห์ ตอนนี้ในวิธีmain()ที่เราสามารถทำได้:

WeekDay weekDay = context.getBean(WeekDay.class);
System.out.println("It's " + weekDay.getWeekDayName() + " today!");

มันบอกฉันว่าวันนี้เป็นวันอาทิตย์ :) ฉันแน่ใจว่าถ้าฉันรันโปรแกรมพรุ่งนี้ วัตถุที่แตกต่างไปจากเดิมอย่างสิ้นเชิงจะปรากฏขึ้นในบริบท โปรดทราบว่าที่นี่เราได้รับ bean เพียงใช้อินเทอร์เฟซcontext.getBean(WeekDay.class): Spring จะพิจารณาบริบทเพื่อดูว่าถั่วตัวใดใช้อินเทอร์เฟซดังกล่าวและจะส่งคืน ถ้าอย่างนั้นปรากฎว่าWeekDayมีวัตถุประเภทหนึ่งในตัวแปรประเภทSundayและความหลากหลายซึ่งเราทุกคนคุ้นเคยอยู่แล้วเริ่มต้นเมื่อทำงานกับตัวแปรนี้ :) และคำสองสามคำเกี่ยวกับแนวทางแบบรวมโดยที่ Bean บางตัวถูกสร้างขึ้นโดย Spring เอง โดยใช้การสแกนแพ็คเกจเพื่อดูคลาสที่มีคำอธิบายประกอบ@Componentและ bean อื่น ๆ บางตัวถูกสร้างขึ้นโดยใช้การกำหนดค่า java เมื่อต้องการทำเช่นนี้ ให้ย้อนกลับไปที่เวอร์ชันเดิม เมื่อเรียนCatและถูกทำเครื่องหมายด้วยคำDogอธิบายประกอบ สมมติว่าเราต้องการสร้างถังขยะสำหรับสัตว์ของเราโดยใช้ การสแกน บรรจุภัณฑ์อัตโนมัติภายในฤดูใบไม้ผลิ แต่สร้างถังขยะโดยระบุวันในสัปดาห์เหมือนที่เราเพิ่งทำ สิ่งที่คุณต้องทำคือเพิ่มที่ระดับชั้นเรียนซึ่งเราระบุเมื่อสร้างบริบทในคำอธิบายประกอบ -th และระบุแพ็คเกจที่ต้องสแกนและ bean ของคลาสที่จำเป็นที่สร้างขึ้นโดยอัตโนมัติในวงเล็บ: Parrot@ComponententitiesMyConfigmain@ComponentScan

@Configuration
@ComponentScan("ru.javarush.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();
		}
	}
}

ปรากฎว่าเมื่อสร้างบริบท Spring เห็นว่าจำเป็นต้องประมวลผลMyConfigคลาส เขาเข้าไปข้างในและเห็นว่าเขาจำเป็นต้องสแกนแพ็คเกจ " ru.javarush.info.fatfaggy.animals.entities" และสร้าง bean ของคลาสเหล่านั้น หลังจากนั้นเขาก็รันเมธอดgetDay()จากคลาสMyConfigและเพิ่ม bean ประเภทนั้นWeekDayให้กับบริบทของเขา ในวิธีการนี้main()ตอนนี้เราสามารถเข้าถึงถั่วทั้งหมดที่เราต้องการแล้ว ทั้งวัตถุของสัตว์และถั่ววันในสัปดาห์ จะแน่ใจได้อย่างไรว่า Spring รับการกำหนดค่า xml ด้วย - google บนอินเทอร์เน็ตด้วยตัวคุณเองหากคุณต้องการ :) สรุป:

• ลองใช้การกำหนดค่าอัตโนมัติ
• ในระหว่างการกำหนดค่าอัตโนมัติ เราจะระบุชื่อของแพ็คเกจที่มีคลาสที่ต้องสร้าง bean
• คลาสดังกล่าวจะถูกทำเครื่องหมายด้วยคำอธิบายประกอบ@Component;
• spring ต้องผ่านคลาสดังกล่าวทั้งหมดและสร้างอ็อบเจ็กต์และวางไว้ในบริบท
• หากการกำหนดค่าอัตโนมัติไม่เหมาะกับเราด้วยเหตุผลบางประการ เราจะใช้การกำหนดค่าจาวา
• ในกรณีนี้ เราสร้างคลาส Java ปกติซึ่งมีวิธีการส่งคืนอ็อบเจ็กต์ที่เราต้องการ และทำเครื่องหมายคลาสดังกล่าวด้วยคำอธิบายประกอบ@Configurationในกรณีที่เราสแกนแพ็คเกจทั้งหมด แทนที่จะระบุคลาสเฉพาะด้วยการกำหนดค่าเมื่อสร้างบริบท
• วิธีการของคลาสนี้ที่ส่งคืนถั่วจะถูกทำเครื่องหมายด้วยคำอธิบายประกอบ@Bean;
หากเราต้องการเปิดใช้งานการสแกนอัตโนมัติเมื่อใช้การกำหนดค่า Java เราจะใช้คำอธิบาย @ComponentScanประกอบ

หากไม่มีสิ่งใดชัดเจน ให้ลองอ่านบทความนี้ภายในสองสามวัน หรือถ้าคุณอยู่ในระดับเริ่มต้นของ Javarash บางทีคุณอาจจะเรียนรู้ฤดูใบไม้ผลิเร็วไปหน่อย คุณสามารถกลับมาที่บทความนี้อีกครั้งในภายหลังได้เสมอ เมื่อคุณรู้สึกมั่นใจมากขึ้นในการเขียนโปรแกรมใน Java หากทุกอย่างชัดเจนคุณสามารถลองโอนโครงการสัตว์เลี้ยงบางส่วนของคุณไปที่ Spring ได้ :) หากมีบางอย่างชัดเจน แต่มีบางอย่างไม่มากโปรดแสดงความคิดเห็น :) นอกจากนี้ยังมีข้อเสนอแนะและความคิดเห็นหากฉันก้าวไปที่ไหนสักแห่งหรือเขียนสิ่งที่โง่ ) ในบทความถัดไป เราจะเจาะลึกเกี่ยวกับspring-web-mvcและสร้างเว็บแอปพลิเคชันอย่างง่ายโดยใช้ spring