ในบทความที่แล้วฉันได้อธิบายโดยสรุปว่าสปริงคืออะไร ถังขยะคืออะไร และบริบท ตอนนี้ได้เวลาลองดูวิธีการทำงานทั้งหมดแล้ว
ฉันจะทำมันเองใน 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
ชื่อ ชื่อของถั่วชนิดนี้จึงจะเป็น "สุนัข" หากเรามีวัตถุอยู่ที่นั่นBufferedReader
Spring จะตั้งชื่อเริ่มต้นให้กับมันว่า "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-kesha
Parrot 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
@Component
entities
MyConfig
main
@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
;
@ComponentScan
ประกอบ
GO TO FULL VERSION