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

پچھلے مضمون میں ، میں نے مختصراً وضاحت کی تھی کہ بہار کیا ہے، ڈبے کیا ہیں اور سیاق و سباق۔ اب یہ کوشش کرنے کا وقت ہے کہ یہ سب کیسے کام کرتا ہے۔ میں خود اسے Intellij Idea Enterprise Edition میں کروں گا۔ لیکن میری تمام مثالوں کو مفت Intellij Idea Community Edition میں بھی کام کرنا چاہیے۔ بس اگر آپ اسکرین شاٹس میں دیکھتے ہیں کہ میرے پاس کچھ ایسی ونڈو ہے جو آپ کے پاس نہیں ہے، تو پریشان نہ ہوں، یہ اس پروجیکٹ کے لیے اہم نہیں ہے :) پہلے، آئیے ایک خالی Maven پروجیکٹ بنائیں۔ میں نے آرٹیکل میں دکھایا کہ یہ کیسے کرنا ہے (یہ الفاظ تک پڑھیں کہ " ہمارے ماون پروجیکٹ کو ویب پروجیکٹ میں تبدیل کرنے کا وقت آگیا ہے۔ "، اس کے بعد یہ پہلے ہی دکھاتا ہے کہ ویب پروجیکٹ کیسے بنایا جائے، اور ہمیں اب اس کی ضرورت نہیں ہے) آئیے اسے src/main فولڈر میں بنائیں /java کچھ پیکج ہے (میرے معاملے میں میں نے اسے “ ru.javarush.info.fatfaggy.animals” کہا ہے، آپ اسے جو چاہیں نام دے سکتے ہیں، بس اسے صحیح جگہوں پر اپنے نام سے بدلنا نہ بھولیں)۔ اور آئیے ایک کلاس بنائیں Mainجس میں ہم ایک طریقہ بنائیں گے۔

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

پھر pom.xml فائل کھولیں اور وہاں ایک سیکشن شامل کریں dependencies۔ اب ہم ماون ریپوزٹری میں جاتے ہیں اور وہاں کے تازہ ترین مستحکم ورژن کے موسم بہار کے سیاق و سباق کو تلاش کرتے ہیں ، اور سیکشن کے اندر جو کچھ ہمیں ملا اسے پیسٹ کرتے ہیں dependencies۔ میں نے اس عمل کو اس مضمون میں کچھ اور تفصیل سے بیان کیا ہے (دیکھیں " Maven میں انحصار کو مربوط کرنا ")۔ پھر Maven خود ضروری انحصار کو تلاش اور ڈاؤن لوڈ کرے گا، اور آخر میں آپ کو کچھ اس طرح ملنا چاہئے: بائیں ونڈو میں آپ پیکیج اور کلاس کے ساتھ پروجیکٹ کی ساخت دیکھ سکتے ہیں Main۔ درمیانی ونڈو دکھاتی ہے کہ میرا pom.xml کیسا لگتا ہے۔ میں نے وہاں پراپرٹیز کا ایک سیکشن بھی شامل کیا ، جس میں میں نے ماون کو اشارہ کیا کہ میں سورس کوڈ میں جاوا کا کون سا ورژن استعمال کر رہا ہوں اور کون سا ورژن مرتب کرنا ہے۔ یہ صرف اس لیے ہے کہ جاوا کا پرانا ورژن استعمال کیا جا رہا ہے۔ آپ یہ کر سکتے ہیں، آپ نہیں کر سکتے) صحیح ونڈو میں - آپ دیکھ سکتے ہیں کہ اگرچہ ہم نے صرف موسم بہار کے سیاق و سباق سے منسلک کیا ہے - اس نے خود بخود بنیادی، پھلیاں، aop اور اظہار کو شامل کیا ہے۔ ورژن کے واضح اشارے کے ساتھ میموری میں ہر ایک کے لیے انحصار کا اندراج کرتے ہوئے ہر ماڈیول کو الگ سے جوڑنا ممکن تھا، لیکن فی الحال ہم اس آپشن سے خوش ہیں جیسا کہ اب ہے۔ اب ایک پیکج (اداروں) بنائیں entitiesاور اس میں 3 کلاسز بنائیں: Cat, Dog, Parrot. ہر جانور کا ایک نام ہونے دیں ( private String name، آپ وہاں کچھ اقدار کو ہارڈ کوڈ کر سکتے ہیں)، اور حاصل کرنے والے/سیٹرز عوامی ہیں۔ اب کلاس میں جائیں Mainاور main()طریقہ کار میں کچھ اس طرح لکھیں:

public static void main(String[] args) {
	// create an empty spring context that will search for its beans by annotations in the specified package
	ApplicationContext context =
		new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.entities");

	Cat cat = context.getBean(Cat.class);
	Dog dog = (Dog) context.getBean("dog");
	Parrot parrot = context.getBean("parrot-kesha", Parrot.class);

	System.out.println(cat.getName());
	System.out.println(dog.getName());
	System.out.println(parrot.getName());
}

سب سے پہلے، ہم ایک سیاق و سباق کی آبجیکٹ بناتے ہیں، اور کنسٹرکٹر میں ہم اسے اس پیکیج کا نام دیتے ہیں جسے پھلیاں کی موجودگی کے لیے اسکین کرنے کی ضرورت ہوتی ہے۔ یعنی، اسپرنگ اس پیکج سے گزرے گا اور ایسی کلاسوں کو تلاش کرنے کی کوشش کرے گا جو خصوصی تشریحات کے ساتھ نشان زد ہوں جو اسپرنگ کو بتائیں کہ یہ ایک بین ہے۔ جس کے بعد یہ ان کلاسوں کی اشیاء بناتا ہے اور انہیں اپنے سیاق و سباق میں رکھتا ہے۔ جس کے بعد ہمیں اس تناظر سے ایک بلی ملتی ہے۔ سیاق و سباق کے آبجیکٹ کو ایڈریس کرتے وقت، ہم اسے ایک بین (آبجیکٹ) دینے کو کہتے ہیں، اور بتاتے ہیں کہ ہمیں کس کلاس کی آبجیکٹ کی ضرورت ہے (یہاں، ویسے، آپ نہ صرف کلاسز، بلکہ انٹرفیس بھی بتا سکتے ہیں)۔ جس کے بعد اسپرنگ اس کلاس کا ایک آبجیکٹ ہمیں واپس کرتا ہے، جسے ہم ایک متغیر میں محفوظ کرتے ہیں۔ اگلا، ہم بہار سے کہتے ہیں کہ وہ ہمیں "کتے" نامی ایک بین منگوائے۔ جب اسپرنگ کلاس آبجیکٹ بناتا ہے، Dogتو یہ اسے ایک معیاری نام دے گا (اگر بین کی تخلیق کا نام واضح طور پر نہیں بتایا گیا ہے)، جو کہ آبجیکٹ کی کلاس کا نام ہے، صرف ایک چھوٹے حرف کے ساتھ۔ لہذا، چونکہ ہماری کلاس کو کہا جاتا ہے Dog، ایسی بین کا نام "کتا" ہوگا۔ اگر ہمارے پاس وہاں کوئی چیز ہوتی BufferedReaderتو اسپرنگ اسے پہلے سے طے شدہ نام "bufferedReader" دے دیتا۔ اور چونکہ اس معاملے میں (جاوا میں) اس بات کا کوئی قطعی یقین نہیں ہے کہ ایسی کوئی چیز کس کلاس کی ہوگی، اس لیے یہ صرف ایک مخصوص کو لوٹاتا ہے Object، جسے ہم دستی طور پر اپنی ضرورت کے مطابق کاسٹ کرتے ہیں Dog۔ کلاس کے واضح اشارے والا آپشن زیادہ آسان ہے۔ ٹھیک ہے، تیسری صورت میں، ہمیں کلاس اور نام کے لحاظ سے ایک بین ملتا ہے۔ بس ایک ایسی صورت حال ہو سکتی ہے جہاں سیاق و سباق میں ایک طبقے کی کئی پھلیاں ہوں گی، اور یہ بتانے کے لیے کہ ہمیں کس خاص بین کی ضرورت ہے، ہم اس کا نام بتاتے ہیں۔ چونکہ ہم نے یہاں بھی واضح طور پر کلاس کا اشارہ کیا ہے، ہمیں اب کاسٹ کرنے کی ضرورت نہیں ہے۔ اہم!اگر یہ پتہ چلتا ہے کہ اسپرنگ کو ان تقاضوں کے مطابق کئی پھلیاں مل جاتی ہیں جو ہم نے اس کے لیے مخصوص کی ہیں، تو یہ اس بات کا تعین نہیں کر سکے گا کہ ہمیں کون سی پھلی دینی ہے اور اس سے مستثنیٰ ہو جائے گا۔ اس لیے کوشش کریں کہ جتنا ممکن ہو اسے واضح کریں کہ آپ کو کون سا ڈبہ درکار ہے، تاکہ ایسے حالات پیدا نہ ہوں۔ اگر اسپرنگ کو آپ کی شرائط کے مطابق اپنے سیاق و سباق میں ایک بھی پھلی نہیں ملتی ہے، تو یہ ایک استثنا بھی دے گا۔ ٹھیک ہے، پھر ہم صرف اپنے جانوروں کے نام اسکرین پر ظاہر کرتے ہیں تاکہ یہ یقینی بنایا جا سکے کہ یہ دراصل وہی چیزیں ہیں جن کی ہمیں ضرورت ہے۔ لیکن اگر ہم ابھی پروگرام چلاتے ہیں، تو ہم دیکھیں گے کہ بہار قسم کھا رہی ہے کہ وہ اپنے سیاق و سباق میں درکار جانور نہیں ڈھونڈ سکتا۔ یہ اس لیے ہوا کہ اس نے یہ پھلیاں نہیں بنائیں۔ جیسا کہ میں نے پہلے ہی کہا ہے، جب اسپرنگ کلاسز کو اسکین کرتا ہے، تو یہ وہاں "اس کی" بہار کی تشریحات تلاش کرتا ہے۔ اور اگر اسے نہیں ملتا ہے، تو وہ ایسی کلاسوں کو نہیں سمجھتا ہے جن کی پھلیاں اسے بنانے کی ضرورت ہے۔ اسے ٹھیک کرنے کے لیے، صرف @Componentہماری جانوروں کی کلاسوں میں کلاس کے سامنے ایک تشریح شامل کریں۔

