आलसी लोगों के लिए वसंत नींव, बुनियादी अवधारणाएं और कोड के साथ उदाहरण। भाग 2

पिछले लेख में , मैंने संक्षेप में बताया कि स्प्रिंग क्या है और बीन्स और संदर्भ क्या हैं। अब इसे आजमाने का समय आ गया है। मैं इसे IntelliJ IDEA एंटरप्राइज़ संस्करण का उपयोग करके करने जा रहा हूँ। लेकिन मेरे सभी उदाहरण मुफ्त IntelliJ IDEA कम्युनिटी एडिशन में भी काम करने चाहिए। स्क्रीनशॉट में, यदि आप देखते हैं कि मेरे पास कुछ विंडो है जो आपके पास नहीं है, तो चिंता न करें — यह इस प्रोजेक्ट के लिए महत्वपूर्ण नहीं है :) सबसे पहले, एक खाली मावेन प्रोजेक्ट बनाएं। मैंने दिखाया कि इस लिंक पर आलेख में इसे कैसे करें । शब्दों तक पढ़ें " यह हमारे लिए समय है कि हम अपने मावेन प्रोजेक्ट को वेब प्रोजेक्ट में बदलें। " - उसके बाद, लेख दिखाता है कि वेब प्रोजेक्ट कैसे बनाया जाए, लेकिन हमें अभी इसकी आवश्यकता नहीं है। src /main/javaफ़ोल्डर, एक पैकेज बनाएं (मेरे मामले में, मैंने इसे " कहा en.codegym.info.fatfaggy.animals। आप इसे जो चाहें कह सकते हैं। बस मेरे पैकेज के नाम को अपने पैकेज के नाम से सभी सही जगहों पर बदलना न भूलें। अब क्लास बनाएं Mainऔर एक जोड़ें तरीका

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

उसके बाद, pom.xml फ़ाइल खोलें और dependenciesसेक्शन जोड़ें। अब मावेन रिपॉजिटरी में जाएं और नवीनतम स्थिर संस्करण के लिए स्प्रिंग संदर्भ खोजें । dependenciesहम जो पाते हैं उसे अनुभाग में रखें । मैंने इस प्रक्रिया को इस अन्य CodeGym आलेख में अधिक विस्तार से वर्णित किया है (" कनेक्टिंग डिपेंडेंसीज़ इन मावेन " नामक अनुभाग देखें )। तब मावेन स्वयं आवश्यक निर्भरताएँ खोजेगा और डाउनलोड करेगा। अंत में, आपको कुछ इस तरह मिलना चाहिए: बाईं ओर की विंडो में, आप पैकेज और Mainक्लास के साथ प्रोजेक्ट स्ट्रक्चर देख सकते हैं। बीच वाली विंडो दिखाती है कि pom.xml मेरे लिए कैसा दिखता है। मैंने एक गुण भी जोड़ाइसके लिए अनुभाग। यह खंड मावेन को बताता है कि मैं अपनी स्रोत फ़ाइलों में जावा के किस संस्करण का उपयोग कर रहा हूं और किस संस्करण को संकलित करना है। यह सिर्फ इतना है कि आईडीईए ने मुझे चेतावनी नहीं दी है कि मैं जावा के पुराने संस्करण का उपयोग कर रहा हूं। यह वैकल्पिक है :) सही विंडो यह स्पष्ट करती है कि भले ही हम केवल स्प्रिंग-संदर्भ मॉड्यूल से जुड़े हों, यह स्वचालित रूप से स्प्रिंग-कोर, स्प्रिंग-बीन्स, स्प्रिंग-एओपी और स्प्रिंग-एक्सप्रेशन मॉड्यूल में खींच लिया जाता है। हम प्रत्येक मॉड्यूल को अलग से जोड़ सकते थे, प्रत्येक मॉड्यूल के लिए pom.xml फ़ाइल में स्पष्ट संस्करण के साथ एक निर्भरता लिख ​​रहे थे, लेकिन अभी के लिए हम चीजों से खुश हैं जैसे वे हैं। अब entitiesपैकेज बनाएं और उसमें 3 क्लास बनाएं: Cat, Dog, Parrot. आइए प्रत्येक जानवर को एक नाम दें (private String name- आप वहां कुछ मूल्यों को हार्डकोड कर सकते हैं)। गेटर्स/सेटर्स सार्वजनिक हैं। 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());
}

