ในบทความที่แล้วฉันได้อธิบายสั้นๆ ว่า Spring คืออะไร และถั่วและบริบทคืออะไร ตอนนี้ได้เวลาทดลองใช้งานแล้ว ฉันจะใช้ IntelliJ IDEA Enterprise Edition แต่ตัวอย่างทั้งหมดของฉันควรใช้งานได้ใน IntelliJ IDEA Community Edition ฟรี ในภาพหน้าจอ ถ้าคุณเห็นว่าฉันมีบางหน้าต่างที่คุณไม่มี ไม่ต้องกังวล — มันไม่สำคัญสำหรับโปรเจ็กต์นี้ :) Spring for lazy people รากฐาน แนวคิดพื้นฐาน และตัวอย่างพร้อมโค้ด ตอนที่ 2 - 1ขั้นแรก สร้างโปรเจ็กต์ Maven ที่ว่างเปล่า ฉันแสดงวิธีทำในบทความที่ลิงค์นี้ . อ่านจนถึงคำว่า " ถึงเวลาที่เราจะแปลงโปรเจ็กต์ Maven เป็นโปรเจ็กต์เว็บแล้ว " — หลังจากนั้น บทความจะแสดงวิธีสร้างโปรเจ็กต์เว็บ แต่เราไม่ต้องการสิ่งนั้นในตอนนี้ ในsrc/main/javaโฟลเดอร์ สร้างแพ็คเกจ (ในกรณีของฉัน ฉันเรียกมันว่า " en.codegym.info.fatfaggy.animalsคุณสามารถเรียกมันว่าอะไรก็ได้ที่คุณต้องการ อย่าลืมแทนที่ชื่อแพ็คเกจของฉันด้วยชื่อแพ็คเกจของคุณในตำแหน่งที่ถูกต้อง ตอนนี้สร้างคลาสMainและเพิ่ม วิธี 

public static void main(String[] args) {
    ...
}
หลังจากนั้นให้เปิดไฟล์ pom.xml และเพิ่มdependenciesส่วน ตอนนี้ไปที่ที่เก็บ Mavenและค้นหาบริบท Springสำหรับเวอร์ชันเสถียรล่าสุด ใส่สิ่งที่เราพบลงในdependenciesส่วน ฉันได้อธิบายกระบวนการนี้อย่างละเอียดในบทความ CodeGym อื่น ๆ นี้ (ดูหัวข้อ " การเชื่อมต่อการพึ่งพาใน Maven ") จากนั้น Maven จะค้นหาและดาวน์โหลดการพึ่งพาที่จำเป็น ในตอนท้าย คุณควรจะได้สิ่งนี้: Spring for lazy people รากฐาน แนวคิดพื้นฐาน และตัวอย่างพร้อมโค้ด ตอนที่ 2 - 2ในหน้าต่างด้านซ้าย คุณจะเห็นโครงสร้างโครงการพร้อมแพ็คเกจและMainคลาส หน้าต่างตรงกลางแสดงว่า pom.xml ค้นหาฉันอย่างไร ฉันยังเพิ่มคุณสมบัติส่วนไป ส่วนนี้จะบอก Maven ว่าฉันใช้ Java เวอร์ชันใดในไฟล์ต้นฉบับและเวอร์ชันใดที่จะคอมไพล์ นี่เป็นเพียงเพื่อไม่ให้ IDEA เตือนฉันว่าฉันใช้ Java เวอร์ชันเก่า นี่เป็นทางเลือก :) หน้าต่างด้านขวาทำให้ชัดเจนว่าแม้ว่าเราจะเชื่อมต่อโมดูลบริบทสปริงเท่านั้น แต่จะดึงโมดูลสปริงคอร์สปริงบีนสปริง aop และสปริงนิพจน์โดยอัตโนมัติ เราสามารถเชื่อมต่อแต่ละโมดูลแยกกัน โดยเขียนการพึ่งพาสำหรับแต่ละโมดูลด้วยเวอร์ชันที่ชัดเจนในไฟล์ pom.xml แต่ตอนนี้เราพอใจกับสิ่งที่เป็นอยู่ ตอนนี้สร้าง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 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());
}
ขั้นแรก เราสร้างคอนเท็กซ์อ็อบเจกต์ โดยบอกคอนสตรัคเตอร์ว่าควรค้นหาแพ็คเกจใดในการค้นหาบีน กล่าวอีกนัยหนึ่ง Spring จะผ่านแพ็คเกจนี้และพยายามค้นหาคลาสที่มีคำอธิบายประกอบพิเศษซึ่งระบุว่าเป็นถั่ว จากนั้นจะสร้างวัตถุของคลาสเหล่านี้และวางไว้ในบริบท หลังจากนั้นเราก็ได้แมวจากบริบทนี้ เราเรียกวัตถุบริบทเพื่อให้ถั่ว (วัตถุ) แก่เรา ซึ่งระบุคลาสของวัตถุที่เราต้องการ (อย่างไรก็ตาม เรายังสามารถระบุอินเทอร์เฟซ ไม่ใช่แค่คลาส) หลังจากนั้น Spring จะส่งคืนวัตถุของคลาสที่ร้องขอ ซึ่งเราจะบันทึกไว้ในตัวแปร ต่อไป เราขอให้สปริงหาถั่วที่เรียกว่า "สุนัข" ให้เรา เมื่อสปริงสร้างไฟล์Dogวัตถุจะให้ชื่อมาตรฐานแก่วัตถุ (เว้นแต่ว่า bean ที่สร้างขึ้นได้รับการกำหนดชื่ออย่างชัดเจน) ซึ่งเป็นชื่อคลาส แต่ใช้อักษรตัวพิมพ์เล็กเริ่มต้น ในกรณีนี้ คลาสของเราเรียกว่าDogดังนั้นชื่อ bean จึงเป็น "dog" หากเราต้องการBufferedReaderวัตถุที่นั่น Spring จะตั้งชื่อว่า "bufferedReader" และเนื่องจาก Java ไม่สามารถแน่ใจได้ 100% ว่าเราต้องการคลาสใด จึงส่งคืนอ็Objectอบเจกต์ ซึ่งเราจะแปลงเป็นประเภทที่ต้องการด้วยตนเอง เช่นDog. ตัวเลือกที่ระบุคลาสอย่างชัดเจนนั้นสะดวกกว่า ตัวเลือกที่สามคือการรับ bean ตามชื่อคลาสและตามชื่อ bean เป็นไปได้ว่าบริบทอาจมีหลายถั่วในคลาสเดียว เพื่อระบุถั่วที่เราต้องการ เราระบุชื่อของมัน เนื่องจากเราระบุคลาสอย่างชัดเจนที่นี่ เราจึงไม่ต้องแคสต์อีกต่อไป สำคัญ!หาก Spring พบ bean หลายตัวที่ตรงกับความต้องการของเรา ก็จะไม่สามารถระบุได้ว่าจะให้ bean ตัวไหนแก่เรา ดังนั้น Spring จะส่งข้อยกเว้น ดังนั้น เพื่อหลีกเลี่ยงสถานการณ์นี้ คุณควรพยายามระบุให้เฉพาะเจาะจงมากที่สุดเท่าที่จะเป็นไปได้ในการบอก Spring ว่าคุณต้องการถั่วชนิดใด หาก Spring ค้นหาบริบทและไม่พบถั่วเดียวที่ตรงกับข้อกำหนดของเรา ก็จะเกิดข้อยกเว้นเช่นกัน สุดท้าย เราเพียงแสดงชื่อสัตว์ของเราเพื่อตรวจสอบว่าเราได้รับสิ่งของที่ต้องการจริงๆ แต่ถ้าเรารันโปรแกรมตอนนี้ เราจะเห็นว่า Spring ไม่มีความสุข — มันไม่สามารถหาสัตว์ที่เราต้องการได้ในบริบทของมัน นี่เป็นเพราะมันไม่ได้สร้างถั่วเหล่านี้ อย่างที่ฉันได้กล่าวไปก่อนหน้านี้ เมื่อ Spring สแกนคลาส มันจะมองหาคำอธิบายประกอบของ Spring ของตัวเอง และถ้า Spring ไม่พบคำอธิบายประกอบเหล่านี้ จากนั้นมันไม่คิดว่าคลาสเหล่านี้สอดคล้องกับบีนที่ต้องสร้าง การแก้ไขปัญหานี้เพียงแค่ต้องเพิ่ม@Componentคำอธิบายประกอบหน้าสัตว์แต่ละประเภทของเรา 

