AOP ڇا آهي؟ اسپيڪٽ تي مبني پروگرامنگ بنياديات

سلام سنگت! بنيادي تصورن کي سمجھڻ کان سواءِ، ڪم ڪار جي تعمير لاءِ فريم ورڪ ۽ طريقه ڪارن ۾ داخل ٿيڻ ڪافي مشڪل آھي. تنهن ڪري اڄ اسان انهن مان هڪ جي باري ۾ ڳالهائينداسين تصور - AOP، يا aspect-oriented programming . اهو هڪ آسان موضوع ناهي ۽ اڪثر ڪري سڌو سنئون استعمال نه ڪيو ويو آهي، پر ڪيترائي فريم ورڪ ۽ ٽيڪنالاجيون ان کي هود جي تحت استعمال ڪن ٿا. ۽ يقينا، ڪڏهن ڪڏهن انٽرويو دوران توهان کي عام اصطلاحن ۾ ٻڌائڻ لاءِ چيو ويندو ته هي ڪهڙي قسم جو جانور آهي ۽ اهو ڪٿي استعمال ڪري سگهجي ٿو. سو اچو ته ڏسو بنيادي تصورات ۽ جاوا ۾ AOP جا ڪجھ سادو مثال . تنهن ڪري، AOP - aspect-oriented programming - هڪ نمونو آهي جنهن جو مقصد هڪ ايپليڪيشن جي مختلف حصن جي ماڊليت کي وڌائڻ آهي پار ڪٽنگ خدشات کي الڳ ڪندي. هن کي ڪرڻ لاء، اصل ڪوڊ کي تبديل ڪرڻ کان سواء، موجوده ڪوڊ ۾ اضافي رويي شامل ڪيو ويو آهي. ٻين لفظن ۾، اسان نظر ثاني ٿيل ڪوڊ ۾ ترميم ڪرڻ کان سواءِ طريقن ۽ طبقن جي چوٽي تي اضافي ڪارڪردگيءَ کي لٽڪائي رهيا آهيون. اهو ڇو ضروري آهي؟ جلد يا بعد ۾ اسان ان نتيجي تي پهچون ٿا ته معمولي اعتراض تي مبني روش هميشه ڪجهه مسئلن کي مؤثر طريقي سان حل نه ڪري سگهي. اهڙي وقت، AOP بچاء لاء اچي ٿو ۽ اسان کي ايپليڪيشن ٺاهڻ لاء اضافي اوزار ڏئي ٿو. ۽ اضافي اوزار جو مطلب آهي ترقي ۾ لچڪ وڌائي، جنهن جي مهرباني، خاص مسئلي کي حل ڪرڻ لاء وڌيڪ اختيار آهن.

AOP جي درخواست

Aspect-oriented programming is designed to solve the cross-cut problems, that can be a code that do many times in different ways, which can not be formed in the completely structured in a different module. ان جي مطابق، AOP سان اسان هن کي ڇڏي سگھون ٿا مکيه ڪوڊ کان ٻاهر ۽ ان کي عمودي طور بيان ڪريون ٿا. هڪ مثال هڪ ايپليڪيشن ۾ سيڪيورٽي پاليسي جي درخواست آهي. عام طور تي، ايپليڪيشن جي ڪيترن ئي عناصرن ۾ سيڪيورٽي ڪٽ. ان کان علاوه، ايپليڪيشن سيڪيورٽي پاليسي لاڳو ٿيڻ لازمي آهي ايپليڪيشن جي سڀني موجوده ۽ نئين حصن تي. ساڳئي وقت، استعمال ٿيل سيڪيورٽي پاليسي پاڻ کي ترقي ڪري سگهي ٿي. اهو آهي جتي AOP جو استعمال هٿ ۾ اچي سگهي ٿو . پڻ هڪ ٻيو مثال لاگنگ آهي . دستي طور تي لاگنگ داخل ڪرڻ جي مقابلي ۾ لاگنگ لاءِ AOP طريقي کي استعمال ڪرڻ جا ڪيترائي فائدا آھن:

1. لاگنگ ڪوڊ لاڳو ڪرڻ ۽ ختم ڪرڻ آسان آهي: توهان کي صرف ڪجهه پهلو جي ترتيبن جي هڪ جوڙي کي شامل ڪرڻ يا ختم ڪرڻ جي ضرورت آهي.
2. لاگنگ لاءِ سڀ سورس ڪوڊ هڪ جاءِ تي محفوظ ٿيل آهي ۽ دستي طور استعمال جي سڀني جڳهن کي ڳولڻ جي ضرورت ناهي.
3. لاگنگ لاءِ ارادو ڪيو ويو ڪوڊ ڪٿي به شامل ڪري سگھجي ٿو، اھو اڳ ۾ ئي لکيل طريقو ۽ ڪلاس يا نئين ڪارڪردگي. هي ڊولپر جي غلطين جو تعداد گھٽائي ٿو.
   انهي سان گڏ، جڏهن توهان ڊزائن جي جوڙجڪ مان هڪ پاسو هٽايو ٿا، توهان بلڪل پڪ ڪري سگهو ٿا ته سڀ ٽريس ڪوڊ هٽايو ويو آهي ۽ ڪجهه به غائب ناهي.