सबसे पहले, हम एक कॉन्टेक्स्ट ऑब्जेक्ट बनाते हैं, कंस्ट्रक्टर को बताते हैं कि बीन्स को खोजने के लिए किस पैकेज में देखना है। दूसरे शब्दों में, वसंत इस पैकेज के माध्यम से जाएगा और विशेष एनोटेशन के साथ चिह्नित कक्षाओं को खोजने का प्रयास करेगा जो इंगित करते हैं कि वे सेम हैं। फिर यह इन वर्गों की वस्तुओं को बनाता है और उन्हें संदर्भ में रखता है। उसके बाद इस प्रसंग से हमें एक बिल्ली प्राप्त होती है। हम संदर्भ वस्तु को हमें एक बीन (ऑब्जेक्ट) देने के लिए कहते हैं, जो हम चाहते हैं कि वस्तु के वर्ग को इंगित करते हैं (वैसे, हम इंटरफेस भी निर्दिष्ट कर सकते हैं, न कि केवल कक्षाएं)। उसके बाद, स्प्रिंग अनुरोधित वर्ग का एक ऑब्जेक्ट लौटाता है, जिसे हम एक चर में सहेजते हैं। अगला, हम वसंत से हमें "कुत्ते" नामक बीन लाने के लिए कहते हैं। जब वसंत एक बनाता हैDogऑब्जेक्ट, यह ऑब्जेक्ट को एक मानक नाम देता है (जब तक कि बनाई गई बीन को स्पष्ट रूप से एक नाम नहीं दिया गया हो), जो कि वर्ग का नाम है, लेकिन प्रारंभिक लोअरकेस अक्षर के साथ। इस मामले में, हमारी कक्षा को बुलाया जाता है Dog, इसलिए बीन का नाम "कुत्ते" होगा। अगर हमें BufferedReaderवहां किसी वस्तु की आवश्यकता होती है, तो स्प्रिंग इसे "बफर्डरीडर" नाम देगा। और क्योंकि जावा 100% निश्चित नहीं हो सकता है कि हम किस वर्ग को चाहते हैं, यह एक वस्तु लौटाता है Object, जिसे हम मैन्युअल रूप से वांछित प्रकार में डालते हैं, अर्थातDog. वह विकल्प जहाँ वर्ग स्पष्ट रूप से इंगित किया गया है, अधिक सुविधाजनक है। तीसरा विकल्प बीन को वर्ग के नाम और बीन के नाम से प्राप्त करना है। यह संभव है कि संदर्भ में एक ही वर्ग की कई फलियाँ हो सकती हैं। हमें जिस विशेष सेम की आवश्यकता है, उसे इंगित करने के लिए, हम उसका नाम इंगित करते हैं। चूंकि हम यहां स्पष्ट रूप से कक्षा को भी इंगित करते हैं, इसलिए अब हमें कास्ट करने की आवश्यकता नहीं है। महत्वपूर्ण!यदि वसंत को कई फलियाँ मिलती हैं जो हमारी आवश्यकताओं से मेल खाती हैं, तो यह निर्धारित नहीं कर सकता कि हमें कौन सी फलियाँ देनी हैं, इसलिए यह एक अपवाद फेंक देगा। तदनुसार, इस स्थिति से बचने के लिए, आपको स्प्रिंग को यह बताने में यथासंभव विशिष्ट होने का प्रयास करना चाहिए कि आपको कौन सी बीन चाहिए। यदि वसंत अपने संदर्भ की खोज करता है और हमारी आवश्यकताओं से मेल खाने वाला एक भी बीन खोजने में विफल रहता है, तो यह एक अपवाद भी फेंक देगा। अंत में, हम केवल यह सत्यापित करने के लिए अपने जानवरों के नाम प्रदर्शित करते हैं कि हमें वास्तव में वे वस्तुएँ मिली हैं जिनकी हमें आवश्यकता है। लेकिन अगर हम अभी प्रोग्राम चलाते हैं, तो हम देखेंगे कि स्प्रिंग नाखुश है - यह उन जानवरों को नहीं ढूंढ सकता है जिनकी हमें इसके संदर्भ में आवश्यकता है। ऐसा इसलिए है क्योंकि इसने इन फलियों को नहीं बनाया है। जैसा कि मैंने पहले कहा था, जब स्प्रिंग कक्षाओं को स्कैन करता है, तो यह अपने स्वयं के स्प्रिंग एनोटेशन की तलाश करता है। और अगर स्प्रिंग को ये एनोटेशन नहीं मिलते हैं, तो यह नहीं है मुझे नहीं लगता कि ये वर्ग बीन्स के अनुरूप हैं जिन्हें इसे बनाने की आवश्यकता है। इसे ठीक करने के लिए केवल जोड़ने की आवश्यकता है@Componentहमारे प्रत्येक पशु वर्ग के सामने एनोटेशन।

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