@Component
public class Cat {
	private String name = "Oscar";
	...
}
แต่มีมากขึ้น หากเราต้องบอก Spring อย่างชัดเจนว่า bean สำหรับคลาสนี้ควรมีชื่อเฉพาะ เราจะระบุชื่อในวงเล็บหลังคำอธิบายประกอบ ตัวอย่างเช่น หากต้องการบอก Spring ให้ตั้งชื่อ " parrot-polly" ให้กับ parrot bean ซึ่งเป็นชื่อที่เราจะใช้เรียกนกแก้วนี้ในmainวิธีการนี้ เราควรทำสิ่งนี้: 

@Component("parrot-polly")
public class Parrot {
	private String name = "Polly";
	...
}
นี่คือจุดรวมของ การกำหนด ค่าอัตโนมัติ คุณเขียนคลาสของคุณ ทำเครื่องหมายด้วยคำอธิบายประกอบที่จำเป็น และบอก Spring ถึงแพ็คเกจที่มีคลาสของคุณ นี่คือแพ็คเกจที่เฟรมเวิร์กจะทำงานเพื่อค้นหาคำอธิบายประกอบและสร้างวัตถุของคลาสเหล่านี้ อย่างไรก็ตาม Spring ไม่เพียงแต่มองหา@Componentคำอธิบายประกอบเท่านั้น แต่ยังมองหาคำอธิบายประกอบอื่นๆ ทั้งหมดที่สืบทอดสิ่งนี้ด้วย ตัวอย่างเช่น , @Controller, @RestController, @Service, @Repositoryและอื่นๆ ซึ่งเราจะแนะนำในบทความต่อๆ ไป ตอนนี้เราจะพยายามทำสิ่งเดียวกันโดยใช้Java -based configuration ในการเริ่มต้น ให้ลบ@Componentคำอธิบายประกอบจากชั้นเรียนของเรา เพื่อทำให้สิ่งต่าง ๆ ท้าทายมากขึ้น ลองจินตนาการว่าเราไม่ได้เขียนคลาสเหล่านี้ ดังนั้นเราจึงไม่สามารถแก้ไขได้ง่าย ๆ ซึ่งหมายความว่าเราไม่สามารถเพิ่มคำอธิบายประกอบได้ มันเหมือนกับว่าคลาสเหล่านี้บรรจุอยู่ในห้องสมุดบางแห่ง ในกรณีนี้ เราจะแก้ไขคลาสเหล่านี้เพื่อให้ Spring จำคลาสเหล่านี้ไม่ได้ แต่เราต้องการวัตถุของคลาสเหล่านี้! ที่นี่เราต้องการการกำหนดค่าตาม Java เพื่อสร้างวัตถุ ในการเริ่มต้น ให้สร้างแพ็คเกจที่มีชื่อ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("en.codegym.info.fatfaggy.animals.configs");
ในกรณีนี้ Spring จะตรวจสอบแพ็คเกจและค้นหาคลาสทั้งหมดที่มี@Configurationคำอธิบายประกอบ และถ้าเรามีโปรแกรมขนาดใหญ่จริง ๆ ที่การกำหนดค่าแบ่งออกเป็นแพ็คเกจต่าง ๆ เราก็เพียงแค่ระบุรายชื่อแพ็คเกจที่มีการกำหนดค่าด้วยเครื่องหมายจุลภาคคั่นด้วย: 

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");
หรือชื่อของแพ็คเกจที่ใช้ร่วมกันทั้งหมด: 