4. پہلو اڪيلا ڪوڊ آهن جيڪي ٻيهر استعمال ڪري سگھجن ٿا ۽ بار بار بهتر ڪري سگھجن ٿا.

AOP پڻ استعمال ڪيو ويندو آهي استثنا هينڊلنگ، ڪيشنگ، ۽ ڪجهه ڪارڪردگي کي ختم ڪرڻ لاء ان کي ٻيهر استعمال ڪرڻ لاء.

AOP جا بنيادي تصور

موضوع جي تجزيي ۾ اڳتي وڌڻ لاء، اچو ته پهرين AOP جي بنيادي مفهومن سان واقف ٿي وڃو. صلاح اضافي منطق آهي، ڪوڊ، جنهن کي ڪنيڪشن پوائنٽ کان سڏيو ويندو آهي. مشوري کان اڳ، بعد ۾ يا ڪنيڪشن پوائنٽ جي بدران ٿي سگهي ٿو (انهن تي وڌيڪ هيٺ ڏنل). نصيحت جا ممڪن قسم :

1. اڳ (اڳ) - ھدف جي طريقن جي عمل کان اڳ ھن قسم جي صلاح شروع ڪئي وئي آھي - ڪنيڪشن پوائنٽون. جڏهن پهلوئن کي ڪلاس طور استعمال ڪيو وڃي، اسان وٺون ٿا @Before تشريح کي نشان ھڻڻ لاءِ مشوري جي قسم کي جيئن اڳي اچي رھيو آھي. جڏهن .aj فائلن جي طور تي پهلو استعمال ڪندي ، اهو ٿيندو اڳي () طريقو .
2. بعد ۾ (بعد ۾) - مشوري جيڪا عمل جي مڪمل ٿيڻ کان پوءِ ڏني ويندي آهي طريقن جي - ڪنيڪشن پوائنٽس، ٻئي عام حالتن ۾ ۽ جڏهن هڪ استثنا اڇلايو ويندو آهي.
   جڏهن پهلوئن کي ڪلاس طور استعمال ڪريون ٿا، اسان استعمال ڪري سگھون ٿا @After تشريح انهي ڳالهه کي ظاهر ڪرڻ لاءِ ته هي هڪ ٽپ آهي جيڪو بعد ۾ اچي ٿو. جڏهن .aj
   فائلن جي طور تي پهلو استعمال ڪندي ، اهو ٿيندو after() طريقو .
3. موٽڻ کان پوءِ - اهي ٽوٽڪا صرف ان صورت ۾ لاڳو ڪيا ويندا آهن جڏهن ٽارگيٽ جو طريقو عام طور تي ڪم ڪري، بغير ڪنهن غلطي جي.
   جڏهن پهلوئن کي طبقن جي طور تي پيش ڪيو وڃي ٿو، اسان استعمال ڪري سگھون ٿا @AfterReturning تشريح کي نشان ھڻڻ لاءِ جيئن مشوري کي ڪامياب مڪمل ٿيڻ تي عمل ڪيو وڃي.
   جڏهن .aj فائلن جي طور تي پہلو استعمال ڪندي، اهو ٿيندو after() طريقو واپسي (Object obj) .
4. اڇلائڻ کان پوء - هن قسم جي صلاح انهن ڪيسن لاء آهي جڏهن هڪ طريقو، اهو آهي، ڪنيڪشن پوائنٽ، هڪ استثنا اڇلائي ٿو. اسان ھي مشوري استعمال ڪري سگھون ٿا ڪجھ ھٿ ڪرڻ لاءِ ناڪامي تي عمل ڪرڻ لاءِ (مثال طور، سڄي ٽرانزيڪشن کي واپس ڪرڻ يا گھربل ٽريس ليول سان لاگ ان ڪرڻ).
   اسپيڪٽ ڪلاسز لاءِ، @AfterThrowing تشريح استعمال ڪئي ويندي آهي اشارو ڏيڻ لاءِ ته هي مشورو استعمال ڪيو ويندو آهي هڪ استثنا اڇلائڻ کان پوءِ. جڏهن .aj
   فائلن جي صورت ۾ پهلو استعمال ڪندي ، اهو طريقو ٿيندو - after() اڇلائڻ (Exception e) .