लेकिन और भी है। यदि हमें स्प्रिंग को स्पष्ट रूप से यह बताने की आवश्यकता है कि इस वर्ग के बीन का एक विशिष्ट नाम होना चाहिए, तो हम एनोटेशन के बाद कोष्ठक में नाम इंगित करते हैं। parrot-pollyउदाहरण के लिए, वसंत को तोते की फलियों को "" नाम देने के लिए कहने के लिए , यह वह नाम है जिसका उपयोग हम इस तोते को mainविधि में प्राप्त करने के लिए करेंगे, हमें कुछ इस तरह करना चाहिए:

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

यह स्वचालित कॉन्फ़िगरेशन का संपूर्ण बिंदु है । आप अपनी कक्षाएं लिखते हैं, उन्हें आवश्यक एनोटेशन के साथ चिह्नित करते हैं, और स्प्रिंग को वह पैकेज बताते हैं जिसमें आपकी कक्षाएं होती हैं। यह वह पैकेज है जिसके माध्यम से एनोटेशन खोजने और इन वर्गों की वस्तुओं को बनाने के लिए फ्रेमवर्क चलेगा। वैसे, स्प्रिंग न केवल @Componentएनोटेशन की तलाश करता है, बल्कि अन्य सभी एनोटेशन भी देखता है जो इसे इनहेरिट करते हैं। उदाहरण के लिए, @Controller, @RestController, @Service, @Repository, और बहुत कुछ, जिसे हम भविष्य के लेखों में पेश करेंगे। अब हम जावा-आधारित कॉन्फ़िगरेशन का उपयोग करके समान कार्य करने का प्रयास करेंगे । आरंभ करने के लिए, को हटा दें@Componentहमारी कक्षाओं से एनोटेशन। चीजों को और अधिक चुनौतीपूर्ण बनाने के लिए, कल्पना करें कि हमने ये कक्षाएं नहीं लिखी हैं, इसलिए हम इन्हें आसानी से संशोधित नहीं कर सकते हैं, जिसका अर्थ है कि हम एनोटेशन नहीं जोड़ सकते हैं। ऐसा लगता है कि इन कक्षाओं को किसी पुस्तकालय में पैक किया गया है। इस मामले में, हमारे पास इन कक्षाओं को संपादित करने का कोई तरीका नहीं है ताकि वे स्प्रिंग द्वारा पहचाने जा सकें। लेकिन हमें इन वर्गों की वस्तुओं की जरूरत है! यहां हमें ऑब्जेक्ट बनाने के लिए जावा-आधारित कॉन्फ़िगरेशन की आवश्यकता है। आरंभ करने के लिए, जैसे नाम के साथ एक पैकेज बनाएँ configs। इस पैकेज में, एक साधारण जावा क्लास बनाएं, कुछ ऐसा MyConfig, और इसे @Configurationएनोटेशन के साथ चिह्नित करें।

