Dependency Injection چیست و آموزش استفاده از تزریق وابستگی ها در اندروید

تزریق وابستگی یا ( Dependency Injection) فرآیندی می باشد که در آن وابستگی های ما به یک کلاس با استفاده از یک رابط کاربری یا همان  (Interface) حذف می شود. 

متنی را در یکی از وبسایت ها خونده بودم که جالب می دونم اون رو اینجا هم بیارم و البته منبع اون سایت رو هم ذکر می کنم( قانون کپی رایت رو رعایت کنیم:) )

یک جمله بسیار جالب در مورد Dependency Injection یا تزریق وابستگی شنیدم که به نظرم کل مفهوم را یکدفعه منتقل می کند که در ادامه برای شما قرار میدهم

متن انگلیسی:

“Dependency Injection” is a 25-dollar term for a 5-cent concept.

ترجمه متن بالا

یک معیار ۲۵ دلاری برای یک مفهوم ۵ سنتی است.

حالا معنی جمله بالا یعنی چی ؟ !

یعنی نمیشه گفت که  تزریق وابستگی یک واژه یا یک Concept بد است و حتی نمیشه گفت یک Concept خوب است اگر به درستی استفاده شود یعنی به درستی درک شده باشد و پیاده سازی شده باشد یک مفهوم خوب و در صورتی که بد استفاده شده باشد یک مفهوم فوق العاده بد خواهد داشت. (منبع:programchi.ir)

خوب امیدورام با این متن با مفهوم تزریق وابستگی آشنا شده باشین:) البته اگر هنوز کمی این مفهوم برای شما گنگ هست نگران نباشد و تا انتهای مطلب همراه ما باشید.

چرا ما از تزریق وابستگی استفاده می کنیم؟

ایده اصلی Dependency Injection این می باشد که اتصالات و وابستگی را بصورت جدا از هم ایجاد کند، بصورتی که کلاس مادر یا شی ایجاد شده به راحتی قابل آزمایش و اجرا باشد.

اصولا مشکل زمانی پیش خواهد آمد که ما یک کلاس را ایجاد کرده باشیم و در آینده بخوایم در یک شی تغییراتی ایجاد کنیم، این تغییرات بسیار دشوار می باشد چرا که اگر از تزریق وابستگی استفاده نکرده باشیم باید تمام نونه های آن شی را تغییر دهیم.

مثال در مورد استفاده از تزریق وابستگی ها:

شما قصد دارید در سیستم خود یک بخش برای ارسال ایمیل پس از ثبت نظر توسط کاربر ایجاد نمایید. شما کلاسی ایجاد خواهید کرد که با استفاده از کلاس پیش فرض ایمیل این کار را برای شما انجام دهد. حالا یک سال دیگر مدیرپروژه شما می گوید که می خواهد به سیستم نظرات خود قابلیت ارسال پیامک را نیز اضاف کند. خوب حالا شما چه کار انجام خواهید داد؟ 

یک کلاس دیگر مجددا برای ارسال پیامک ایجاد خواهید کرد که از کلاس پیش فرض  ارسال پیامک شما استفاده کند؟ 

خوب چرا اینکار؟ 

همانطور که می دانیم هم ایمیل و هم پیامک یک گیرنده و یک متن دارند البته ممکن است در برخی موارد مانند سرویس دهنده متفاوت باشند اما نتیجه نهایی هر دو ارسال پیغامی به کاربر مورد نظر می باشد

 پس در اینجا می توانیم با استفاده از Dependency Injection و یک رابط کاربری یا همان Interface کلاس مادر خود را طوری ایجاد خواهیم کرد، که به راحتی استفاده و بتوان حتی اگر روزی نیاز به استفاده از روش های دیگری همچون ارسال پیام صوتی و تصویری و.. بود هم از همین کلاس استفاده نماییم.

حالا بزارید با همدیگه نمونه ای رو بررسی کنیم:

فرض کنید ما کلاسی داریم بنام MessageService که کار ارسال پیام را به چند صورت می خواهد انجام دهد. خوب ما دو کلاس برای ارسال پیام ایجاد کرده ایم که دو نوع پیام را ارسال میکنند

بدون استفاده از DI  (مخفف Dependency Injection) کدهای ما بصورت زیر خواهد بود:

class TypeA{
 sendMessage(){
    ---------
    ---------
 }
}
 
class TypeB{
 sendMessage(){
  ---------
  ---------
 }
}
class SendMessageApplication{
   main(){
     send(type);
  }
 
  send(int type){
     if(type == 1){
        TypeA a = new TypeA();
        a.sendMessage(); 
     }else{
        TypeB b = new TypeB();
        b.sendMessage();
     }
  }
}

در آینده اگر برای نمونه ما بخواهیم کلاس نوع A را تغییر دهیم برای نمونه به نوع C این کار را باید بصورت دستی انجام دهیم، حالا اگر پروژه بسیار بزرگ باشد تصور کنید این کار چقدر دشوار تر خواهد شد.

خوب راه حل چیست؟

ما یک رابط کاربری (interface) ایجاد میکنیم که کار ارسال پیام را انجام میده و دارای یک متد بنام  sendMessage می باشد.

حال تمامی سرویس دهنده های ما (همان کلاس های ارسال پیام) باید این رابط کاربری  را implement  کنند

با این کار ما کلاس هایی داریم که همگی از یک رابط کاربری استفاده کرده اند و متدی بنام sendMessage را درون خود دارند که عملیات نهایی ارسال پیام را با توجه به نوع اون کلاس انجام می دهند. برای نمونه کلاس اول متن را بصورت انگلیسی و کلاس دوم بصورت فارسی می فرستد.

حال  ما در تابع setter  در کلاس MessageApplication از طریق تزریق وابستگی نوع سرویس مورد نظر( همان کلاس های ارسال پیام) را گرفته و با استفاده از متد sendMessage که متد messageService.sendMessage(); را که اشاره به تابع sendMessage() رابط کاربری ما دارد را اجرا و عملیات ارسال پیام را انجام خواهیم داد.

پس با استفاده از تزریق وابستگی ها کلاس های ما بصورت زیر تغییر خواهند کرد:

interface MessageService{
  sendMessage();
}
 
class TypeA implements MessageService{
 void sendMessage(){
   //------------
   //------------
 }
}
 
class TypeB implements MessageService{
 void sendMessage(){
   //-----------
   //-----------
 }
}
//----------------------------------------------------
class MessageApplication{
  MessageService messageService;
  void setMessageService(MessageService service){
    this.messageService = service;
  }
  void sendMessage(){
   messageService.sendMessage();
 }
}

حال شما می تواند با ایجاد یک شی از کلاس MessageApplication و فراخوانی sendMessage() به راحتی از دو روش ارسال پیام یعنی کلاس های A  و B استفاده کنید و حتی انواع دیگری نیز ایجاد نمایید و بدون تغییر در کلاس MessageApplication  تنها از نوع جدید استفاده کنید.

درصورتی که سوالی یا پیشنهادی دارید از بخش نظرات ارسال فرمایید