సోమరి ప్రజల కోసం స్ప్రింగ్ ఫౌండేషన్, ప్రాథమిక భావనలు మరియు కోడ్‌తో ఉదాహరణలు. పార్ట్ 2

మునుపటి వ్యాసంలో , వసంతం అంటే ఏమిటి మరియు బీన్స్ మరియు సందర్భం ఏమిటో నేను క్లుప్తంగా వివరించాను. ఇప్పుడు దీనిని ప్రయత్నించడానికి సమయం ఆసన్నమైంది. నేను IntelliJ IDEA ఎంటర్‌ప్రైజ్ ఎడిషన్‌ని ఉపయోగించి దీన్ని చేయబోతున్నాను. కానీ నా ఉదాహరణలన్నీ ఉచిత IntelliJ IDEA కమ్యూనిటీ ఎడిషన్‌లో కూడా పని చేయాలి. స్క్రీన్‌షాట్‌లలో, మీ వద్ద లేని విండో నా దగ్గర ఉందని మీరు చూస్తే, చింతించకండి — ఈ ప్రాజెక్ట్‌కి ఇది ముఖ్యం కాదు :) ముందుగా, ఖాళీ మావెన్ ప్రాజెక్ట్‌ను సృష్టించండి. ఈ లింక్‌లోని వ్యాసంలో దీన్ని ఎలా చేయాలో నేను చూపించాను . " మా మావెన్ ప్రాజెక్ట్‌ను వెబ్ ప్రాజెక్ట్‌గా మార్చడానికి ఇది సమయం. " - ఆ తర్వాత, వెబ్ ప్రాజెక్ట్‌ను ఎలా తయారు చేయాలో కథనం చూపిస్తుంది, కానీ ప్రస్తుతం మాకు అది అవసరం లేదు. src/main/java లోఫోల్డర్, ఒక ప్యాకేజీని సృష్టించండి (నా విషయంలో, నేను దీనిని " అని పిలిచాను en.codegym.info.fatfaggy.animals. మీరు దానిని మీకు ఏది కావాలంటే అది కాల్ చేయవచ్చు. నా ప్యాకేజీ పేరును సరైన అన్ని ప్రదేశాలలో మీ ప్యాకేజీ పేరుతో భర్తీ చేయడం మర్చిపోవద్దు. ఇప్పుడు తరగతిని సృష్టించి Main, జోడించండి పద్ధతి

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

ఆ తర్వాత, pom.xml ఫైల్‌ని తెరిచి, dependenciesవిభాగాన్ని జోడించండి. ఇప్పుడు మావెన్ రిపోజిటరీకి వెళ్లి తాజా స్థిరమైన వెర్షన్ కోసం స్ప్రింగ్ సందర్భాన్ని కనుగొనండి . మేము కనుగొన్న వాటిని విభాగంలో ఉంచండి dependencies. నేను ఈ ఇతర కోడ్‌జిమ్ కథనంలో ఈ ప్రక్రియను మరింత వివరంగా వివరించాను (" మావెన్‌లో డిపెండెన్సీలను కనెక్ట్ చేయడం " అనే విభాగాన్ని చూడండి ). అప్పుడు మావెన్ స్వయంగా అవసరమైన డిపెండెన్సీలను కనుగొని డౌన్‌లోడ్ చేస్తుంది. చివరికి, మీరు ఇలాంటివి పొందాలి: ఎడమ వైపున ఉన్న విండోలో, మీరు ప్యాకేజీ మరియు తరగతితో ప్రాజెక్ట్ నిర్మాణాన్ని చూడవచ్చు 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());
}