@Configuration
public class MyConfig {
}

अब हमें main()संदर्भ बनाने के तरीके को बदलते हुए, विधि को बदलने की जरूरत है। हम या तो स्पष्ट रूप से संकेत कर सकते हैं कि किस वर्ग में हमारा विन्यास है:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class);

यदि हमारे पास कई अलग-अलग वर्ग हैं जो बीन्स बनाते हैं और हम उनमें से कई को एक साथ जोड़ना चाहते हैं, तो हम उन सभी को अल्पविराम से अलग करके इंगित करते हैं:

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

और अगर हमारे पास उनमें से बहुत सारे हैं और हम उन सभी को एक साथ जोड़ना चाहते हैं, तो हम केवल उस पैकेज के नाम का संकेत देते हैं जिसमें वे शामिल हैं:

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

इस मामले में, स्प्रिंग पैकेज के माध्यम से जाएगा और @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");

आप जैसा चाहें वैसा कर सकते हैं, लेकिन मुझे ऐसा लगता है कि पहला विकल्प, जो केवल विन्यास के साथ एक वर्ग को इंगित करता है, हमारे कार्यक्रम के लिए सबसे उपयुक्त होगा। एक संदर्भ बनाते समय, वसंत एनोटेशन के साथ चिह्नित कक्षाओं की तलाश करता है @Configurationऔर इन वर्गों की अपनी वस्तुएं बनाएगा। यह एनोटेशन के साथ चिह्नित विधियों को कॉल करने का प्रयास करता है @Bean, जिसका अर्थ है कि ये विधियां बीन्स (ऑब्जेक्ट्स) लौटाती हैं जो वसंत संदर्भ में जोड़ देगा। और अब हम जावा-आधारित कॉन्फ़िगरेशन के साथ अपनी कक्षा में बिल्ली, कुत्ते और तोते के लिए बीन्स बनाएंगे। यह करना काफी सरल है:

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

यहां हम मैन्युअल रूप से अपनी बिल्ली बनाते हैं और इसे स्प्रिंग को सौंप देते हैं, जो तब हमारी वस्तु को उसके संदर्भ में रखता है। चूंकि हमने अपने बीन को स्पष्ट रूप से कोई नाम नहीं दिया है, स्प्रिंग इसे विधि के नाम के समान नाम देगा। हमारे मामले में, बिल्ली बीन को " getCat" कहा जाएगा। लेकिन क्योंकि हम विधि में कैट बीन प्राप्त करने के लिए नाम का नहीं, वर्ग का उपयोग करते हैं main, बीन का नाम हमारे लिए महत्वपूर्ण नहीं है। इसी तरह, एक डॉग बीन बनाएं, यह ध्यान में रखते हुए कि स्प्रिंग बीन को विधि का नाम देगा। अपने तोते की फलियों को स्पष्ट रूप से नाम देने के लिए, हम केवल एनोटेशन के बाद कोष्ठक में इसका नाम इंगित करते हैं @Bean:

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

जैसा कि आप देख सकते हैं, यहाँ मैंने एक Objectवापसी प्रकार का संकेत दिया और विधि को एक मनमाना नाम दिया। यह बीन के नाम को प्रभावित नहीं करता है, क्योंकि हमने यहां स्पष्ट रूप से नाम निर्दिष्ट किया है। फिर भी, अधिक या कम सार्थक वापसी मान और विधि का नाम इंगित करना बेहतर है। इसे एक वर्ष में परियोजना को फिर से खोलने पर अपने आप को एक एहसान करने के अलावा किसी अन्य कारण से न करें। :) अब उस स्थिति पर विचार करें जहां हमें एक सेम बनाने के लिए एक बीन की आवश्यकता होती है । उदाहरण के लिए, मान लीजिए कि हम चाहते हैं कि कैट बीन में बिल्ली का नाम तोते का नाम और स्ट्रिंग "-किलर" हो। कोई बात नहीं!

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