@Component
public class Cat {
	private String name = "Barsik";
	...
}

لیکن یہ سب کچھ نہیں ہے۔ اگر ہمیں بہار کے لیے واضح طور پر اشارہ کرنے کی ضرورت ہے کہ اس کلاس کے لیے بین کا ایک مخصوص نام ہونا چاہیے، تو اس نام کو تشریح کے بعد قوسین میں ظاہر کیا جا سکتا ہے۔ مثال کے طور پر، بہار کا نام دینے کے لیے ہمیں parrot-keshaطوطے کی پھلی کی ضرورت ہے، جس سے ہم mainبعد میں یہ طوطا حاصل کریں گے، ہمیں کچھ اس طرح کرنے کی ضرورت ہے:

@Component("parrot-kesha")
public class Parrot {
	private String name = "Kesha";
	...
}

یہ خودکار ترتیب کا پورا نقطہ ہے ۔ آپ اپنی کلاسیں لکھتے ہیں، ان پر ضروری تشریحات کے ساتھ نشان لگاتے ہیں، اور اپنی کلاسوں کے ساتھ ایک پیکیج کو بہار کی طرف اشارہ کرتے ہیں، جس کے ذریعے یہ جاتا ہے، تشریحات تلاش کرتا ہے اور ایسی کلاسوں کی اشیاء تخلیق کرتا ہے۔ ویسے، Spring نہ صرف تشریحات @Componentبلکہ دیگر تمام تشریحات کو بھی تلاش کرے گا جو اس سے وراثت میں ملے ہیں۔ مثال کے طور پر @Controller،،،، اور دیگر، جن @RestControllerسے ہم مزید مضامین میں ملیں گے۔ اب ہم ایسا کرنے کی کوشش کرتے ہیں، لیکن استعمال کرتے ہوئے java configuration ۔ پہلے، آئیے اپنی کلاسوں سے تشریحات کو ہٹا دیں۔ کام کو پیچیدہ کرنے کے لیے، آئیے تصور کریں کہ یہ ہماری اپنی خود لکھی ہوئی کلاسیں نہیں ہیں، جن میں ہم آسانی سے ترمیم کر سکتے ہیں، تشریحات سمیت کچھ شامل کر سکتے ہیں۔ ایسا لگتا ہے جیسے یہ کلاسیں کسی لائبریری میں بھری پڑی ہوں۔ اس صورت میں، ہم ان کلاسوں میں کسی بھی طرح ترمیم نہیں کر سکتے تاکہ وہ بہار کے ذریعے قبول کر لیں۔ لیکن ہمیں ان کلاسوں کی اشیاء کی ضرورت ہے! یہاں ہمیں ایسی اشیاء بنانے کے لیے جاوا کنفیگریشن کی ضرورت ہوگی۔ شروع کرنے کے لیے، آئیے ایک پیکج بنائیں، مثال کے طور پر ، اور اس میں - ایک باقاعدہ جاوا کلاس، مثال کے طور پر، اور اسے ایک تشریح کے ساتھ نشان زد کریں۔@Service@Repository@ComponentconfigsMyConfig@Configuration

