AOP کیا ہے؟ پہلو پر مبنی پروگرامنگ کی بنیادی باتیں

ہیلو لوگو! بنیادی تصورات کو سمجھے بغیر، فنکشنلٹی کی تعمیر کے لیے فریم ورک اور نقطہ نظر کو تلاش کرنا کافی مشکل ہے۔ تو آج ہم ان میں سے ایک تصور کے بارے میں بات کریں گے - AOP، یا پہلو پر مبنی پروگرامنگ ۔ یہ کوئی آسان موضوع نہیں ہے اور اسے اکثر براہ راست استعمال نہیں کیا جاتا ہے، لیکن بہت سے فریم ورک اور ٹیکنالوجیز اسے ہڈ کے نیچے استعمال کرتی ہیں۔ اور یقیناً، بعض اوقات انٹرویوز کے دوران آپ سے عام الفاظ میں یہ بتانے کے لیے کہا جا سکتا ہے کہ یہ کس قسم کا جانور ہے اور اسے کہاں استعمال کیا جا سکتا ہے۔ تو آئیے جاوا میں AOP کے بنیادی تصورات اور کچھ آسان مثالوں کو دیکھتے ہیں ۔ لہذا، AOP - پہلو پر مبنی پروگرامنگ - ایک نمونہ ہے جس کا مقصد کراس کٹنگ خدشات کو الگ کرکے ایپلی کیشن کے مختلف حصوں کی ماڈیولریٹی کو بڑھانا ہے۔ ایسا کرنے کے لیے، اصل کوڈ کو تبدیل کیے بغیر، موجودہ کوڈ میں اضافی رویہ شامل کیا جاتا ہے۔ دوسرے لفظوں میں، ایسا لگتا ہے کہ ہم ترمیم شدہ کوڈ میں ترمیم کیے بغیر طریقوں اور کلاسوں کے اوپر اضافی فعالیت کو لٹکا رہے ہیں۔ یہ کیوں ضروری ہے؟ جلد یا بدیر ہم اس نتیجے پر پہنچتے ہیں کہ عام اعتراض پر مبنی نقطہ نظر بعض مسائل کو ہمیشہ مؤثر طریقے سے حل نہیں کر سکتا۔ ایسے لمحے میں، AOP بچاؤ کے لیے آتا ہے اور ہمیں ایپلیکیشن بنانے کے لیے اضافی ٹولز دیتا ہے۔ اور اضافی ٹولز کا مطلب ہے ترقی میں لچک میں اضافہ، جس کی بدولت کسی خاص مسئلے کو حل کرنے کے لیے مزید اختیارات موجود ہیں۔

اے او پی کی درخواست

پہلو پر مبنی پروگرامنگ کو کراس کٹنگ کے مسائل کو حل کرنے کے لیے ڈیزائن کیا گیا ہے، جو کوئی بھی کوڈ ہو سکتا ہے جو مختلف طریقوں سے کئی بار دہرایا جاتا ہے، جسے مکمل طور پر علیحدہ ماڈیول میں ڈھانچہ نہیں بنایا جا سکتا۔ اس کے مطابق، AOP کے ساتھ ہم اسے مرکزی کوڈ سے باہر چھوڑ سکتے ہیں اور اسے عمودی طور پر بیان کر سکتے ہیں۔ ایک مثال ایک درخواست میں سیکیورٹی پالیسی کا اطلاق ہے۔ عام طور پر، سیکیورٹی ایپلی کیشن کے بہت سے عناصر میں کمی کرتی ہے۔ مزید برآں، ایپلیکیشن سیکیورٹی پالیسی کو درخواست کے تمام موجودہ اور نئے حصوں پر یکساں طور پر لاگو کیا جانا چاہیے۔ ایک ہی وقت میں، استعمال شدہ سیکورٹی پالیسی خود تیار ہو سکتی ہے۔ یہ وہ جگہ ہے جہاں AOP کا استعمال کام آ سکتا ہے ۔ اس کے علاوہ ایک اور مثال لاگنگ ہے ۔ دستی طور پر لاگنگ داخل کرنے کے مقابلے میں لاگنگ کے لیے AOP اپروچ استعمال کرنے کے کئی فوائد ہیں:

1. لاگنگ کوڈ کو لاگو کرنا اور ہٹانا آسان ہے: آپ کو صرف کچھ پہلوؤں کے کنفیگریشنز کو شامل کرنے یا ہٹانے کی ضرورت ہے۔
2. لاگنگ کے لیے تمام سورس کوڈ ایک جگہ پر محفوظ ہیں اور استعمال کی تمام جگہوں کو دستی طور پر تلاش کرنے کی ضرورت نہیں ہے۔
3. لاگنگ کے لیے بنائے گئے کوڈ کو کہیں بھی شامل کیا جا سکتا ہے، چاہے وہ پہلے سے لکھے گئے طریقے اور کلاسز ہوں یا نئی فعالیت۔ یہ ڈویلپر کی غلطیوں کی تعداد کو کم کرتا ہے۔
   اس کے علاوہ، جب آپ ڈیزائن کنفیگریشن سے کسی پہلو کو ہٹاتے ہیں، تو آپ پوری طرح یقین کر سکتے ہیں کہ تمام ٹریس کوڈ ہٹا دیے گئے ہیں اور کچھ بھی غائب نہیں ہے۔
4. پہلو اسٹینڈ اکیلے کوڈ ہیں جنہیں دوبارہ استعمال کیا جا سکتا ہے اور اسے بار بار بہتر بنایا جا سکتا ہے۔

AOP کو مستثنیٰ ہینڈلنگ، کیشنگ، اور کچھ فعالیتوں کو ہٹانے کے لیے بھی استعمال کیا جاتا ہے تاکہ اسے دوبارہ قابل استعمال بنایا جا سکے۔

AOP کے بنیادی تصورات

موضوع کے تجزیہ میں مزید آگے بڑھنے کے لیے، آئیے پہلے AOP کے بنیادی تصورات سے واقف ہوں۔ مشورہ اضافی منطق ہے، کوڈ، جسے کنکشن پوائنٹ سے کہا جاتا ہے۔ مشورہ کنکشن پوائنٹ سے پہلے، بعد میں یا اس کے بجائے کیا جا سکتا ہے (ذیل میں ان پر مزید)۔ مشورے کی ممکنہ اقسام :

1. اس سے پہلے (پہلے) - اس قسم کا مشورہ ہدف کے طریقوں پر عمل درآمد سے پہلے شروع کیا جاتا ہے - کنکشن پوائنٹس۔ پہلوؤں کو کلاسز کے طور پر استعمال کرتے وقت، ہم @Before تشریح لیتے ہیں تاکہ مشورے کی قسم کو پہلے کے طور پر نشان زد کیا جا سکے۔ پہلوؤں کو .aj فائلوں کے طور پر استعمال کرتے وقت ، یہ before() طریقہ ہوگا ۔
2. بعد (بعد میں) - مشورے جو طریقوں پر عمل درآمد کی تکمیل کے بعد پھانسی دی جاتی ہے - کنکشن پوائنٹس، دونوں عام صورتوں میں اور جب کوئی استثناء پھینکا جاتا ہے۔
   پہلوؤں کو کلاس کے طور پر استعمال کرتے وقت، ہم @After تشریح کا استعمال اس بات کی نشاندہی کرنے کے لیے کر سکتے ہیں کہ یہ ایک ٹپ ہے جو بعد میں آتی ہے۔
   جب پہلوؤں کو .aj فائلوں کے طور پر استعمال کریں تو یہ after() طریقہ ہوگا ۔
