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

ఈ కథనంలో, నా కోడ్‌ని ఉపయోగించి 5 నిమిషాల్లో వర్కింగ్ స్ప్రింగ్ ప్రాజెక్ట్‌ను ఎలా అప్‌లోడ్ చేయాలో మరియు రన్నింగ్‌ను ఎలా పొందాలో నేను మీకు చెప్పను. నేను బేసిక్‌లను మాత్రమే వ్రాయబోతున్నాను — మీరు తెలియని మరియు ఇప్పటికీ ప్రాజెక్ట్‌ను సృష్టించే అంశాలు. కానీ ఈ కథనంలో, మీరు ఇంకా ఏమి జరుగుతుందో అర్థం చేసుకోలేరు మరియు, ముఖ్యంగా, ఎందుకు.

స్ప్రింగ్ ఫ్రేమ్‌వర్క్ అంటే ఏమిటి?

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

నిర్మాణం

కానీ స్ప్రింగ్ అనేది ఒక నిర్దిష్ట ఫ్రేమ్‌వర్క్ మాత్రమే కాదు. బదులుగా, ఇది అనేక చిన్న ఫ్రేమ్‌వర్క్‌లను సూచించడానికి ఉపయోగించే సాధారణ పేరు, వీటిలో ప్రతి ఒక్కటి దాని స్వంత రకమైన పనిని చేస్తుంది.

https://docs.spring.io/spring/docs/4.3.26.RELEASE/spring-framework-reference/htmlsingle/
మూర్తి 2.1. స్ప్రింగ్ ఫ్రేమ్‌వర్క్ యొక్క అవలోకనం

మీరు గమనిస్తే, స్ప్రింగ్ మాడ్యులర్. ఇది మా అప్లికేషన్‌కు అవసరమైన మాడ్యూల్‌లను మాత్రమే కనెక్ట్ చేయడానికి మరియు మనం ఉపయోగించని వాటిని కనెక్ట్ చేయకుండా అనుమతిస్తుంది. నాకు తెలిసినంత వరకు, ఈ విధానమే స్ప్రింగ్‌ని అప్పటి పోటీదారు (EJB)ని అధిగమించి, ఆధిక్యం వహించేలా చేసింది. EJBని ఉపయోగించే అప్లికేషన్‌లు వాటి వెనుక చాలా డిపెండెన్సీలను లాగాయి మరియు ఫలితంగా, అవి నిదానంగా మరియు నెమ్మదిగా మారాయి. స్ప్రింగ్ ఫ్రేమ్‌వర్క్ అనేక మాడ్యూళ్ళను కలిగి ఉందని చిత్రం చూపిస్తుంది:

• డేటా యాక్సెస్
• వెబ్
• కోర్
• ఇంకా చాలా

ఈ రోజు మనం ప్రధాన మాడ్యూల్‌లో కనిపించే కొన్ని భావనలతో పరిచయం పొందుతాము: బీన్స్, సందర్భం మరియు ఇతరులు. మీరు ఊహించినట్లుగా, డేటా యాక్సెస్ మాడ్యూల్ డేటాతో (ప్రధానంగా డేటాబేస్‌లు) పని చేయడానికి సాధనాలను కలిగి ఉంటుంది మరియు వెబ్ మాడ్యూల్ నెట్‌వర్క్‌లో పని చేయడానికి (వెబ్ అప్లికేషన్‌లను సృష్టించడంతో సహా, ఇది తరువాత చర్చించబడుతుంది). అదనంగా, స్ప్రింగ్‌కు మద్దతిచ్చే సమగ్ర అవస్థాపన ఉంది: ఫ్రేమ్‌వర్క్‌లో అధికారికంగా చేర్చబడని అనేక ఇతర ప్రాజెక్ట్‌లు, కానీ మీ స్ప్రింగ్ ప్రాజెక్ట్‌లో సజావుగా విలీనం చేయబడ్డాయి (ఉదాహరణకు, స్ప్రింగ్ సెక్యూరిటీ, నేను కూడా తాకాలని ఆశిస్తున్నాను. వెబ్‌సైట్‌లో వినియోగదారుని ప్రామాణీకరించడం).

జావా ఎందుకు స్ప్రింగ్ ఫ్రేమ్‌వర్క్‌ను కలిగి ఉంది?