5. آس پاس شايد مشوري جي سڀ کان اهم قسمن مان هڪ آهي جيڪو هڪ طريقي جي چوڌاري آهي، اهو آهي، هڪ ڪنيڪشن پوائنٽ، جنهن سان اسين، مثال طور، چونڊي سگھون ٿا ته ڏنل ڪنيڪشن پوائنٽ جي طريقي تي عمل ڪرڻ يا نه.
   توھان لکي سگھو ٿا مشوري ڪوڊ جيڪو ھلندو آھي ان کان اڳ ۽ پوءِ جوائن پوائنٽ جو طريقو عمل ۾ اچي ٿو. مشوري جي
   ذميدارين ۾ شامل ٿيڻ واري پوائنٽ جي طريقي کي ڪال ڪرڻ ۽ قيمتون واپس ڪرڻ شامل آھن جيڪڏھن طريقو ڪجھھ موٽائي ٿو. اهو آهي، هن ٽپ ۾ توهان آساني سان ٽارگيٽ طريقي جي عمل کي بغير بغير بغير ڪنهن کي سڏڻ جي نقل ڪري سگهو ٿا، ۽ نتيجي ۾ توهان جي پنهنجي شيء کي واپس ڪري سگهو ٿا. طبقن جي شڪل ۾ پهلوئن لاءِ، اسان @Around تشريح استعمال ڪندا آهيون ٽوٽڪا ٺاهڻ لاءِ جيڪي ڪنيڪشن پوائنٽ کي لپيٽيون. جڏهن .aj فائلن جي طور تي پاسن کي استعمال ڪندي ، اهو ٿيندو چوڌاري () طريقو .
   

شامل ٿيڻ واري نقطي - هڪ عمل ڪندڙ پروگرام ۾ هڪ نقطو (هڪ طريقو سڏڻ، هڪ اعتراض ٺاهڻ، هڪ متغير تائين رسائي) جتي مشورو لاڳو ڪيو وڃي. ٻين لفظن ۾، هي هڪ قسم جو باقاعده اظهار آهي، جنهن جي مدد سان ڪوڊ متعارف ڪرائڻ لاء جڳهون (جڳهون تجويزون لاڳو ڪرڻ) مليا آهن. پوائنٽ کٽ ڪنيڪشن پوائنٽن جو هڪ سيٽ آهي . ڪٽ اهو طئي ڪري ٿو ته ڇا ڏنل ڪنيڪشن پوائنٽ ڏنل ٽپ سان ٺهڪي اچي ٿو. Aspect ھڪڙو ماڊل يا ڪلاس آھي جيڪو آخر کان آخر تائين ڪارڪردگي کي لاڳو ڪري ٿو. هڪ پاسو باقي ڪوڊ جي رويي کي تبديل ڪري ٿو شامل ٿيڻ واري پوائنٽن تي صلاح لاڳو ڪندي ڪجهه سلائس پاران بيان ڪيل . ٻين لفظن ۾، اهو ٽوڪن ۽ ڪنيڪشن پوائنٽن جو هڪ ميلاپ آهي. تعارف - ھڪڙي طبقي جي جوڙجڪ کي تبديل ڪرڻ ۽ / يا غير ملڪي ڪوڊ ۾ پہلو ڪارڪردگي کي شامل ڪرڻ لاء وراثت واري درجي کي تبديل ڪرڻ. ھدف اھو اعتراض آھي جنھن تي مشوري لاڳو ڪئي ويندي. Weaving تجويز ڪيل پراکسي شيون ٺاهڻ لاء ٻين شين سان حصن کي ڳنڍڻ جو عمل آهي. اهو ڪمپلي وقت، لوڊ وقت، يا هلائڻ وقت تي ٿي سگهي ٿو. ڪپڙي جا ٽي قسم آهن:

• Compile-time weaving - جيڪڏهن توهان وٽ هڪ پاسو جو سورس ڪوڊ آهي ۽ اهو ڪوڊ جنهن ۾ توهان پهلو استعمال ڪندا آهيو، توهان سڌو سنئون اسپيڪٽ جي ڪمپلر کي استعمال ڪندي سورس ڪوڊ ۽ اسپيڪٽ کي مرتب ڪري سگهو ٿا؛
• پوسٽ-ڪمپليشن ويونگ (بائنري ويونگ) - جيڪڏهن توهان نٿا ڪري سگهو يا نه ٿا چاهيو ته سورس ڪوڊ ٽرانسفارميشن کي استعمال ڪرڻ لاءِ توهان جي ڪوڊ ۾ پهلون کي ورجائڻ لاءِ، توهان اڳ ۾ ئي مرتب ڪيل ڪلاس يا جار وٺي سگهو ٿا ۽ انجيڪشن جا حصا وٺي سگهو ٿا؛
• load-time weaving صرف binary weaving آهي ملتوي ڪئي وئي جيستائين ڪلاس لوڊر ڪلاس فائل لوڊ نه ڪري ۽ 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 distribution جو رستو . توھان وڌيڪ پڙھي سگھوٿا ھن صفحي تي 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 صاف ڪمپلي کي هلائڻ . هاڻي اچو ته مثالن ڏانهن وڃو.