3. واپسی کے بعد - یہ تجاویز صرف اس صورت میں عمل میں لائی جاتی ہیں جب ہدف کا طریقہ عام طور پر کام کرتا ہے، بغیر کسی غلطی کے۔
   جب پہلوؤں کو کلاسز کے طور پر پیش کیا جاتا ہے، تو ہم @AfterReturning تشریح کا استعمال کر سکتے ہیں تاکہ مشورے کو کامیابی سے مکمل ہونے پر عمل میں لایا جا سکے۔
   پہلوؤں کو .aj فائلوں کے طور پر استعمال کرتے وقت، یہ after() طریقہ واپسی (Object obj) ہوگا ۔
4. پھینکنے کے بعد - اس قسم کے مشورے کا مقصد ان صورتوں کے لیے ہے جب کوئی طریقہ، یعنی کنکشن پوائنٹ، استثنا دیتا ہے۔ ہم اس مشورے کو ناکام عمل سے نمٹنے کے لیے استعمال کر سکتے ہیں (مثال کے طور پر، پورے لین دین کو واپس کرنا یا مطلوبہ ٹریس لیول کے ساتھ لاگ ان کرنا)۔
   پہلو کی کلاسوں کے لیے، @AfterThrowing تشریح کا استعمال اس بات کی نشاندہی کرنے کے لیے کیا جاتا ہے کہ یہ مشورہ مستثنیٰ ہونے کے بعد استعمال کیا جاتا ہے۔ .aj
   فائلوں کی شکل میں پہلوؤں کو استعمال کرتے وقت ، یہ طریقہ ہوگا - after() پھینکنا (Exception e) ۔
5. ارد گرد شاید مشورہ کی سب سے اہم قسموں میں سے ایک ہے جو ایک طریقہ کے ارد گرد ہے، یعنی، ایک کنکشن پوائنٹ، جس کے ساتھ ہم، مثال کے طور پر، منتخب کر سکتے ہیں کہ آیا کنکشن پوائنٹ کے دیئے گئے طریقہ پر عمل کرنا ہے یا نہیں۔
   آپ ایڈوائس کوڈ لکھ سکتے ہیں جو جوائن پوائنٹ کے طریقہ کار پر عملدرآمد سے پہلے اور بعد میں چلتا ہے۔ مشورے کی
   ذمہ داریوں میں جوائن پوائنٹ کے طریقہ کار کو کال کرنا اور اگر طریقہ کچھ واپس کرتا ہے تو اقدار کو واپس کرنا شامل ہیں۔ یعنی، اس ٹِپ میں آپ ٹارگٹ میتھڈ کے آپریشن کو بغیر کال کیے آسانی سے نقل کر سکتے ہیں، اور اس کے نتیجے میں اپنی کوئی چیز واپس کر سکتے ہیں۔ کلاسز کی شکل میں پہلوؤں کے لیے، ہم کنکشن پوائنٹ کو لپیٹنے والے ٹپس بنانے کے لیے @Around تشریح کا استعمال کرتے ہیں۔ پہلوؤں کو .aj فائلوں کے طور پر استعمال کرتے وقت ، یہ around() طریقہ ہوگا ۔
   

