आळशी लोकांसाठी वसंत ऋतु फाउंडेशन, मूलभूत संकल्पना आणि कोडसह उदाहरणे. भाग 2

मागील लेखात , स्प्रिंग म्हणजे काय आणि बीन्स आणि संदर्भ काय आहेत हे मी थोडक्यात स्पष्ट केले. आता ते वापरून पाहण्याची वेळ आली आहे. मी ते IntelliJ IDEA Enterprise Edition वापरून करणार आहे. परंतु माझी सर्व उदाहरणे विनामूल्य IntelliJ IDEA समुदाय आवृत्तीमध्ये देखील कार्य करतात. स्क्रीनशॉट्समध्ये, जर तुम्हाला दिसले की माझ्याकडे काही विंडो आहे जी तुमच्याकडे नाही, काळजी करू नका — या प्रकल्पासाठी ते महत्त्वाचे नाही :) प्रथम, एक रिक्त Maven प्रकल्प तयार करा. हे कसे करायचे ते मी या दुव्यावरील लेखात दाखवले . " आमच्या मॅवेन प्रोजेक्टला वेब प्रोजेक्टमध्ये रूपांतरित करण्याची वेळ आली आहे " या शब्दांपर्यंत वाचा . — त्यानंतर, लेख वेब प्रोजेक्ट कसा बनवायचा हे दर्शवितो, परंतु आम्हाला आत्ता त्याची गरज नाही. src/main/java मध्येफोल्डर, एक पॅकेज तयार करा (माझ्या बाबतीत, मी त्याला " म्हटले आहे en.codegym.info.fatfaggy.animals. तुम्हाला हवे ते कॉल करू शकता. फक्त माझ्या पॅकेजचे नाव तुमच्या पॅकेजच्या नावाने सर्व योग्य ठिकाणी बदलण्यास विसरू नका. आता वर्ग तयार करा Mainआणि एक जोडा पद्धत

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

त्यानंतर, pom.xml फाईल उघडा आणि dependenciesविभाग जोडा. आता Maven रेपॉजिटरी वर जा आणि नवीनतम स्थिर आवृत्तीसाठी स्प्रिंग संदर्भ शोधा. आम्हाला जे आढळले ते विभागात ठेवा dependencies. मी या इतर CodeGym लेखात या प्रक्रियेचे अधिक तपशीलवार वर्णन केले आहे (" Maven मधील अवलंबन कनेक्ट करणे " शीर्षक असलेला विभाग पहा ). मग मावेन स्वतः आवश्यक अवलंबित्व शोधेल आणि डाउनलोड करेल. सरतेशेवटी, तुम्हाला असे काहीतरी मिळाले पाहिजे: डावीकडील विंडोमध्ये, तुम्ही पॅकेज आणि वर्गासह प्रकल्पाची रचना पाहू शकता Main. मधली विंडो pom.xml मला कशी दिसते ते दाखवते. मी एक गुणधर्म देखील जोडलेत्यावर विभाग. हा विभाग मावेनला सांगते की मी माझ्या स्त्रोत फाइल्समध्ये Java ची कोणती आवृत्ती वापरत आहे आणि कोणती आवृत्ती संकलित करायची आहे. हे फक्त यासाठी आहे की मी Java ची जुनी आवृत्ती वापरत असल्याचे IDEA मला चेतावणी देत ​​नाही. हे ऐच्छिक आहे :) उजव्या विंडोने हे स्पष्ट केले आहे की आम्ही फक्त स्प्रिंग-कॉन्टेक्स्ट मॉड्यूल कनेक्ट केले असले तरी, ते स्प्रिंग-कोर, स्प्रिंग-बीन्स, स्प्रिंग-एओपी आणि स्प्रिंग-एक्सप्रेशन मॉड्यूल्समध्ये आपोआप खेचले जाते. आम्ही प्रत्येक मॉड्यूल स्वतंत्रपणे कनेक्ट करू शकलो असतो, 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तेथे एखाद्या वस्तूची आवश्यकता असेल, तर स्प्रिंग त्याला "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, आणि बरेच काही, जे आम्ही भविष्यातील लेखांमध्ये सादर करू. आता आपण Java-आधारित कॉन्फिगरेशन वापरून तेच करण्याचा प्रयत्न करू . प्रारंभ करण्यासाठी, काढा@Componentआमच्या वर्गातील भाष्ये. गोष्टी अधिक आव्हानात्मक बनवण्यासाठी, कल्पना करा की आम्ही हे वर्ग लिहिलेले नाहीत, त्यामुळे आम्ही त्यांना सहजपणे सुधारू शकत नाही, याचा अर्थ आम्ही भाष्ये जोडू शकत नाही. असे आहे की हे वर्ग काही लायब्ररीमध्ये पॅकेज केलेले आहेत. या प्रकरणात, आमच्यासाठी हे वर्ग संपादित करण्याचा कोणताही मार्ग नाही जेणेकरून ते स्प्रिंगद्वारे ओळखले जातील. पण आम्हाला या वर्गांच्या वस्तूंची गरज आहे! येथे आपल्याला ऑब्जेक्ट्स तयार करण्यासाठी Java-आधारित कॉन्फिगरेशन आवश्यक आहे. प्रारंभ करण्यासाठी, सारखे नाव असलेले पॅकेज तयार करा configs. या पॅकेजमध्ये, एक सामान्य Java क्लास तयार करा, जसे काहीतरी 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;
}