ApplicationContext context =
	new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals");
คุณสามารถทำได้ตามที่คุณต้องการ แต่สำหรับฉันแล้วดูเหมือนว่าตัวเลือกแรกซึ่งระบุคลาสที่มีการกำหนดค่าจะเหมาะกับโปรแกรมของเรามากที่สุด เมื่อสร้างบริบท Spring จะมองหาคลาสที่มี@Configurationเครื่องหมายกำกับ และจะสร้างออบเจกต์ของคลาสเหล่านี้เอง มันพยายามเรียกเมธอดที่มี@Beanคำอธิบายประกอบ ซึ่งหมายความว่าเมธอดเหล่านี้ส่งคืนถั่ว (วัตถุ) ที่สปริงจะเพิ่มในบริบท และตอนนี้เราจะสร้าง bean สำหรับแมว สุนัข และนกแก้วในชั้นเรียนของเราด้วยการกำหนดค่าตาม Java มันค่อนข้างง่ายที่จะทำ: 

@Bean
public Cat getCat() {
	return new Cat();
}
ที่นี่เราสร้างแมวของเราด้วยตนเองและมอบให้ Spring ซึ่งจะเก็บวัตถุของเราไว้ในบริบทของมัน เนื่องจากเราไม่ได้ตั้งชื่อให้กับ bean ของเราอย่างชัดเจน Spring จึงตั้งชื่อให้เหมือนกับชื่อเมธอด ในกรณีของเรา ถั่วแมวจะเรียกว่า " getCat" แต่เนื่องจากเราใช้คลาส ไม่ใช่ชื่อ เพื่อให้ได้ cat bean ในเมธอดmainชื่อของ bean จึงไม่สำคัญสำหรับเรา ในทำนองเดียวกัน ให้สร้าง dog bean โดยจำไว้ว่า Spring จะตั้งชื่อเมธอดให้กับ bean ในการตั้งชื่อ Parrot bean ของเราอย่างชัดเจน เราเพียงระบุชื่อในวงเล็บหลัง@Beanคำอธิบายประกอบ: 