@Configuration
public class MyConfig {
}

اب ہمیں main()طریقہ کار میں سیاق و سباق بنانے کے طریقے کو تھوڑا سا موافقت کرنے کی ضرورت ہے۔ ہم یا تو براہ راست وہاں ترتیب کے ساتھ اپنی کلاس کی وضاحت کر سکتے ہیں:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class);

اگر ہمارے پاس کئی مختلف کلاسیں ہیں جہاں ہم پھلیاں بناتے ہیں اور ہم ان میں سے کئی کو ایک ساتھ جوڑنا چاہتے ہیں، تو ہم انہیں وہاں کوما سے الگ کرکے اشارہ کرتے ہیں:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class, MyAnotherConfig.class);

ٹھیک ہے، اگر ہمارے پاس ان میں سے بہت سارے ہیں، اور ہم ان سب کو ایک ساتھ جوڑنا چاہتے ہیں، تو ہم یہاں صرف اس پیکیج کے نام کی نشاندہی کرتے ہیں جس میں ہمارے پاس یہ ہیں:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.configs");

اس صورت میں، Spring اس پیکیج سے گزرے گا اور ان تمام کلاسوں کو تلاش کرے گا جن پر تشریح کے ساتھ نشان لگایا گیا ہے @Configuration۔ ٹھیک ہے، اگر ہمارے پاس واقعی ایک بڑا پروگرام ہے جہاں کنفیگرس کو مختلف پیکجوں میں تقسیم کیا گیا ہے، تو ہم صرف کوما سے الگ کردہ کنفیگرز کے ساتھ پیکیجز کے ناموں کی نشاندہی کرتے ہیں:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.database.configs",
		"ru.javarush.info.fatfaggy.animals.root.configs",
		"ru.javarush.info.fatfaggy.animals.web.configs");