येथे स्प्रिंग दिसेल की हे बीन तयार करण्यासाठी, फ्रेमवर्क पूर्वी तयार केलेल्या पोपट बीनमध्ये जाणे आवश्यक आहे. त्यानुसार, ते मेथड कॉल्सची आवश्यक साखळी व्यवस्था करेल: प्रथम, पोपट तयार करण्याची पद्धत कॉल केली जाते आणि नंतर फ्रेमवर्क नवीन पोपटाला मांजर तयार करण्याच्या पद्धतीकडे पाठवते. अवलंबित्व इंजेक्शन कार्यात येते ते येथे आहे : स्प्रिंग स्वतः आवश्यक पोपट बीन आमच्या पद्धतीत पास करते. जर IDEA व्हेरिएबलबद्दल नाराज असेल parrot, तर पोपट तयार करण्याच्या पद्धतीचा रिटर्न प्रकार वरून बदलायला विसरू Objectनका Parrot. याव्यतिरिक्त, Java-आधारित कॉन्फिगरेशन तुम्हाला पूर्णपणे कोणताही Java कोड चालवू देतेतुमच्या बीन तयार करण्याच्या पद्धतींमध्ये. तुम्ही खरोखर काहीही करू शकता: इतर सहाय्यक वस्तू तयार करा, इतर कोणत्याही पद्धती कॉल करा, अगदी स्प्रिंग एनोटेशनसह चिन्हांकित नसलेल्या, लूप तयार करा, बुलियन परिस्थिती — जे काही मनात येईल ते! हे सर्व स्वयंचलित कॉन्फिगरेशनसह शक्य नाही, आणि अगदी कमी 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आहेत
• वसंत ऋतु या सर्व वर्गांमधून चालते, वस्तू तयार करते आणि त्यांना संदर्भात ठेवते;
• काही कारणास्तव स्वयंचलित कॉन्फिगरेशन आम्हाला अनुकूल नसल्यास, आम्ही Java-आधारित कॉन्फिगरेशन वापरतो
• या प्रकरणात, आम्ही एक सामान्य Java वर्ग तयार करतो ज्याच्या पद्धती आम्हाला आवश्यक असलेल्या वस्तू परत करतात. @Configurationसंदर्भ तयार करताना कॉन्फिगरेशनसह विशिष्ट वर्ग सूचित करण्याऐवजी आम्ही संपूर्ण पॅकेज स्कॅन करणार असल्यास आम्ही हा वर्ग भाष्यासह चिन्हांकित करतो
• बीन्स परत करणाऱ्या या वर्गाच्या पद्धती भाष्याने चिन्हांकित केल्या @Beanआहेत
Java-आधारित कॉन्फिगरेशन वापरताना आम्हाला स्वयंचलित स्कॅनिंग सक्षम करायचे असल्यास, आम्ही @ComponentScanभाष्य वापरतो.

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