برنامه نویسی جنبه گرا (AOP)

در این مقاله میخواهیم در مورد مفهوم برنامه نویسی جنبه گرا (Aspect-Oriented Programming) یا به اختصار AOP با شما کاربران عزیز سایت میهن لرن صحبت کنیم. حتما با برنامه نویسی شی گرا (OOP) بخوبی آشنایی دارید و می دانید که این سبک برنامه نویسی بسیار کاربردی و قدرتمند هست. اما با وجود برنامه نویسی شی گرا، چه نیازی به مفهوم جدید AOP بود؟

اول بهتر است بصورت مختصر در مورد تاریخچه تکامل زبان های برنامه نویسی مواردی را بدانیم. در روزهای اولیه پیدایش علم کامپیوتر، برنامه نویسان برنامه های خودشان را مستقیما با استفاده از کدهای سطح ماشین می نوشتند. بنابراین بیشتر از اینکه فکرشان را معطوف به اصل مساله بکنند لازم بود متوجه مجموعه دستورات ماشین مورد نظر بکنند! یعنی ماشینی که قرار بود این برنامه روی آن اجرا شود. به تدریج زبان های سطح بالاتری بوجود آمدند و برای ما سطحی از انتزاع را فراهم کردند به این معنی که یک برنامه را میتوانستیم روی کامپیوترهای مختلف اجرا کنیم و لازم نبود زمان نوشتن، به این مساله فکر کنیم که روی چه ماشینی قرار است اجرا شود. پیشرفت های زبان های برنامه نویسی ادامه پیدا کرد و به سمت زبان های ساخت یافته رفتیم. حالا میتوانستیم برای راحت تر کردن کار، مساله را به تعدادی روال، که برای انجام کارها لازم بودند تقسیم کنیم، همچنین ساختارهای داده، ساختارهای کنترلی مثل حلقه ها و.. و توابع بوجود آمدند. بعد از آن، سبک برنامه نویسی شی گرا رواج پیدا کرد که به ما اجازه می داد جزئیات پیاده سازی را پشت واسط برنامه نویسی پنهان کنیم. چندشکلی بودن، امکان رفتار و واسطه مشترک برای مفاهیم مشابه را به ما می داد. بنابراین میتوانستیم پیمانه های خاص و جدید را بدون نیاز به دستکاری در پیاده سازی مفاهیم پایه ایجاد کنیم.

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

برای اینکه قضیه روشن تر شود باید بدانید یک سیستم نرم افزاری مجموعه ایست از دغدغه (Concern) های مختلف که بین بخش های مختلف برنامه مشترک هستند. و گاهی اوقات میتوانند رابطه پیچیده ای بین بخش های مختلف ایجاد بکنند. مثل دغدغه امنیت (Security)، ثبت وقایع (Logging)، احراز هویت (Authenticatin)، اشکال زدایی، امنیت کار موازی (Multithread satefy)، بررسی اشکال ها، منطق کاری، کارایی، ماندگاری داده ها و …

در شکل زیر یک سیستم را بصورت مجموعه ای از دغدغه ها که بصورت ماژولار پیاده سازی شده اند نشان می دهد:

اگر بخواهیم برای پیاده سازی این دغدغه ها از روش برنامه نویسی شی گرا استفاده کنیم، نتیجه سیستمی خواهد شد که بسیار پیچیده، غیرقابل فهم و غیرانعطاف پذیر خواهد بود. به این خاطر که تصور کنید اکثر کلاس های برنامه شما طبیعتا به ثبت وقایع نیاز خواهند داشت. حال اگر قرار باشد هر کلاس، خودش بطور مجزا این قابلیت را پیاده سازی کند چه اتفاقی می افتد؟؟ اولا ممکن است پیاده سازی ها در کلاس های مختلف با هم متفاوت باشد! علاوه بر آن اگر سیاست ثبت وقایع در سیستم عوض شود مجبور خواهیم بود تمام کلاس ها را تغییر بدهیم! و مورد بعدی اینکه کلاس های ما درگیر عملیاتی خواهند شد که ارتباطی به عملکرد و هدف اصلی آنها ندارد!

چرا که در واقع مواردی مانند ثبت وقایع، جزو دغدغه های سیستمی هستند که بعضی از آنها را تحت عنوان دغدغه های تداخلی (Cross-cutting) می شناسیم، یعنی دغدغه هایی که بر روی پیاده سازی ماژول های مختلف برنامه اثر می گذارند و بهمین دلیل طراحی و درک سیستم مورد نظر سخت تر و پیاده سازیش پیچیده تر و تغییرش هم بمراتب سخت تر خواهد شد.

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

برنامه نویسی جنبه گرا در واقع یکی از روش هایی است که مشکل دغدغه های تداخلی را بخوبی حل میکند و شما میتوانید این موارد را از کد اصلی برنامه خارج کنید و آنرا بصورت عمودی تعریف کنید:

function mainProgram()
{ 
   var x =  foo();
   doSomethingWith(x);
   return x;
}

aspect logging
{ 
    before (mainProgram is called):
    { 
       log.Write("entering mainProgram");
    }

    after (mainProgram is called):
    { 
       log.Write(  "exiting mainProgram with return value of "
                  + mainProgram.returnValue);
    }
 } 

aspect verification
{ 
    before (doSomethingWith is called):
    { 
       if (doSomethingWith.arguments[0] == null) 
       { 
          throw NullArgumentException();
       }

       if (!doSomethingWith.caller.isAuthenticated)
       { 
          throw Securityexception();
       }
    }
 }

و حالا استفاده از یک aspect-weaver (تلاقی دهنده یا مجتمع ساز جنبه) برای کامپایل کد به کد زیر:

function mainProgram()
{ 
   log.Write("entering mainProgram");

   var x = foo();   

   if (x == null) throw NullArgumentException();
   if (!mainProgramIsAuthenticated()) throw Securityexception();
   doSomethingWith(x);   

   log.Write("exiting mainProgram with return value of "+ x);
   return x;
} 

پس واحد ماژول بندی در AOP جنبه است در صورتیکه این واحد در OOP کلاس است. در AOP پیاده سازی هر دغدغه از اینکه توسط دغدغه های دیگر تحت نظر است بی خبر است. مثلا قسمت های مختلف نمیدانند که دغدغه های دیگر آغاز و پایان عملیات آن را ثبت میکنند یا هویت کاربر را قبل از آن چک میکنند.

برای برنامه سازی جنبه گرا میتوان از زبان های عادی مانند C، C++ یا جاوا استفاده کرد و بخش هایی را برای مشخص کردن قوانین تلاقی به آن اضافه نمود. این مفاهیم شامل برش نقطه ای (Point cut) ، نقاط اتصال (Join point) ، ابلاغیه (Advice) و جنبه (Aspect) هستند.

راه حل هایی که تاکنون برای مواجه با دغدغه های تداخلی وجود دارد شامل framework ها و application server هاست. یکی از فریمورک هایی که از برنامه نویسی جنبه گرا پشتیبانی میکند فریمورک معروف و محبوب spring است.

فریمورک Spring AOP برای ماژول بندی کردن دغدغه های تداخلی در قالب جنبه ها استفاده میشود. مفسری که یک سری فرآیند ها را در زمان اجرای یک متود از آن جداسازی میکند. Spring AOP میتواند متود در حال اجرا را ربوده و قابلیت های اضافی را قبل یا بعد از اجرای آن اضافه کند. شما می توانید آموزش های فارسی برنامه نویسی جنبه گرا را از سایت ما، میهن لرن، دانلود کنید.