ٹھیک ہے، یا ان سب کے لیے عام پیکیج کا نام:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals");

آپ اسے اپنی مرضی کے مطابق کر سکتے ہیں، لیکن مجھے لگتا ہے کہ پہلا آپشن، جہاں آپ صرف کنفیگرز کے ساتھ ایک کلاس کی وضاحت کرتے ہیں، ہمارے پروگرام کے لیے بہترین ہو گا۔ سیاق و سباق بناتے وقت، اسپرنگ ان کلاسوں کو تلاش کرے گا جو تشریح کے ساتھ نشان زد ہوں @Configurationاور اپنے آپ میں ان کلاسوں کی اشیاء بنائیں۔ جس کے بعد یہ ان کلاسوں میں ایسے طریقوں کو کال کرنے کی کوشش کرے گا جن پر تشریح کے ساتھ نشان لگایا گیا ہے @Bean، جس کا مطلب ہے کہ اس طرح کے طریقے پھلیاں (آبجیکٹ) واپس کر دیں گے جو اس نے پہلے ہی اپنے سیاق و سباق میں رکھ دی ہیں۔ ٹھیک ہے، اب جاوا کنفیگریشن کے ساتھ اپنی کلاس میں بلی، کتے اور طوطے کی پھلیاں بنائیں۔ یہ کافی آسانی سے کیا جاتا ہے:

@Bean
public Cat getCat() {
	return new Cat();
}

یہ پتہ چلتا ہے کہ ہم نے خود اپنی بلی کو خود بنایا اور اسے بہار کو دیا، اور اس نے پہلے ہی ہمارے اس اعتراض کو اپنے سیاق و سباق میں رکھا۔ چونکہ ہم نے واضح طور پر اپنی بین کے نام کی وضاحت نہیں کی ہے، اس لیے اسپرنگ بین کو وہی نام دے گا جو طریقہ کے نام کا ہے۔ ہمارے معاملے میں، بلی کی بین کا نام " getCat" ہوگا۔ لیکن چونکہ in main-e ہم اب بھی بلی کو نام سے نہیں بلکہ کلاس سے حاصل کرتے ہیں، تو اس صورت میں اس بن کا نام ہمارے لیے اہم نہیں ہے۔ اسی طرح ایک کتے کے ساتھ ایک بین بنائیں، لیکن یہ ذہن میں رکھیں کہ بہار اس طریقہ کے نام سے اس قسم کی بین کا نام دیں گے۔ طوطے کے ساتھ ہماری بین کا نام واضح طور پر رکھنے کے لیے، تشریح کے بعد قوسین میں اس کے نام کی نشاندہی کریں @Bean:

@Bean("parrot-kesha")
public Object weNeedMoreParrots() {
	return new Parrot();
}

جیسا کہ آپ دیکھ سکتے ہیں، یہاں میں نے واپسی کی قدر کی قسم کی نشاندہی کی Object، اور طریقہ کار کو کچھ بھی کہا۔ اس سے بین کے نام پر کوئی اثر نہیں پڑتا ہے کیونکہ ہم اسے یہاں واضح طور پر متعین کرتے ہیں۔ لیکن یہ بہتر ہے کہ واپسی کی قدر کی قسم اور طریقہ کا نام نیلے رنگ سے نہیں بلکہ کم و بیش واضح طور پر ظاہر کیا جائے۔ صرف اپنے لیے بھی، جب آپ ایک سال میں اس پروجیکٹ کو کھولتے ہیں۔ :) اب آئیے ایک ایسی صورتحال پر غور کریں جہاں ایک بین بنانے کے لیے ہمیں دوسری بین استعمال کرنے کی ضرورت ہے ۔ مثال کے طور پر، ہم چاہتے ہیں کہ کیٹ بین میں بلی کا نام طوطے کے نام اور تار "- قاتل" پر مشتمل ہو۔ کوئی مسئلہ نہیں!