مثال نمبر 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 جي طاقت جو فائدو وٺڻ جو. هاڻي اسان کي فائل ٺاهڻ جي ضرورت آهي - aspect . اهي ٻن قسمن ۾ اچن ٿا: پهرين هڪ فائل آهي .aj ايڪسٽينشن سان ، ٻيو هڪ باقاعده طبقو آهي جيڪو لاڳو ڪري ٿو AOP صلاحيتون تشريحون استعمال ڪندي. اچو ته پهرين .aj ايڪسٽينشن سان فائل ڏسون :

public aspect GreetingAspect {

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

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

ھي فائل ڪجھھ ھڪڙي طبقي وانگر آھي. اچو ته ڄاڻون ته هتي ڇا ٿي رهيو آهي: پوائنٽ کٽ - هڪ ڪٽ يا ڪنيڪشن پوائنٽن جو هڪ سيٽ؛ سلام () - هن سلائس جو نالو؛ : execution - جڏھن executing * - all، call - Main.printName(..) - ھي طريقو. اڳيان اچي ٿو مخصوص صلاح - before() - جيڪو ھدف جي طريقي کي سڏڻ کان اڳ عمل ڪيو ويندو آھي، : greeting() - اھو سليس جنھن تي ھي مشوري رد ڪري ٿي، ۽ ھيٺ اسين ڏسون ٿا پاڻ طريقي جي جسم، جيڪو جاوا ۾ لکيل آھي. ٻولي اسان سمجھون ٿا. جڏهن اسان هن پاسو موجود سان مکيه هلون ٿا ، اسان ڪنسول ڏانهن هيٺين آئوٽ حاصل ڪنداسين: اسان ڏسي سگھون ٿا ته هر ڪال کي printName طريقي سان تبديل ڪيو ويو آهي هڪ پاسو. هاڻي اچو ته هڪ نظر رکون ته اهو پاسو ڪهڙو نظر ايندو، پر جاوا ڪلاس جي تشريح سان:

@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 طريقي کي استعمال ڪندي ، اسان بورڊ ۾ ان جي جاءِ جو تعين ڪرڻ لاءِ ريپر جي طريقي کي سڏيندا آهيون ۽ ان مطابق، مٿي ڏنل طريقي ۾ ڪوڊ جوائنپوائنٽ.proceed(); - هي اڳ آهي ، جيڪو هيٺ ڏنل آهي - بعد ۾ . جيڪڏهن اسان مکيه هلون ٿا ته اسان ڪنسول ۾ حاصل ڪنداسين: جيڪڏهن اسان پنهنجي طريقي ۾ هڪ استثنا شامل ڪيو (اوچتو آپريشن ناڪام ٿئي ٿو):

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

ان کان پوء اسان ڪنسول ۾ پيداوار حاصل ڪنداسين: اها ناڪامي جي هڪ pseudo-processing ٿي ٻاهر موٽيو.

مثال نمبر 3

ايندڙ مثال طور، اچو ته ڪنسول ۾ لاگ ان ٿيڻ وانگر ڪجهه ڪريون. پهرين، اچو ته ڏسو Main ، جتي اسان جو pseudo business logic ٿئي ٿو:

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 استعمال ڪندي ، اسان اندروني متغير جي قيمت مقرر ڪنداسين - قدر ، پوء 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. جڏهن هڪ طريقو هڪ موٽڻ جي قيمت آهي جيڪڏهن (returningValue != null) {
2. جڏهن ڪو به واپسي قدر نه آهي ٻيو {

@AfterThrowing(value = "methodExecuting()"، throwing = "exception") - صلاح جيڪا ڪنھن نقص جي صورت ۾ شروع ڪئي ويندي، اھو آھي، جڏھن ھڪڙي استثنا کي طريقي مان اڇلايو وڃي. ۽ مطابق، هلائڻ سان main ، اسان کي کنسول ۾ لاگنگ جو هڪ قسم حاصل ڪنداسين: خير، جيئن ته اسان استثنا کي نه سنڀاليو، اسان ان جو اسٽيڪ ٽريڪ پڻ حاصل ڪنداسين: توهان انهن مضمونن ۾ استثنا ۽ انهن جي سنڀال بابت پڙهي سگهو ٿا: جاوا ۾ استثنا ۽ استثنا ۽ انهن جي سنڀال . اهو سڀ ڪجهه اڄ منهنجي لاءِ آهي. اڄ اسان AOP سان واقف ٿي چڪا آهيون ، ۽ توهان ڏسي سگهو ٿا ته هي جانور ايترو خوفناڪ نه آهي جيترو اهو رنگيل آهي. سڀني کي الوداع!