సరే, ఇది ఫ్యాషన్‌గా, మృదువుగా మరియు తాజాగా ఉండటంతో పాటు, స్ప్రింగ్‌ని ఉపయోగించి మీరు కొద్దిపాటి నైపుణ్యం పొందిన వెంటనే, మీకు ఇకపై అన్ని రకాల పని ఎలా ఉంటుందో మీకు అర్థమవుతుందని నేను ఇప్పుడే చెప్పగలను. చేయడానికి, మరియు వసంతకాలం ఎంత పని తీసుకుంటుంది. మీరు కాన్ఫిగరేషన్ సెట్టింగ్‌ల యొక్క రెండు డజన్ల పంక్తులను వ్రాయవచ్చు మరియు రెండు తరగతులను వ్రాయవచ్చు మరియు మీరు పని చేసే ప్రాజెక్ట్‌తో ముగించవచ్చు. అయితే హుడ్ కింద ఎంత వస్తువు ఉంది, ఎంత పని జరుగుతోంది మరియు మీరు సాదా సర్వ్‌లెట్‌లు లేదా సాకెట్లు మరియు స్వచ్ఛమైన జావా ఆధారంగా అదే ప్రాజెక్ట్‌ను అమలు చేయబోతున్నట్లయితే మీరు ఎంత కోడ్ వ్రాయవలసి ఉంటుంది అని మీరు ఆలోచించడం ప్రారంభించిన వెంటనే, మీ వెంట్రుకలు నిక్కబొడుచుకుంటాయి :) వసంతాన్ని ఒక రకమైన మాయాజాలంగా కూడా అభివర్ణిస్తారు. ప్రతిదీ పని చేస్తుందని మీరు చూసినప్పుడు మీరు దీన్ని అనుభవిస్తారు, కానీ తెరవెనుక ఎలా మరియు ఎంత పని జరుగుతోందనే దాని గురించి మీకు స్థూలమైన ఆలోచన కూడా ఉంది — కాబట్టి నిజంగా ఏదో ఒక రకమైన మ్యాజిక్ చర్యలో ఉన్నట్లు అనిపిస్తుంది :) అదంతా ఒకదానితో ఒకటి ఎలా అనుసంధానించబడిందో వివరించడానికి ప్రయత్నించడం కంటే దీనిని మ్యాజిక్ అని పిలవడం సులభం. :) స్ప్రింగ్ చదవడానికి అనుకూలంగా ఉన్న రెండవ వాదన ఏమిటంటే, జూనియర్ డెవలపర్‌ల కోసం దాదాపు 90% ఉద్యోగ అవకాశాలకు (నా వ్యక్తిగత పరిశీలనల ఆధారంగా) జ్ఞానం లేదా కనీసం స్ప్రింగ్‌ల గురించి సాధారణ ఆలోచన అవసరం.Data, Web MVC, మరియు Securityమాడ్యూల్స్ అధునాతన డెవలపర్‌లను అందిస్తాయి :) కానీ నేడు కేవలం ప్రాథమిక అంశాల గురించి మాత్రమే.

DI/IoC

మీరు ఎప్పుడైనా వసంతకాలం గురించి చదవడానికి ప్రయత్నించినట్లయితే, మీరు ఎదుర్కొన్న మొదటి విషయం బహుశా ఈ సంక్షిప్త పదాలు: DI/IoC. ఇప్పుడు మీరు ఈ కథనం నుండి విరామం తీసుకుని, ఈ DZone కథనాన్ని చదవాలని నేను బాగా సిఫార్సు చేస్తున్నాను ! IoC అంటే నియంత్రణ యొక్క విలోమం. లైబ్రరీని ఉపయోగించడం అనేది మీ కోడ్‌లో ఏ వస్తువును ఏ పద్ధతిలో కాల్ చేయాలో మీరే సూచిస్తుందని నేను వ్రాసినప్పుడు నేను ఇప్పటికే పేర్కొన్నాను, అయితే ఫ్రేమ్‌వర్క్‌ని ఉపయోగించడం అంటే ఫ్రేమ్‌వర్క్ సరైన సమయంలో మీ కోడ్‌ని పిలుస్తుందని అర్థం. మరో మాటలో చెప్పాలంటే, ఈ రెండో సందర్భంలో, మీరు ఇకపై కోడ్/ప్రోగ్రామ్‌ని అమలు చేసే ప్రక్రియను నిర్వహించడం లేదు - ఫ్రేమ్‌వర్క్ మీ కోసం దీన్ని చేస్తుంది. మీరు నియంత్రణను ఫ్రేమ్‌వర్క్‌కు (నియంత్రణ విలోమం) పంపారు. DI అంటే డిపెండెన్సీ ఇంజెక్షన్. డిపెండెన్సీ ఇంజెక్షన్‌తో, మీరు ప్రధాన పద్ధతిలో పిల్లి వస్తువులను సృష్టించి, ఆపై వాటిని మీ పద్ధతులకు పంపరు. బదులుగా, స్ప్రింగ్ ఫ్రేమ్‌వర్క్ మీ కోసం వాటిని సృష్టిస్తుంది. మీరు "నేను ఇక్కడ పిల్లిని తీసుకురావాలనుకుంటున్నాను" అని చెప్పండి మరియు ఫ్రేమ్‌వర్క్ మీ పద్ధతిలో మీకు ఒకటి పంపుతుంది. మేము ఈ సంక్షిప్తీకరణను తదుపరి కథనాలలో చూస్తాము.