@Bean
public Cat getCat(Parrot parrot) {
	Cat cat = new Cat();
	cat.setName(parrot.getName() + "-killer");
	return cat;
}

یہاں بہار دیکھے گا کہ اس بین کو بنانے سے پہلے، اسے پہلے سے تیار شدہ طوطے کی بین کو یہاں منتقل کرنے کی ضرورت ہوگی۔ اس لیے وہ ہمارے طریقوں پر کالوں کی ایک زنجیر بنائے گا تاکہ پہلے طوطے کو بنانے کا طریقہ کہا جائے اور پھر اس طوطے کو بلی بنانے کے طریقے تک پہنچا دے۔ یہ وہ جگہ ہے جہاں انحصار انجیکشن نامی چیز نے کام کیا : بہار نے خود ہمارے طریقہ کار میں مطلوبہ طوطے کی بین کو منتقل کیا۔ اگر خیال کسی متغیر کے بارے میں شکایت کرتا ہے تو طوطے کو parrotبنانے کے طریقہ کار میں واپسی کی قسم کو تبدیل کرنا نہ بھولیں ۔ اس کے علاوہ، جاوا کنفیگریشن آپ کو پھلیاں بنانے کے طریقوں میں بالکل کسی بھی جاوا کوڈ پر عمل کرنے کی اجازت دیتی ہے۔ آپ واقعی کچھ بھی کر سکتے ہیں: دیگر معاون اشیاء بنائیں، کوئی اور طریقہ کال کریں، یہاں تک کہ جن پر موسم بہار کی تشریحات کے ساتھ نشان نہیں لگایا گیا ہے، لوپس بنائیں، حالات - جو بھی ذہن میں آئے! یہ سب خودکار کنفیگریشن کا استعمال کرتے ہوئے حاصل نہیں کیا جا سکتا، بہت کم ایکس ایم ایل کنفیگریشن کا استعمال کرتے ہوئے۔ ObjectParrot اب ایک اور پرلطف مسئلہ دیکھتے ہیں۔ پولیمورفزم اور انٹرفیس کے ساتھ :) آئیے ایک انٹرفیس بنائیں 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("It's " + weekDay.getWeekDayName() + " today!");

اس نے مجھے بتایا کہ آج اتوار ہے :) مجھے یقین ہے کہ اگر میں کل پروگرام چلاتا ہوں تو سیاق و سباق میں ایک بالکل مختلف چیز نظر آئے گی۔ براہ کرم نوٹ کریں کہ یہاں ہمیں بین صرف انٹرفیس کے ذریعے ملتا ہے: context.getBean(WeekDay.class)۔ بہار اپنے سیاق و سباق میں دیکھے گا کہ اس کی کون سی پھلیاں اس طرح کے انٹرفیس کو لاگو کرتی ہیں اور اسے واپس کرے گی۔ ٹھیک ہے، پھر پتہ چلتا ہے کہ WeekDayقسم کے متغیر میں ایک قسم کی چیز ہے Sunday، اور پولیمورفزم، جو ہم سب کو پہلے سے ہی معلوم ہے، اس متغیر کے ساتھ کام کرتے وقت شروع ہوتا ہے۔ :) اور مشترکہ نقطہ نظر کے بارے میں کچھ الفاظ ، جہاں کچھ پھلیاں اسپرنگ کے ذریعے خود بنائی جاتی ہیں، ایک تشریح کے ساتھ کلاسز کی موجودگی کے لیے پیکجوں کی اسکیننگ کا استعمال کرتے ہوئے @Component، اور کچھ دوسری بینز جاوا کنفگ کا استعمال کرتے ہوئے بنائی جاتی ہیں۔ ایسا کرنے کے لیے، آئیے اصل ورژن پر واپس جائیں، جب کلاسز Cat، Dogاور Parrotایک تشریح کے ساتھ نشان زد تھے @Component۔ ہم کہتے ہیں کہ ہم موسم بہار تک پیکج کی خودکار اسکیننگ کا استعمال کرتے ہوئے اپنے جانوروں کے لیے ڈبے بنانا چاہتے ہیں entities، لیکن ہفتے کے دن کے ساتھ ایک ڈبہ بنائیں جیسا کہ ہم نے ابھی کیا تھا۔ آپ کو صرف کلاس کی سطح پر شامل کرنے کی ضرورت ہے ، جسے ہم -th تشریح MyConfigمیں سیاق و سباق بناتے وقت بیان کرتے ہیں ، اور بریکٹ میں اس پیکیج کی نشاندہی کرتے ہیں جس کو اسکین کرنے کی ضرورت ہوتی ہے اور ضروری کلاسوں کی پھلیاں خود بخود بن جاتی ہیں: main@ComponentScan