@Bean("parrot-polly")
public Object weNeedMoreParrots() {
	return new Parrot();
}
อย่างที่คุณเห็น ที่นี่ฉันระบุObjectประเภทการคืนสินค้าและตั้งชื่อเมธอดตามอำเภอใจ การดำเนินการนี้ไม่มีผลกับชื่อถั่ว เนื่องจากเราได้ระบุชื่อไว้ที่นี่อย่างชัดเจน ถึงกระนั้นก็เป็นการดีกว่าที่จะระบุค่าส่งคืนและชื่อเมธอดที่มีความหมายมากหรือน้อย ทำสิ่งนี้หากไม่มีเหตุผลอื่นนอกจากทำประโยชน์ให้ตัวเองเมื่อคุณเปิดโครงการอีกครั้งในหนึ่งปี :) ตอนนี้ให้พิจารณาสถานการณ์ที่ เราต้องการหนึ่งถั่ว เพื่อสร้างอีกถั่ว ตัวอย่างเช่น สมมติว่าเราต้องการให้ชื่อแมวใน cat bean เป็นชื่อนกแก้วบวกกับสตริง "-killer" ไม่มีปัญหา! 

@Bean
public Cat getCat(Parrot parrot) {
	Cat cat = new Cat();
	cat.setName(parrot.getName() + "-killer");
	return cat;
}
ที่นี่ Spring จะเห็นว่าในการสร้าง bean นี้ เฟรมเวิร์กจำเป็นต้องส่งผ่าน parrot bean ที่สร้างไว้ก่อนหน้านี้ ดังนั้น มันจะจัดการการเรียกเมธอดที่จำเป็น: ขั้นแรก เมธอดสร้างนกแก้วจะถูกเรียก จากนั้นเฟรมเวิร์กจะส่งนกแก้วตัวใหม่ไปยังเมธอดสร้างแมว นี่คือที่มาของการฉีดพึ่งพา: สปริงเองส่งถั่วนกแก้วที่จำเป็นไปยังวิธีการของเรา หาก IDEA ไม่พอใจเกี่ยวกับparrotตัวแปร อย่าลืมเปลี่ยนประเภทการส่งคืนของวิธีการสร้างนกแก้วจากObjectเป็น Parrotนอกจากนี้ การกำหนดค่าบน Java ยังให้คุณรันโค้ด Java ใดๆ ก็ได้ในวิธีการสร้างถั่วของคุณ คุณสามารถทำอะไรก็ได้จริงๆ: สร้างออบเจกต์เสริมอื่นๆ เรียกใช้เมธอดอื่นๆ แม้กระทั่งวิธีที่ไม่ได้ทำเครื่องหมายด้วยคำอธิบายประกอบสปริง สร้างลูป เงื่อนไขบูลีน — อะไรก็ตามที่อยู่ในใจ! ทั้งหมดนี้ไม่สามารถทำได้ด้วยการกำหนดค่าอัตโนมัติ และแม้แต่การกำหนดค่า XML ที่น้อยกว่านั้น ทีนี้ลองมาพิจารณาปัญหาที่สนุกขึ้นอีกสักหน่อย ความหลากหลายและอินเทอร์เฟซ :) เราจะสร้างWeekDayอินเทอร์เฟซและสร้าง 7 คลาสที่ใช้อินเทอร์เฟซนี้: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday. เราจะให้String getWeekDayName()วิธีการแก่อินเทอร์เฟซซึ่งจะส่งคืนชื่อวันในสัปดาห์สำหรับชั้นเรียนที่เกี่ยวข้อง กล่าวอีกนัยหนึ่งMondayชั้นจะกลับมา "Monday" ฯลฯ เมื่อเริ่มต้นแอปพลิเคชัน สมมติว่างานของเราคือใส่ bean ที่ตรงกับวันปัจจุบันของสัปดาห์ลงในบริบท ไม่ใช่ bean สำหรับทุกคลาสที่ใช้อินเทอร์เฟซ — เฉพาะ 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("Today is " + weekDay.getWeekDayName() + "!");
สำหรับฉัน โปรแกรมบอกฉันว่าเป็นวันอาทิตย์ :) ฉันมั่นใจว่าถ้าฉันรันโปรแกรมในวันพรุ่งนี้ บริบทจะมีออบเจกต์ที่แตกต่างไปจากเดิมอย่างสิ้นเชิง โปรดทราบว่าเราได้รับ bean เพียงแค่ใช้อินเทอร์เฟซcontext.getBean(WeekDay.class): Spring จะค้นหาบริบทสำหรับ bean ที่ใช้อินเทอร์เฟซ และจะส่งคืน จากนั้นปรากฎว่าWeekDayตัวแปรของเราลงเอยด้วยวัตถุวันอาทิตย์ และแนวคิดที่คุ้นเคยของความหลากหลายจะถูกนำไปใช้เมื่อเราทำงานกับตัวแปรนี้ :) ต่อไปนี้เป็นคำศัพท์สองสามคำเกี่ยวกับแนวทางการรวมซึ่ง Spring บางตัวสร้างถั่วโดยอัตโนมัติ บางส่วนโดยการสแกนแพ็คเกจสำหรับคลาสที่มี@Componentคำอธิบายประกอบ และอื่นๆ โดยการกำหนดค่าบน Java เมื่อเราพิจารณาเรื่องนี้ เราจะกลับไปใช้เวอร์ชันดั้งเดิมโดยที่Cat, Dog, และParrotชั้นเรียนถูกทำเครื่องหมายด้วย@Componentคำอธิบายประกอบ สมมติว่าเราต้องการสร้างถั่วสำหรับสัตว์ของเราโดยให้ Spring สแกนแพ็คเกจโดยอัตโนมัติแต่entitiesเราต้องการสร้างถั่วด้วยวันในสัปดาห์เหมือนที่เราเพิ่งทำ สิ่งที่คุณต้องทำคือเพิ่ม@ComponentScanคำอธิบายประกอบที่ระดับของMyConfigคลาส ซึ่งเราระบุไว้เมื่อสร้างบริบทในmain()และระบุในวงเล็บถึงแพ็คเกจที่ต้องสแกนและสร้างบีนของคลาสที่จำเป็นโดยอัตโนมัติ: 