బీన్స్ మరియు సందర్భం

స్ప్రింగ్‌లోని ముఖ్య భావనలలో ఒకటి బీన్. నిజానికి, ఇది కొంత తరగతికి చెందిన వస్తువు మాత్రమే. మనకు 3 వస్తువులు అవసరమయ్యే ప్రోగ్రామ్ ఉందని అనుకుందాం: పిల్లి, కుక్క మరియు చిలుక. మరియు మేము కొన్ని పద్ధతులతో కూడిన తరగతులను కలిగి ఉన్నాము. కొన్నిసార్లు మనకు ఒక పద్ధతి కోసం పిల్లి అవసరం, కొన్నిసార్లు మనకు వేరే పద్ధతి కోసం కుక్క అవసరం, మరియు కొన్నిసార్లు మన పద్ధతులకు పిల్లి మరియు చిలుక రెండూ అవసరం (ఉదాహరణకు, పిల్లికి ఆహారం ఇచ్చే పద్ధతి, హా-హా). ఇంకా ఇతర పద్ధతుల కోసం, మూడు వస్తువులు అవసరం. అవును, మేము మొదట ఈ మూడు వస్తువులను ప్రధాన పద్ధతిలో సృష్టించవచ్చు, ఆపై వాటిని మా తరగతులకు పంపవచ్చు, ఆపై ఈ తరగతుల్లో వాటిని సంబంధిత పద్ధతులకు పాస్ చేయవచ్చు... మరియు మొత్తం ప్రోగ్రామ్ అంతటా. కానీ మన పద్ధతుల కోసం మేము అప్పుడప్పుడు ఇన్‌పుట్ పారామితుల జాబితాను మార్చాలనుకుంటున్నామని కూడా అనుకుంటే (ఉదాహరణకు, మేము ఏదైనా తిరిగి వ్రాయాలని లేదా కొత్త కార్యాచరణను జోడించాలని నిర్ణయించుకుంటాము), అప్పుడు మేము కోడ్‌లో కొన్ని మార్పులు చేయాల్సి ఉంటుంది. మరియు ఇప్పుడు మనకు 3 కాదు, 300 అలాంటి వస్తువులు ఉన్నాయని ఊహించుకోండి. మా వస్తువులన్నింటినీ ఒకే జాబితాలో సేకరించడం ఒక ప్రత్యామ్నాయం (List<Object>), ప్రతి పద్ధతికి దానిని పాస్ చేయండి, ఆపై పద్ధతుల్లో ఉన్నప్పుడు అవసరమైన వస్తువును పొందండి. ప్రోగ్రామ్ నడుస్తున్నప్పుడు, ఈ జాబితాకు ఏదైనా వస్తువు జోడించబడితే లేదా అధ్వాన్నంగా ఉంటే, ఒకటి తొలగించబడితే? ఇది జాబితా నుండి వస్తువులను పొందడానికి మేము సూచికను ఉపయోగించే ప్రతి పద్ధతిని విచ్ఛిన్నం చేసే సామర్థ్యాన్ని కలిగి ఉంటుంది. ఈ సమస్యను నివారించడానికి, మేము మా వస్తువులను జాబితాలో కాకుండా మ్యాప్‌లో నిల్వ చేయాలని నిర్ణయించుకుంటాము, ఇక్కడ ఆబ్జెక్ట్ పేరు కీ మరియు విలువ ఆబ్జెక్ట్‌గా ఉంటుంది. ఇది మనకు అవసరమైన వస్తువులను వాటి పేరును ఉపయోగించడం ద్వారా తిరిగి పొందేందుకు అనుమతిస్తుంది, ఉదాహరణకు get("చిలుక"), మరియు ప్రతిస్పందనగా మనం చిలుక వస్తువును పొందుతాము. లేదా కీ అనేది వస్తువు యొక్క తరగతి కావచ్చు మరియు విలువ వస్తువు కూడా కావచ్చు. ఈ సందర్భంలో, వస్తువు పేరును పేర్కొనడం కంటే, మనకు అవసరమైన వస్తువు యొక్క తరగతిని నిర్దేశించవచ్చు. అది కూడా అనుకూలమైనది. లేదా మేము మ్యాప్ కోసం ఒక రకమైన రేపర్‌ను కూడా వ్రాయవచ్చు, ఇక్కడ కొన్ని పద్ధతులు వాటి పేరుతో వస్తువులను పొందుతాయి మరియు ఇతర పద్ధతులు వాటి తరగతి ద్వారా వస్తువులను పొందుతాయి. మనం ఇక్కడికి వచ్చిన దాన్ని ఒక అంటారుస్ప్రింగ్ ఫ్రేమ్‌వర్క్‌లో అప్లికేషన్ సందర్భం . ఒక సందర్భం బీన్స్ (వస్తువులు) యొక్క సేకరణ. మనకు అవసరమైన బీన్ (వస్తువు) దాని పేరు ద్వారా, దాని రకం ద్వారా లేదా ఇతర మార్గాల ద్వారా పొందడానికి మేము సందర్భాన్ని యాక్సెస్ చేస్తాము. అదనంగా, మనకు అవసరమైన బీన్‌ను దాని స్వంత సందర్భంలో చూడమని మరియు దానిని మా పద్ధతికి పంపమని మేము స్ప్రింగ్‌ని అడగవచ్చు. ఉదాహరణకు, మనకు ఇలాంటి పద్ధతి ఉందని అనుకుందాం:

public void doSomething(Cat cat) {
    ...
}

స్ప్రింగ్ ఈ పద్ధతిని పిలిచినప్పుడు, అది మా పిల్లి వస్తువును దాని సందర్భం నుండి తీసుకొని పద్ధతికి పంపింది. కానీ ఇప్పుడు మేము నిర్ణయించుకున్నాము, పిల్లితో పాటు, మా పద్ధతికి చిలుక కూడా అవసరం. వసంతకాలంలో, ఏదీ సులభం కాదు! మేము కేవలం వ్రాస్తాము:

public void doSomething(Cat cat, Parrot parrot) {
    ...
}

ఇప్పుడు స్ప్రింగ్ మా పద్ధతిని పిలిచినప్పుడు, పిల్లి మరియు చిలుకను దాటవలసిన అవసరాన్ని అర్థం చేసుకుంటుంది, కాబట్టి అది దాని సందర్భానికి వెళ్లి, ఈ రెండు వస్తువులను పొంది, వాటిని మా పద్ధతికి పంపుతుంది. స్ప్రింగ్‌కు నియంత్రణ పగ్గాలను బదిలీ చేయడం ద్వారా, మేము వస్తువులను సృష్టించే బాధ్యతను కూడా బదిలీ చేస్తాము మరియు వాటిని మా పద్ధతులకు బదిలీ చేస్తాము, వీటిని స్ప్రింగ్ అంటారు. ఇది ప్రశ్న వేస్తుంది: ఏ వస్తువులు (బీన్స్) సృష్టించాలో స్ప్రింగ్‌కి ఎలా తెలుసు?

అప్లికేషన్‌ను కాన్ఫిగర్ చేయడానికి మార్గాలు

అనువర్తనాన్ని కాన్ఫిగర్ చేయడానికి మూడు ప్రధాన మార్గాలు ఉన్నాయి , అంటే మనకు ఏ వస్తువులు అవసరమో స్ప్రింగ్‌కి చెప్పే మార్గాలు:

1. XML కాన్ఫిగరేషన్ ఫైల్స్
2. జావా-ఆధారిత కాన్ఫిగరేషన్
3. ఆటోమేటిక్ కాన్ఫిగరేషన్

స్ప్రింగ్ సృష్టికర్తలు ఈ క్రమంలో వాటికి ప్రాధాన్యతనిస్తారు:

• ప్రాధాన్యత ఇవ్వాల్సిన ప్రధాన ప్రాధాన్యత కలిగిన పద్ధతి ఆటోమేటిక్ కాన్ఫిగరేషన్
• సాధ్యమయ్యే అన్ని బీన్స్‌లను సరిగ్గా కాన్ఫిగర్ చేయడానికి ఆటోమేటిక్ కాన్ఫిగరేషన్ ఉపయోగించబడకపోతే, జావా-ఆధారిత కాన్ఫిగరేషన్‌ను ఉపయోగించండి (జావా కోడ్‌ని ఉపయోగించి ఆబ్జెక్ట్‌లను సృష్టించడం ఇందులో ఉంటుంది)
• మరియు అతి తక్కువ ప్రాధాన్యత గల పద్ధతి పాత పద్ధతిలో — XML config ఫైళ్లను ఉపయోగించడం.

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