@Configuration
@ComponentScan("ru.javarush.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();
		}
	}
}

یہ پتہ چلتا ہے کہ سیاق و سباق بناتے وقت، Spring دیکھتا ہے کہ اسے کلاس پر کارروائی کرنے کی ضرورت ہے MyConfig۔ وہ اس میں جاتا ہے اور دیکھتا ہے کہ اسے پیکج " " کو اسکین کرنے اور ان کلاسوں کی بینز بنانے کی ضرورت ہے ، جس کے بعد وہ کلاس سے ru.javarush.info.fatfaggy.animals.entitiesطریقہ کار پر عمل کرتا ہے اور اپنے سیاق و سباق میں ٹائپ بین کو شامل کرتا ہے ۔ طریقہ کار میں، اب ہمیں ان تمام پھلیوں تک رسائی حاصل ہے جن کی ہمیں ضرورت ہے: جانوروں کی اشیاء اور ہفتے کے دن کے ساتھ بین دونوں۔ اس بات کو کیسے یقینی بنایا جائے کہ اسپرنگ کچھ ایکس ایم ایل کنفیگرز بھی اٹھا لے - اگر ضروری ہو تو اسے انٹرنیٹ پر خود گوگل کریں :) خلاصہ:getDay()MyConfigWeekDaymain()

• خودکار ترتیب استعمال کرنے کی کوشش کریں؛
• خودکار کنفیگریشن کے دوران، ہم اس پیکیج کے نام کی نشاندہی کرتے ہیں جس میں وہ کلاسز شامل ہیں جن کی پھلیاں بنانے کی ضرورت ہے۔
• ایسی کلاسوں کو ایک تشریح کے ساتھ نشان زد کیا جاتا ہے۔@Component;
• spring ان تمام کلاسوں سے گزرتا ہے اور ان کی اشیاء تخلیق کرتا ہے اور انہیں سیاق و سباق میں رکھتا ہے۔
• اگر کسی وجہ سے خودکار کنفیگریشن ہمارے مطابق نہیں ہے تو ہم جاوا کنفیگریشن استعمال کرتے ہیں۔
• اس صورت میں، ہم ایک باقاعدہ جاوا کلاس بناتے ہیں، جس کے طریقے ہماری ضرورت کی اشیاء کو واپس کر دیتے ہیں، اور @Configurationسیاق و سباق بناتے وقت کنفیگریشن کے ساتھ مخصوص کلاس کی وضاحت کرنے کے بجائے پورے پیکیج کو اسکین کرنے کی صورت میں ایسی کلاس کو تشریح کے ساتھ نشان زد کرتے ہیں۔
• اس کلاس کے طریقے جو پھلیاں واپس کرتے ہیں ان کو تشریح کے ساتھ نشان زد کیا جاتا ہے @Bean۔
اگر ہم جاوا کنفیگریشن استعمال کرتے وقت خودکار اسکیننگ کو فعال کرنا چاہتے ہیں تو ہم تشریح استعمال کرتے ہیں @ComponentScan۔

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