@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();
		}
	}
}
เมื่อสร้างบริบท Spring จะเห็นว่าจำเป็นต้องประมวลผลMyConfigคลาส เข้าสู่คลาสและเห็นว่าจำเป็นต้องสแกนen.codegym.info.fatfaggy.animals.entitiesแพ็คเกจ " " และสร้างบีนของคลาสเหล่านั้น หลังจากนั้นจึงรันเมธอดMyConfigของคลาสgetDay()และเพิ่มWeekDayบีนในบริบท ในmain()วิธีการนี้ ตอนนี้เราสามารถเข้าถึงถั่วทั้งหมดที่เราต้องการได้ ทั้งวัตถุที่เป็นสัตว์และถั่วที่มีวันในสัปดาห์ หากคุณต้องการให้ Spring เลือกไฟล์คอนฟิกูเรชัน XML ด้วย คุณสามารถค้นหาเว็บของคุณเองเพื่อค้นหาคำอธิบาย :) สรุป:
  • ลองใช้การกำหนดค่าอัตโนมัติ
  • ระหว่างการกำหนดค่าอัตโนมัติ ให้ระบุชื่อแพ็กเกจที่มีคลาสซึ่งบีนจำเป็นต้องสร้าง
  • คลาสเหล่านี้ถูกทำเครื่องหมายด้วย@Componentคำอธิบายประกอบ
  • Spring ดำเนินการผ่านคลาสเหล่านี้ทั้งหมด สร้างออบเจกต์ และใส่ไว้ในบริบท
  • หากการกำหนดค่าอัตโนมัติไม่เหมาะกับเราด้วยเหตุผลบางประการ เราจะใช้การกำหนดค่าตาม Java
  • ในกรณีนี้ เราสร้างคลาส Java ธรรมดาที่มีเมธอดส่งคืนวัตถุที่เราต้องการ เราทำเครื่องหมายคลาสนี้ด้วย@Configurationคำอธิบายประกอบหากเราจะสแกนทั้งแพ็คเกจแทนที่จะระบุคลาสเฉพาะด้วยการกำหนดค่าเมื่อสร้างบริบท
  • เมธอดของคลาสนี้ที่ส่งคืน bean จะถูกทำเครื่องหมายด้วย@Beanคำอธิบายประกอบ
    • หากเราต้องการเปิดใช้งานการสแกนอัตโนมัติเมื่อใช้การกำหนดค่าตาม Java เราจะใช้ @ComponentScanคำอธิบายประกอบ
หากบทความนี้สร้างความสับสนอย่างมาก ให้ลองอ่านในอีกสองสามวัน หรือถ้าคุณอยู่ในระดับต้นๆ ของ CodeGym มันอาจจะเร็วไปหน่อยสำหรับคุณที่จะเรียน Spring คุณสามารถกลับมาที่บทความนี้ได้ในภายหลังเมื่อคุณรู้สึกมั่นใจในทักษะการเขียนโปรแกรม Java ของคุณมากขึ้น หากทุกอย่างชัดเจน คุณสามารถลองแปลงโปรเจ็กต์สัตว์เลี้ยงของคุณเป็น Spring ได้ :) หากบางสิ่งชัดเจน แต่อย่างอื่นไม่เป็นเช่นนั้น โปรดแสดงความคิดเห็น :) แจ้งให้เราทราบข้อเสนอแนะและคำวิจารณ์ของคุณ หากฉันผิดพลาด ที่ไหนสักแห่งหรือเขียนเรื่องไร้สาระ :) ในบทความหน้า เราจะเจาะลึกเกี่ยวกับspring-web-mvcและสร้างเว็บแอปพลิเคชันอย่างง่ายโดยใช้ Spring