جوائن پوائنٹ - ایک ایگزیکیوٹنگ پروگرام میں ایک نقطہ (طریقہ کو کال کرنا، کسی چیز کو بنانا، کسی متغیر تک رسائی حاصل کرنا) جہاں مشورہ لاگو کیا جانا چاہیے۔ دوسرے لفظوں میں، یہ ایک طرح کا باقاعدہ اظہار ہے، جس کی مدد سے کوڈ متعارف کرانے کے لیے جگہیں مل جاتی ہیں۔ پوائنٹ کٹ کنکشن پوائنٹس کا ایک سیٹ ہے ۔ کٹ اس بات کا تعین کرتا ہے کہ آیا دیا ہوا کنکشن پوائنٹ دیئے گئے ٹپ پر فٹ بیٹھتا ہے۔ پہلو ایک ماڈیول یا کلاس ہے جو اختتام سے آخر تک فعالیت کو نافذ کرتا ہے۔ ایک پہلو جوائن پوائنٹس پر مشورے کو لاگو کرکے باقی کوڈ کے رویے میں ترمیم کرتا ہے جو کچھ سلائس کے ذریعہ بیان کیا گیا ہے ۔ دوسرے الفاظ میں، یہ تجاویز اور کنکشن پوائنٹس کا مجموعہ ہے۔ تعارف - غیر ملکی کوڈ میں پہلو کی فعالیت کو شامل کرنے کے لیے کلاس کی ساخت کو تبدیل کرنا اور/یا وراثت کے درجہ بندی کو تبدیل کرنا۔ ہدف وہ اعتراض ہے جس پر مشورہ لاگو کیا جائے گا۔ ویونگ تجویز کردہ پراکسی آبجیکٹ بنانے کے لیے پہلوؤں کو دیگر اشیاء کے ساتھ جوڑنے کا عمل ہے۔ یہ کمپائل ٹائم، لوڈ ٹائم، یا رن ٹائم پر کیا جا سکتا ہے۔ بنائی کی تین قسمیں ہیں:

• کمپائل ٹائم ویونگ - اگر آپ کے پاس کسی پہلو کا سورس کوڈ اور وہ کوڈ ہے جس میں آپ پہلوؤں کو استعمال کرتے ہیں، تو آپ AspectJ کمپائلر کا استعمال کرتے ہوئے سورس کوڈ اور پہلو کو براہ راست مرتب کر سکتے ہیں۔
• پوسٹ کمپائلیشن ویونگ (بائنری ویونگ) - اگر آپ اپنے کوڈ میں پہلوؤں کو بُننے کے لیے سورس کوڈ کی تبدیلیوں کو استعمال نہیں کر سکتے یا نہیں کرنا چاہتے، تو آپ پہلے سے مرتب شدہ کلاسز یا جار لے سکتے ہیں اور پہلوؤں کو انجیکشن کر سکتے ہیں۔
• لوڈ ٹائم ویونگ صرف بائنری ویونگ ہے جب تک کلاس لوڈر کلاس فائل کو لوڈ نہیں کرتا اور JVM کے لیے کلاس کی وضاحت نہیں کرتا۔
  اس کی حمایت کرنے کے لیے، ایک یا زیادہ "ویو کلاس لوڈرز" کی ضرورت ہے۔ وہ یا تو واضح طور پر رن ​​ٹائم کے ذریعے فراہم کیے جاتے ہیں یا "ویونگ ایجنٹ" کے ذریعے چالو کیے جاتے ہیں۔

AspectJ AOP پیراڈائمز کا ایک مخصوص نفاذ ہے جو کراس کٹنگ مسائل کو حل کرنے کی صلاحیت کو نافذ کرتا ہے۔ دستاویزات یہاں مل سکتی ہیں ۔

جاوا میں مثالیں۔

اگلا، AOP کو بہتر طور پر سمجھنے کے لیے، ہم ہیلو ورلڈ لیول کی چھوٹی چھوٹی مثالیں دیکھیں گے۔ مجھے فوری طور پر نوٹ کرنے دو کہ ہماری مثالوں میں ہم compile-time weaving استعمال کریں گے ۔ پہلے ہمیں اپنے pom.xml میں درج ذیل انحصار شامل کرنے کی ضرورت ہے ۔

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjrt</artifactId>
  <version>1.9.5</version>
</dependency>