మొదట, మేము బీన్స్‌ను కనుగొనడానికి ఏ ప్యాకేజీని చూడాలో కన్స్ట్రక్టర్‌కు తెలియజేస్తూ, సందర్భోచిత వస్తువును సృష్టిస్తాము. మరో మాటలో చెప్పాలంటే, స్ప్రింగ్ ఈ ప్యాకేజీ ద్వారా వెళుతుంది మరియు అవి బీన్స్ అని సూచించే ప్రత్యేక ఉల్లేఖనాలతో గుర్తించబడిన తరగతులను కనుగొనడానికి ప్రయత్నిస్తుంది. అప్పుడు అది ఈ తరగతుల వస్తువులను సృష్టిస్తుంది మరియు వాటిని సందర్భంలో ఉంచుతుంది. ఆ తరువాత, మేము ఈ సందర్భం నుండి పిల్లిని పొందుతాము. మనకు కావలసిన వస్తువు యొక్క తరగతిని సూచిస్తూ, బీన్ (ఆబ్జెక్ట్) ఇవ్వమని మేము సందర్భోచిత వస్తువును పిలుస్తాము (మార్గం ద్వారా, మేము తరగతులు మాత్రమే కాకుండా ఇంటర్‌ఫేస్‌లను కూడా పేర్కొనవచ్చు). ఆ తర్వాత, స్ప్రింగ్ అభ్యర్థించిన తరగతి యొక్క వస్తువును తిరిగి ఇస్తుంది, దానిని మనం వేరియబుల్‌లో సేవ్ చేస్తాము. తర్వాత, "కుక్క" అనే బీన్‌ను మాకు తీసుకురావాలని మేము స్ప్రింగ్‌ని అడుగుతాము. స్ప్రింగ్ సృష్టించినప్పుడు aDogఆబ్జెక్ట్, ఇది ఆబ్జెక్ట్‌కు ప్రామాణిక పేరును ఇస్తుంది (సృష్టించిన బీన్‌కు స్పష్టంగా పేరు కేటాయించబడితే తప్ప), ఇది తరగతి పేరు కానీ ప్రారంభ చిన్న అక్షరంతో ఉంటుంది. ఈ సందర్భంలో, మా తరగతిని పిలుస్తారు 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, మరియు మరిన్ని, మేము భవిష్యత్ కథనాలలో పరిచయం చేస్తాము. ఇప్పుడు మనం Java-ఆధారిత కాన్ఫిగరేషన్‌ని ఉపయోగించి అదే పనిని చేయడానికి ప్రయత్నిస్తాము . ప్రారంభించడానికి, తీసివేయండి@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స్థాయిలో ఉల్లేఖనాన్ని జోడించడం మరియు స్కాన్ చేయవలసిన ప్యాకేజీని కుండలీకరణాల్లో సూచించడం మరియు అవసరమైన తరగతుల బీన్స్‌ను స్వయంచాలకంగా సృష్టించడం మాత్రమే మీరు చేయాల్సిందల్లా :MyConfigmain()

@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.

ఈ కథనం పూర్తిగా గందరగోళంగా ఉంటే, రెండు రోజుల్లో దాన్ని చదవడానికి ప్రయత్నించండి. లేదా మీరు కోడ్‌జిమ్ ప్రారంభ స్థాయిలలో ఒకదానిలో ఉన్నట్లయితే, మీరు స్ప్రింగ్‌ని చదవడానికి కొంచెం ముందుగానే ఉండవచ్చు. మీ జావా ప్రోగ్రామింగ్ నైపుణ్యాలపై మీకు మరింత నమ్మకం ఉన్నప్పుడు మీరు ఎప్పుడైనా ఈ కథనానికి కొంచెం తర్వాత తిరిగి రావచ్చు. ప్రతిదీ స్పష్టంగా ఉంటే, మీరు మీ యొక్క కొన్ని పెంపుడు ప్రాజెక్ట్‌లను స్ప్రింగ్‌గా మార్చడానికి ప్రయత్నించవచ్చు :) కొన్ని విషయాలు స్పష్టంగా ఉన్నప్పటికీ మరికొన్ని విషయాలు తెలియకపోతే, దయచేసి వ్యాఖ్యానించండి :) నేను తప్పు చేస్తే, మీ సూచనలు మరియు విమర్శలను నాకు తెలియజేయండి. ఎక్కడో లేదా కొన్ని అర్ధంలేనివి వ్రాసారు :) తరువాతి కథనంలో, మేము స్ప్రింగ్-వెబ్-mvc లోకి అకస్మాత్తుగా డైవ్ చేస్తాము మరియు స్ప్రింగ్‌ని ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను తయారు చేస్తాము.