سست لوگوں کے لیے بہار فاؤنڈیشن، بنیادی تصورات، اور کوڈ کے ساتھ مثالیں۔ حصہ 2

پچھلے مضمون میں ، میں نے مختصر طور پر وضاحت کی تھی کہ بہار کیا ہے اور پھلیاں اور سیاق و سباق کیا ہیں۔ اب اسے آزمانے کا وقت آگیا ہے۔ میں اسے IntelliJ IDEA انٹرپرائز ایڈیشن کا استعمال کرتے ہوئے کرنے جا رہا ہوں۔ لیکن میری تمام مثالوں کو مفت IntelliJ IDEA کمیونٹی ایڈیشن میں بھی کام کرنا چاہیے۔ اسکرین شاٹس میں، اگر آپ دیکھتے ہیں کہ میرے پاس کچھ ونڈو ہے جو آپ کے پاس نہیں ہے، تو پریشان نہ ہوں — یہ اس پروجیکٹ کے لیے اہم نہیں ہے :) سب سے پہلے، ایک خالی Maven پروجیکٹ بنائیں۔ میں نے اس لنک پر آرٹیکل میں یہ کیسے کرنا ہے دکھایا ۔ الفاظ تک پڑھیں " اب وقت آگیا ہے کہ ہم اپنے Maven پروجیکٹ کو ویب پروجیکٹ میں تبدیل کریں۔ " — اس کے بعد، مضمون میں دکھایا گیا ہے کہ ویب پروجیکٹ کیسے بنایا جائے، لیکن ہمیں ابھی اس کی ضرورت نہیں ہے۔ src/main/java فولڈر میں ، ایک پیکج بنائیں (میرے معاملے میں، میں نے اسے کہا ہے " en.codegym.info.fatfaggy.animals۔ آپ اسے جو چاہیں کہہ سکتے ہیں۔ بس تمام صحیح جگہوں پر میرے پیکیج کے نام کو اپنے پیکیج کے نام سے بدلنا نہ بھولیں۔ اب Mainکلاس بنائیں اور ایک طریقہ شامل کریں۔

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

اس کے بعد pom.xml فائل کھولیں اور dependenciesسیکشن شامل کریں۔ اب ماون ریپوزٹری پر جائیں اور تازہ ترین مستحکم ورژن کے لیے بہار کا سیاق و سباق تلاش کریں۔ جو کچھ ہمیں ملتا ہے اسے سیکشن میں ڈالیں dependencies۔ میں نے اس عمل کو اس دوسرے CodeGym مضمون میں مزید تفصیل سے بیان کیا ہے (" Maven میں انحصار کنیکٹنگ " کے عنوان سے سیکشن دیکھیں )۔ پھر 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());
}

سب سے پہلے، ہم ایک سیاق و سباق کی آبجیکٹ بناتے ہیں، کنسٹرکٹر کو بتاتے ہیں کہ پھلیاں تلاش کرنے کے لیے کون سا پیکج دیکھنا ہے۔ دوسرے لفظوں میں، بہار اس پیکیج سے گزرے گی اور خصوصی تشریحات کے ساتھ نشان زدہ کلاسز تلاش کرنے کی کوشش کرے گی جو اس بات کی نشاندہی کرتی ہیں کہ وہ پھلیاں ہیں۔ پھر یہ ان کلاسوں کی اشیاء بناتا ہے اور انہیں سیاق و سباق میں رکھتا ہے۔ اس کے بعد ہمیں اس سیاق و سباق سے ایک بلی ملتی ہے۔ ہم سیاق و سباق کے آبجیکٹ سے مطالبہ کرتے ہیں کہ ہمیں ایک بین (آبجیکٹ) دیں، جس چیز کی ہم چاہتے ہیں اس کی کلاس کی نشاندہی کریں (ویسے، ہم انٹرفیس بھی بتا سکتے ہیں، نہ کہ کلاسز)۔ اس کے بعد، Spring درخواست کردہ کلاس کا ایک آبجیکٹ لوٹاتا ہے، جسے ہم پھر ایک متغیر میں محفوظ کرتے ہیں۔ اگلا، ہم بہار سے کہتے ہیں کہ وہ ہمیں "کتا" نامی بین حاصل کرے۔ جب Spring ایک 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-based configuration کا استعمال کرتے ہوئے وہی کام کرنے کی کوشش کریں گے ۔ شروع کرنے کے لیے، @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تبدیل کرنا نہ بھولیں ۔ اس کے علاوہ، جاوا پر مبنی کنفیگریشن آپ کو اپنے بین بنانے کے طریقوں میں کسی بھی جاوا کوڈ کو چلانے دیتی ہے۔ آپ واقعی کچھ بھی کر سکتے ہیں: دیگر معاون اشیاء بنائیں، کوئی دوسرا طریقہ کال کریں، یہاں تک کہ جن پر بہار کی تشریحات کے ساتھ نشان نہیں ہے، لوپس بنائیں، بولین حالات — جو بھی ذہن میں آئے! یہ سب کچھ خودکار کنفیگریشن کے ساتھ ممکن نہیں ہے، اور اس سے بھی کم XML کنفیگریشن کے ساتھ۔ اب آئیے ایک مسئلے پر غور کریں جو کچھ زیادہ ہی مزے کا ہے۔ پولیمورفزم اور انٹرفیس :) ہم ایک انٹرفیس بنائیں گے اور 7 کلاسز بنائیں گے جو اس انٹرفیس کو نافذ کریں گے: , , , , , , . ہم انٹرفیس کو ایک طریقہ دیں گے، جو متعلقہ کلاس کے لیے ہفتے کے دن کا نام واپس کر دے گا۔ دوسرے لفظوں میں، کلاس واپس آ جائے گی " "، وغیرہ۔ ایپلیکیشن شروع کرنے پر، فرض کریں کہ ہمارا کام ہفتے کے موجودہ دن کے مطابق سیاق و سباق میں ڈالنا ہے۔ انٹرفیس کو نافذ کرنے والی تمام کلاسوں کے لیے پھلیاں نہیں — صرف ایک بین جس کی ہمیں ضرورت ہے۔ آپ اسے اس طرح کر سکتے ہیں: ObjectParrotWeekDayMondayTuesdayWednesdayThursdayFridaySaturdaySundayString getWeekDayName()MondayMondayWeekDay

@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 کی ابتدائی سطحوں میں سے کسی ایک پر ہیں، تو آپ کے لیے موسم بہار کا مطالعہ کرنا تھوڑا جلدی ہو سکتا ہے۔ جب آپ اپنی جاوا پروگرامنگ کی مہارتوں پر زیادہ اعتماد محسوس کرتے ہیں تو آپ تھوڑی دیر بعد اس مضمون پر واپس جا سکتے ہیں۔ اگر سب کچھ واضح ہے، تو آپ اپنے پالتو جانوروں کے کچھ پروجیکٹ کو بہار میں تبدیل کرنے کی کوشش کر سکتے ہیں :) اگر کچھ چیزیں واضح ہیں لیکن کچھ چیزیں نہیں ہیں، تو براہ کرم ایک تبصرہ کریں :) مجھے اپنی تجاویز اور تنقید سے آگاہ کریں، اگر میں غلط ہوا ہوں کہیں یا کوئی بکواس لکھا ہے :) اگلے مضمون میں، ہم اچانک spring-web-mvc میں غوطہ لگائیں گے اور Spring کا استعمال کرتے ہوئے ایک سادہ ویب ایپلیکیشن بنائیں گے۔