ایک اصول کے طور پر، پہلوؤں کو استعمال کرنے کے لیے ایک خاص Ajs کمپائلر استعمال کیا جاتا ہے ۔ IntelliJ IDEA کے پاس یہ ڈیفالٹ نہیں ہے، لہذا جب اسے ایپلیکیشن کمپائلر کے طور پر منتخب کرتے ہیں تو آپ کو AspectJ ڈسٹری بیوشن کا راستہ بتانا ہوگا ۔ آپ اس صفحہ پر Ajs کو کمپائلر کے طور پر منتخب کرنے کے طریقہ کار کے بارے میں مزید پڑھ سکتے ہیں۔ یہ پہلا طریقہ تھا، اور دوسرا (جو میں نے استعمال کیا تھا) pom.xml میں درج ذیل پلگ ان کو شامل کرنا تھا ۔

<build>
  <plugins>
     <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>aspectj-maven-plugin</artifactId>
        <version>1.7</version>
        <configuration>
           <complianceLevel>1.8</complianceLevel>
           <source>1.8</source>
           <target>1.8</target>
           <showWeaveInfo>true</showWeaveInfo>
           <verbose>true</verbose>
           <Xlint>ignore</Xlint>
           <encoding>UTF-8</encoding>
        </configuration>
        <executions>
           <execution>
              <goals>
                 <goal>compile</goal>
                 <goal>test-compile</goal>
              </goals>
           </execution>
        </executions>
     </plugin>
  </plugins>
</build>

اس کے بعد، Maven سے دوبارہ درآمد کرنے اور mvn clean compile کو چلانے کا مشورہ دیا جاتا ہے ۔ اب آئیے مثالوں کی طرف۔

مثال نمبر 1

آئیے ایک مین کلاس بنائیں ۔ اس میں ہمارے پاس ایک لانچ پوائنٹ اور ایک طریقہ ہوگا جو کنسول میں اس پر بھیجے گئے ناموں کو پرنٹ کرتا ہے:

public class Main {

  public static void main(String[] args) {
  printName("Толя");
  printName("Вова");
  printName("Sasha");
  }

  public static void printName(String name) {
     System.out.println(name);
  }
}

کچھ بھی پیچیدہ نہیں: انہوں نے نام پاس کیا اور اسے کنسول میں ظاہر کیا۔ اگر ہم اسے ابھی چلاتے ہیں تو کنسول ظاہر کرے گا: ٹھیک ہے، یہ AOP کی طاقت سے فائدہ اٹھانے کا وقت ہے. اب ہمیں ایک فائل بنانے کی ضرورت ہے ۔ وہ دو قسموں میں آتے ہیں: پہلی .aj ایکسٹینشن والی فائل ہے ، دوسری ایک باقاعدہ کلاس ہے جو تشریحات کا استعمال کرتے ہوئے AOP صلاحیتوں کو نافذ کرتی ہے۔ آئیے پہلے .aj ایکسٹینشن والی فائل کو دیکھیں ۔

public aspect GreetingAspect {

  pointcut greeting() : execution(* Main.printName(..));

  before() : greeting() {
     System.out.print("Привет ");
  }
}

یہ فائل کسی حد تک کلاس سے ملتی جلتی ہے۔ آئیے معلوم کریں کہ یہاں کیا ہو رہا ہے: پوائنٹ کٹ - ایک کٹ یا کنکشن پوائنٹس کا ایک سیٹ؛ greeting() — اس ٹکڑے کا نام؛ : execution - عمل کرتے وقت * - all، call - Main.printName(..) - یہ طریقہ۔ اس کے بعد مخصوص مشورہ آتا ہے - before() - جو ٹارگٹ میتھڈ کو بلائے جانے سے پہلے عمل میں لایا جاتا ہے، : greeting() - وہ ٹکڑا جس پر یہ مشورہ رد عمل ظاہر کرتا ہے، اور نیچے ہم خود طریقہ کا باڈی دیکھتے ہیں، جو جاوا میں لکھا ہوا ہے۔ زبان ہم سمجھتے ہیں. جب ہم اس پہلو کے ساتھ مین چلاتے ہیں تو ہمیں کنسول میں درج ذیل آؤٹ پٹ ملے گا۔ ہم دیکھ سکتے ہیں کہ پرنٹ نام کے طریقہ کار کی ہر کال کو ایک پہلو سے تبدیل کیا گیا ہے۔ اب آئیے ایک نظر ڈالتے ہیں کہ پہلو کیسا نظر آئے گا، لیکن تشریحات کے ساتھ جاوا کلاس کے طور پر:

@Aspect
public class GreetingAspect{

  @Pointcut("execution(* Main.printName(String))")
  public void greeting() {
  }

  @Before("greeting()")
  public void beforeAdvice() {
     System.out.print("Привет ");
  }
}

.aj aspect فائل کے بعد ، سب کچھ زیادہ واضح ہے:

• @ Aspect اشارہ کرتا ہے کہ دی گئی کلاس ایک پہلو ہے۔
@Pointcut("execution(* Main.printName(String))") ایک کٹ پوائنٹ ہے جو Main.printName پر آنے والی تمام کالوں پر قسم String کی آنے والی دلیل کے ساتھ فائر کرتا ہے ۔
• @Before("greeting()") - مشورہ جو گریٹنگ() کٹ پوائنٹ پر بیان کردہ کوڈ کو کال کرنے سے پہلے لاگو کیا جاتا ہے ۔

اس پہلو کے ساتھ مین چلانے سے کنسول آؤٹ پٹ تبدیل نہیں ہوگا:

مثال نمبر 2

ہم کہتے ہیں کہ ہمارے پاس کچھ طریقہ ہے جو کلائنٹس کے لیے کچھ آپریشن کرتا ہے اور اس طریقہ کو مین سے کال کریں :

public class Main {

  public static void main(String[] args) {
  makeSomeOperation("Толя");
  }

  public static void makeSomeOperation(String clientName) {
     System.out.println("Выполнение некоторых операций для клиента - " + clientName);
  }
}

@Around تشریح کا استعمال کرتے ہوئے ، آئیے "سیڈو ٹرانزیکشن" کی طرح کچھ کرتے ہیں:

@Aspect
public class TransactionAspect{

  @Pointcut("execution(* Main.makeSomeOperation(String))")
  public void executeOperation() {
  }

  @Around(value = "executeOperation()")
  public void beforeAdvice(ProceedingJoinPoint joinPoint) {
     System.out.println("Открытие транзакции...");
     try {
        joinPoint.proceed();
        System.out.println("Закрытие транзакции....");
     }
     catch (Throwable throwable) {
        System.out.println("Операция не удалась, откат транзакции...");
     }
  }
  }

ProceedingJoinPoint آبجیکٹ کے proceed طریقہ کو استعمال کرتے ہوئے ، ہم بورڈ میں اس کی جگہ کا تعین کرنے کے لیے ریپر کے طریقہ کار کو کہتے ہیں اور اس کے مطابق، اوپر کے طریقہ کار میں کوڈ joinPoint.proceed(); - یہ پہلے ہے ، جو نیچے ہے - بعد میں ۔ اگر ہم مین چلاتے ہیں تو ہم کنسول میں حاصل کریں گے: اگر ہم اپنے طریقہ کار میں ایک استثنائی تھرو شامل کرتے ہیں (اچانک آپریشن ناکام ہوجاتا ہے):

public static void makeSomeOperation(String clientName)throws Exception {
  System.out.println("Выполнение некоторых операций для клиента - " + clientName);
  throw new Exception();
}

پھر ہم کنسول میں آؤٹ پٹ حاصل کریں گے: یہ ناکامی کی چھدم پروسیسنگ نکلی۔

مثال نمبر 3

اگلی مثال کے طور پر، آئیے کچھ ایسا کرتے ہیں جیسے کنسول میں لاگ ان کرنا۔ سب سے پہلے، آئیے Main کو دیکھتے ہیں ، جہاں ہماری سیڈو بزنس منطق ہوتی ہے:

public class Main {
  private String value;