यहां स्प्रिंग यह देखेगा कि इस बीन को बनाने के लिए, फ्रेमवर्क को पहले बनाए गए पैरट बीन में पास करना होगा। तदनुसार, यह विधि कॉल की आवश्यक श्रृंखला की व्यवस्था करेगा: सबसे पहले, तोता बनाने की विधि को कहा जाता है और फिर रूपरेखा नए तोते को बिल्ली बनाने की विधि में पास करती है। यहां वह जगह है जहां निर्भरता इंजेक्शन खेल में आता है: वसंत ही हमारे तरीके के लिए आवश्यक तोता बीन पास करता है। यदि आईडीईए वेरिएबल के बारे में परेशान हो जाता है , तोता-निर्माण विधि के रिटर्न प्रकार को से में parrotबदलना न भूलें । इसके अलावा, जावा-आधारित कॉन्फ़िगरेशन आपको पूरी तरह से कोई भी जावा कोड चलाने देता हैObjectParrotआपके बीन बनाने के तरीकों में। आप वास्तव में कुछ भी कर सकते हैं: अन्य सहायक वस्तुएं बनाएं, किसी भी अन्य तरीकों को कॉल करें, यहां तक ​​​​कि वे जो स्प्रिंग एनोटेशन के साथ चिह्नित नहीं हैं, लूप बनाएं, बूलियन स्थितियां - जो भी मन में आए! स्वचालित कॉन्फ़िगरेशन के साथ यह सब संभव नहीं है, और XML कॉन्फ़िगरेशन के साथ तो और भी कम। अब आइए एक ऐसी समस्या पर विचार करें जो थोड़ी अधिक मजेदार है। बहुरूपता और इंटरफेस :) हम एक WeekDayइंटरफेस बनाएंगे और इस इंटरफेस को लागू करने वाली 7 कक्षाएं बनाएंगे: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday। हम इंटरफ़ेस को एक विधि देंगे String getWeekDayName(), जो संबंधित वर्ग के लिए सप्ताह के दिन का नाम लौटाएगा। दूसरे शब्दों में, Mondayकक्षा वापस आ जाएगी"Monday", आदि। आवेदन शुरू करने पर, मान लें कि हमारा कार्य सप्ताह के वर्तमान दिन के अनुरूप एक बीन को संदर्भ में रखना है। इंटरफ़ेस को लागू करने वाले सभी वर्गों के लिए बीन्स नहीं - केवल एक बीन जिसकी हमें आवश्यकता है। आप कर सकते 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() + "!");

मेरे लिए, कार्यक्रम मुझे बताता है कि यह रविवार है :) मुझे विश्वास है कि अगर मैं कल कार्यक्रम चलाता हूं, तो संदर्भ में एक पूरी तरह से अलग वस्तु होगी। ध्यान दें कि हम केवल इंटरफ़ेस का उपयोग करके बीन प्राप्त कर रहे हैं: context.getBean(WeekDay.class). स्प्रिंग इंटरफ़ेस को लागू करने वाले बीन के संदर्भ की खोज करेगा और इसे वापस कर देगा। फिर यह पता चलता है कि हमारा WeekDayचर रविवार की वस्तु के साथ समाप्त होता है, और बहुरूपता की परिचित अवधारणा लागू होती है क्योंकि हम इस चर के साथ काम करते हैं। :) अब संयुक्त दृष्टिकोण के बारे में कुछ शब्द , जिसमें कुछ बीन्स स्प्रिंग द्वारा स्वचालित रूप से बनाए जाते हैं, कुछ @Componentएनोटेशन के साथ कक्षाओं के पैकेज को स्कैन करके, और अन्य जावा-आधारित कॉन्फ़िगरेशन द्वारा। जैसा कि हम इस पर विचार करते हैं, हम मूल संस्करण पर लौटेंगे, जहाँ Cat, Dog, औरParrotकक्षाओं को @Componentएनोटेशन के साथ चिह्नित किया गया था। मान लीजिए कि हम अपने जानवरों के लिए बीन्स बनाना चाहते हैं, वसंत स्वचालित रूप से पैकेज को स्कैन करता है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();
		}
	}
}

