சோம்பேறிகளுக்கான வசந்தம் அறக்கட்டளை, அடிப்படைக் கருத்துக்கள் மற்றும் குறியீட்டுடன் எடுத்துக்காட்டுகள். பகுதி 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 கட்டுரையில் விரிவாக விவரித்தேன் (" Maven இல் சார்புகளை இணைத்தல் " என்ற தலைப்பைப் பார்க்கவும் ). பின்னர் மேவன் தானே தேவையான சார்புகளைக் கண்டுபிடித்து பதிவிறக்கும். முடிவில், நீங்கள் இதைப் போன்ற ஒன்றைப் பெற வேண்டும்: இடதுபுறத்தில் உள்ள சாளரத்தில், தொகுப்பு மற்றும் Mainவகுப்பைக் கொண்ட திட்ட அமைப்பைக் காணலாம். pom.xml என்னை எப்படித் தேடுகிறது என்பதை நடுச் சாளரம் காட்டுகிறது. நான் ஒரு பண்புகளையும் சேர்த்தேன்அதற்கான பிரிவு. எனது மூலக் கோப்புகளில் ஜாவாவின் எந்தப் பதிப்பைப் பயன்படுத்துகிறேன், எந்தப் பதிப்பைத் தொகுக்க வேண்டும் என்பதை இந்தப் பகுதி மேவனுக்குச் சொல்கிறது. நான் ஜாவாவின் பழைய பதிப்பைப் பயன்படுத்துகிறேன் என்று 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" என்று பெயரிடும். நாம் விரும்பும் வகுப்பை Java 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;
}

இந்த பீனை உருவாக்க, முன்பு உருவாக்கப்பட்ட கிளி பீனில் கட்டமைப்பை கடக்க வேண்டும் என்பதை இங்கே ஸ்பிரிங் பார்க்கும். அதன்படி, இது தேவையான முறை அழைப்புகளின் சங்கிலியை ஏற்பாடு செய்யும்: முதலில், கிளி உருவாக்கும் முறை அழைக்கப்படுகிறது, பின்னர் கட்டமைப்பானது புதிய கிளியை பூனை உருவாக்கும் முறைக்கு அனுப்புகிறது. இங்கே சார்பு ஊசி நடைமுறைக்கு வருகிறது: வசந்தமே எங்கள் முறைக்கு தேவையான கிளி பீனை அனுப்புகிறது. மாறியைப் பற்றி IDEA வருத்தப்பட்டால் , கிளி உருவாக்கும் முறையின் திரும்பும் வகையை இருந்து க்கு 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()முறையில், இப்போது நமக்குத் தேவையான அனைத்து பீன்ஸுக்கும் அணுகல் உள்ளது: விலங்கு பொருட்கள் மற்றும் வாரத்தின் நாளுடன் ஒரு பீன்ஸ். நீங்கள் எப்போதாவது ஸ்பிரிங் சில எக்ஸ்எம்எல் உள்ளமைவு கோப்புகளை எடுக்க வேண்டும் என்றால், உங்கள் சொந்த வலைத் தேடலைச் செய்து விளக்கத்தைக் கண்டறியலாம் :) சுருக்கம்:

• தானியங்கி உள்ளமைவைப் பயன்படுத்த முயற்சிக்கவும்
• தானியங்கு உள்ளமைவின் போது, ​​பீன்ஸ் உருவாக்கப்பட வேண்டிய வகுப்புகளைக் கொண்ட தொகுப்பின் பெயரைக் குறிப்பிடவும்
• @Componentஇந்த வகுப்புகள் சிறுகுறிப்புடன் குறிக்கப்பட்டுள்ளன
• வசந்தம் இந்த அனைத்து வகுப்புகளிலும் ஓடுகிறது, பொருட்களை உருவாக்குகிறது மற்றும் அவற்றை சூழலில் வைக்கிறது;
• சில காரணங்களால் தானியங்கி உள்ளமைவு நமக்குப் பொருந்தவில்லை என்றால், நாங்கள் ஜாவா அடிப்படையிலான உள்ளமைவைப் பயன்படுத்துகிறோம்
• இந்த வழக்கில், நாம் ஒரு சாதாரண ஜாவா வகுப்பை உருவாக்குகிறோம், அதன் முறைகள் நமக்குத் தேவையான பொருட்களைத் திருப்பித் தருகின்றன. @Configurationசூழலை உருவாக்கும் போது உள்ளமைவுடன் ஒரு குறிப்பிட்ட வகுப்பைக் குறிப்பிடுவதற்குப் பதிலாக, முழு தொகுப்பையும் ஸ்கேன் செய்யப் போகிறோம் என்றால், இந்த வகுப்பை சிறுகுறிப்புடன் குறிக்கிறோம்.
• @Beanபீன்ஸ் திரும்பும் இந்த வகுப்பின் முறைகள் சிறுகுறிப்புடன் குறிக்கப்பட்டுள்ளன
ஜாவா அடிப்படையிலான உள்ளமைவைப் பயன்படுத்தும் போது தானியங்கி ஸ்கேனிங்கை இயக்க விரும்பினால், சிறுகுறிப்பைப் பயன்படுத்துகிறோம் @ComponentScan.

இந்தக் கட்டுரை முற்றிலும் குழப்பமாக இருந்தால், ஓரிரு நாட்களில் படித்துப் பாருங்கள். அல்லது நீங்கள் CodeGym இன் ஆரம்ப நிலைகளில் ஒன்றில் இருந்தால், நீங்கள் ஸ்பிரிங் படிப்பது சற்று முன்னதாக இருக்கலாம். உங்கள் ஜாவா நிரலாக்கத் திறன்களில் அதிக நம்பிக்கை இருந்தால், சிறிது நேரம் கழித்து இந்தக் கட்டுரைக்குத் திரும்பலாம். எல்லாம் தெளிவாக இருந்தால், உங்களின் சில செல்லப் பிராஜெக்ட்களை வசந்தமாக மாற்ற முயற்சி செய்யலாம் :) சில விஷயங்கள் தெளிவாக இருந்தாலும் மற்ற விஷயங்கள் இல்லை என்றால், தயவுசெய்து கருத்துத் தெரிவிக்கவும் :) நான் தவறாக இருந்தால், உங்கள் பரிந்துரைகளையும் விமர்சனங்களையும் எனக்குத் தெரியப்படுத்துங்கள். எங்காவது அல்லது சில முட்டாள்தனங்களை எழுதியது :) அடுத்த கட்டுரையில், நாம் திடீரென்று ஸ்பிரிங்-வெப்-எம்விசிக்குள் நுழைந்து , ஸ்பிரிங் பயன்படுத்தி ஒரு எளிய இணைய பயன்பாட்டை உருவாக்குவோம்.