  public static void main(String[] args) throws Exception {
     Main main = new Main();
     main.setValue("<некоторое meaning>");
     String valueForCheck = main.getValue();
     main.checkValue(valueForCheck);
  }

  public void setValue(String value) {
     this.value = value;
  }

  public String getValue() {
     return this.value;
  }

  public void checkValue(String value) throws Exception {
     if (value.length() > 10) {
        throw new Exception();
     }
  }
}

بنیادی طور پر ، setValue کا استعمال کرتے ہوئے ، ہم اندرونی متغیر کی قدر سیٹ کریں گے - value ، پھر getValue کا استعمال کرتے ہوئے، ہم اس قدر کو لیں گے اور checkValue میں ہم چیک کریں گے کہ آیا یہ قدر 10 حروف سے زیادہ لمبی ہے۔ اگر ہاں، تو استثنیٰ دیا جائے گا۔ اب آئیے اس پہلو کو دیکھتے ہیں جس کے ساتھ ہم طریقوں کے آپریشن کو لاگ کریں گے:

@Aspect
public class LogAspect {

  @Pointcut("execution(* *(..))")
  public void methodExecuting() {
  }

  @AfterReturning(value = "methodExecuting()", returning = "returningValue")
  public void recordSuccessfulExecution(JoinPoint joinPoint, Object returningValue) {
     if (returningValue != null) {
        System.out.printf("Успешно выполнен метод - %s, класса- %s, с результатом выполнения - %s\n",
              joinPoint.getSignature().getName(),
              joinPoint.getSourceLocation().getWithinType().getName(),
              returningValue);
     }
     else {
        System.out.printf("Успешно выполнен метод - %s, класса- %s\n",
              joinPoint.getSignature().getName(),
              joinPoint.getSourceLocation().getWithinType().getName());
     }
  }

  @AfterThrowing(value = "methodExecuting()", throwing = "exception")
  public void recordFailedExecution(JoinPoint joinPoint, Exception exception) {
     System.out.printf("Метод - %s, класса- %s, был аварийно завершен с исключением - %s\n",
           joinPoint.getSignature().getName(),
           joinPoint.getSourceLocation().getWithinType().getName(),
           exception);
  }
}

یہاں کیا ہو رہا ہے؟ @Pointcut("Execution(* *(..))") - تمام طریقوں سے تمام کالوں سے جڑے گا؛ @AfterReturning(value = "methodExecuting()", returning = "returningValue") - مشورہ جو ہدف کے طریقہ کار کے کامیابی سے مکمل ہونے کے بعد عمل میں لایا جائے گا۔ ہمارے یہاں دو صورتیں ہیں:

1. جب کسی طریقہ کی واپسی کی قدر ہوتی ہے if (returningValue != null) {
2. جب واپسی کی کوئی قیمت نہیں ہوتی ہے {

@AfterThrowing(value = "methodExecuting()", throwing = "exception") - مشورہ جو کسی خرابی کی صورت میں شروع کیا جائے گا، یعنی جب طریقہ سے کوئی استثناء پھینک دیا جائے گا۔ اور اس کے مطابق، main کو چلانے سے ، ہمیں کنسول میں لاگنگ کی ایک قسم ملے گی: ٹھیک ہے، چونکہ ہم نے استثنیٰ کو ہینڈل نہیں کیا، اس لیے ہمیں اس کا اسٹیک ٹریس بھی ملے گا: آپ ان مضامین میں مستثنیات اور ان سے نمٹنے کے بارے میں پڑھ سکتے ہیں: Java اور Exceptions میں مستثنیات اور ان کی ہینڈلنگ ۔ آج میرے لیے اتنا ہی ہے۔ آج ہم AOP سے واقف ہوئے ، اور آپ دیکھ سکتے ہیں کہ یہ جانور اتنا خوفناک نہیں جتنا اسے پینٹ کیا گیا ہے۔ سب کو الوداع!