संदर्भ बनाते समय, स्प्रिंग देखता है कि उसे MyConfigकक्षा को संसाधित करने की आवश्यकता है। यह कक्षा में प्रवेश करता है और देखता है कि इसे en.codegym.info.fatfaggy.animals.entitiesपैकेज को स्कैन करने और उन वर्गों के बीन्स बनाने की आवश्यकता है, जिसके बाद यह MyConfigकक्षा की getDay()विधि को निष्पादित करता है और WeekDayसंदर्भ में एक बीन जोड़ता है। विधि में main(), अब हमारे पास उन सभी बीन्स तक पहुंच है जिनकी हमें आवश्यकता है: पशु वस्तुएं और सप्ताह के दिन के साथ एक बीन। यदि आपको कभी भी स्प्रिंग को कुछ XML कॉन्फ़िगरेशन फ़ाइलें लेने की आवश्यकता होती है, तो आप स्पष्टीकरण खोजने के लिए अपनी स्वयं की वेब खोज कर सकते हैं :) सारांश:

• स्वचालित कॉन्फ़िगरेशन का उपयोग करने का प्रयास करें
• स्वचालित कॉन्फ़िगरेशन के दौरान, उस पैकेज का नाम इंगित करें जिसमें वे वर्ग शामिल हैं जिनकी बीन्स बनाने की आवश्यकता है
• इन वर्गों को @Componentएनोटेशन के साथ चिह्नित किया गया है
• वसंत इन सभी वर्गों से चलता है, वस्तुओं का निर्माण करता है और उन्हें संदर्भ में रखता है;
• यदि किसी कारण से स्वचालित कॉन्फ़िगरेशन हमें सूट नहीं करता है, तो हम जावा-आधारित कॉन्फ़िगरेशन का उपयोग करते हैं
• इस मामले में, हम एक साधारण जावा वर्ग बनाते हैं, जिसके तरीके हमें आवश्यक वस्तुओं को लौटाते हैं। हम इस वर्ग को @Configurationएनोटेशन के साथ चिह्नित करते हैं यदि हम संदर्भ बनाते समय कॉन्फ़िगरेशन के साथ एक विशिष्ट वर्ग को इंगित करने के बजाय पूरे पैकेज को स्कैन करने जा रहे हैं
• इस वर्ग की विधियाँ जो फलियाँ लौटाती हैं, उन्हें @Beanएनोटेशन के साथ चिह्नित किया जाता है
यदि हम जावा-आधारित कॉन्फ़िगरेशन का उपयोग करते समय स्वचालित स्कैनिंग को सक्षम करना चाहते हैं, तो हम @ComponentScanएनोटेशन का उपयोग करते हैं।

यदि यह लेख पूरी तरह से भ्रमित करने वाला रहा है, तो एक दो दिनों में इसे पढ़ने का प्रयास करें। या यदि आप CodeGym के शुरुआती स्तरों में से एक पर हैं, तो आपके लिए स्प्रिंग का अध्ययन करना थोड़ा जल्दी हो सकता है। जब आप अपने जावा प्रोग्रामिंग कौशल में अधिक आत्मविश्वास महसूस करते हैं तो आप हमेशा इस लेख पर थोड़ी देर बाद वापस आ सकते हैं। अगर सब कुछ स्पष्ट है, तो आप अपने कुछ पालतू प्रोजेक्ट को स्प्रिंग में बदलने की कोशिश कर सकते हैं :) अगर कुछ चीजें स्पष्ट हैं लेकिन अन्य चीजें नहीं हैं, तो कृपया एक टिप्पणी छोड़ दें :) मुझे अपने सुझाव और आलोचनाएं बताएं, अगर मैं गलत हो गया कहीं या कुछ बकवास लिखा :) अगले लेख में, हम अचानक स्प्रिंग-वेब-एमवीसी में डुबकी लगाएंगे और स्प्रिंग का उपयोग करके एक सरल वेब एप्लिकेशन बनाएंगे।