AOP কি? দৃষ্টিভঙ্গি ভিত্তিক প্রোগ্রামিং নীতি

হাই, বন্ধুরা এবং মেয়েরা! মৌলিক ধারণাগুলি না বুঝে, কার্যকারিতা তৈরির কাঠামো এবং পদ্ধতির মধ্যে অনুসন্ধান করা বেশ কঠিন। তাই আজ আমরা এমন একটি ধারণা সম্পর্কে কথা বলব — AOP, ওরফে দৃষ্টিভঙ্গি-ভিত্তিক প্রোগ্রামিং । এই বিষয় সহজ নয় এবং খুব কমই সরাসরি ব্যবহার করা হয়, কিন্তু অনেক ফ্রেমওয়ার্ক এবং প্রযুক্তি এটি হুডের অধীনে ব্যবহার করে। এবং অবশ্যই, কখনও কখনও সাক্ষাত্কারের সময়, আপনাকে সাধারণ ভাষায় বর্ণনা করতে বলা হতে পারে এটি কী ধরণের জন্তু এবং এটি কোথায় প্রয়োগ করা যেতে পারে। তাহলে চলুন জাভাতে AOP এর মৌলিক ধারণা এবং কিছু সহজ উদাহরণ দেখে নেওয়া যাক । এখন তাহলে, AOP এর অর্থ হল দিক-ভিত্তিক প্রোগ্রামিং, যা ক্রস-কাটিং উদ্বেগগুলিকে আলাদা করে একটি অ্যাপ্লিকেশনের বিভিন্ন অংশের মডুলারিটি বাড়ানোর উদ্দেশ্যে একটি দৃষ্টান্ত। এটি সম্পন্ন করার জন্য, মূল কোডে পরিবর্তন না করেই বিদ্যমান কোডে অতিরিক্ত আচরণ যোগ করা হয়। অন্য কথায়, আমরা এটিকে পরিবর্তিত কোডে পরিবর্তন না করে পদ্ধতি এবং ক্লাসের উপরে অতিরিক্ত কার্যকারিতা ঝুলিয়ে রাখার মত ভাবতে পারি। কেন এই প্রয়োজন? শীঘ্রই বা পরে, আমরা উপসংহারে পৌঁছেছি যে সাধারণ বস্তু-ভিত্তিক পদ্ধতি সবসময় কার্যকরভাবে নির্দিষ্ট সমস্যার সমাধান করতে পারে না। এবং যখন সেই মুহূর্তটি আসে, AOP উদ্ধারে আসে এবং অ্যাপ্লিকেশন তৈরির জন্য আমাদের অতিরিক্ত সরঞ্জাম দেয়। এবং অতিরিক্ত সরঞ্জামগুলির অর্থ সফ্টওয়্যার বিকাশে নমনীয়তা বৃদ্ধি, যার অর্থ একটি নির্দিষ্ট সমস্যা সমাধানের জন্য আরও বিকল্প।

AOP প্রয়োগ করা হচ্ছে

দৃষ্টিভঙ্গি-ভিত্তিক প্রোগ্রামিং ক্রস-কাটিং কাজগুলি সম্পাদন করার জন্য ডিজাইন করা হয়েছে, যেটি যেকোন কোড হতে পারে যা বিভিন্ন পদ্ধতি দ্বারা বহুবার পুনরাবৃত্তি হতে পারে, যা সম্পূর্ণরূপে একটি পৃথক মডিউলে গঠন করা যায় না। তদনুসারে, AOP আমাদের এটিকে মূল কোডের বাইরে রাখতে এবং উল্লম্বভাবে ঘোষণা করতে দেয়। একটি উদাহরণ একটি অ্যাপ্লিকেশন একটি নিরাপত্তা নীতি ব্যবহার করা হয়. সাধারণত, নিরাপত্তা একটি অ্যাপ্লিকেশনের অনেক উপাদানের মাধ্যমে চলে। আরও কী, অ্যাপ্লিকেশনটির নিরাপত্তা নীতিটি অ্যাপ্লিকেশনের সমস্ত বিদ্যমান এবং নতুন অংশগুলিতে সমানভাবে প্রয়োগ করা উচিত। একই সময়ে, ব্যবহার করা একটি নিরাপত্তা নীতি নিজেই বিকশিত হতে পারে। এটি AOP ব্যবহার করার জন্য উপযুক্ত জায়গা । এছাড়াও, আরেকটি উদাহরণ হল লগিং. লগিং কার্যকরী ম্যানুয়ালি যোগ করার পরিবর্তে লগিং করার জন্য AOP পদ্ধতি ব্যবহার করার বিভিন্ন সুবিধা রয়েছে:

1. লগিং করার জন্য কোড যোগ করা এবং অপসারণ করা সহজ: আপনাকে যা করতে হবে তা হল কিছু কিছু কনফিগারেশন যোগ করা বা অপসারণ করা।

2. লগিং করার জন্য সমস্ত সোর্স কোড এক জায়গায় রাখা হয়, তাই আপনাকে ম্যানুয়ালি যেখানে এটি ব্যবহার করা হয় সেগুলি খুঁজে বের করার দরকার নেই৷

3. লগিং কোড যেকোন জায়গায় যোগ করা যেতে পারে, পদ্ধতি এবং ক্লাস যা ইতিমধ্যে লেখা হয়েছে বা নতুন কার্যকারিতায়। এটি কোডিং ত্রুটির সংখ্যা হ্রাস করে।

   এছাড়াও, ডিজাইন কনফিগারেশন থেকে একটি দিক সরানোর সময়, আপনি নিশ্চিত হতে পারেন যে সমস্ত ট্রেসিং কোড চলে গেছে এবং কিছুই মিস করা হয়নি।

4. দিকগুলি হল পৃথক কোড যা উন্নত এবং বারবার ব্যবহার করা যেতে পারে।

এটিকে পুনঃব্যবহারযোগ্য করার জন্য ব্যতিক্রম হ্যান্ডলিং, ক্যাশিং এবং নির্দিষ্ট কার্যকারিতা নিষ্কাশনের জন্যও AOP ব্যবহার করা হয়।

AOP এর মৌলিক নীতি

এই বিষয়ে আরও এগিয়ে যেতে, আসুন প্রথমে AOP এর মূল ধারণাগুলি জেনে নেওয়া যাক। পরামর্শ — যোগদানের পয়েন্ট থেকে ডাকা অতিরিক্ত যুক্তি বা কোড। যোগদানের পয়েন্টের আগে, পরে বা পরিবর্তে পরামর্শ দেওয়া যেতে পারে (নিচে তাদের সম্পর্কে আরও)। সম্ভাব্য ধরনের পরামর্শ :

1. আগে — টার্গেট মেথড, অর্থাৎ জয়েন পয়েন্টগুলি কার্যকর করার আগে এই ধরনের পরামর্শ চালু করা হয়। ক্লাস হিসাবে দিকগুলি ব্যবহার করার সময়, উপদেশটিকে আগে আসছে বলে চিহ্নিত করতে আমরা @Before টীকা ব্যবহার করি। .aj ফাইল হিসাবে দিকগুলি ব্যবহার করার সময় , এটি পূর্ববর্তী() পদ্ধতি হবে ।

2. আফটার — পদ্ধতিগুলি (জয়েন্ট পয়েন্ট) সম্পূর্ণ হওয়ার পরে কার্যকর করা উপদেশ, সাধারণ সঞ্চালনের পাশাপাশি একটি ব্যতিক্রম নিক্ষেপ করার সময়ও।

   ক্লাস হিসাবে দিকগুলি ব্যবহার করার সময়, আমরা @After টীকাটি ব্যবহার করতে পারি এটি নির্দেশ করার জন্য যে এটি পরে আসে।

   .aj ফাইল হিসাবে দিকগুলি ব্যবহার করার সময় , এটি after() পদ্ধতি।

3. প্রত্যাবর্তনের পরে — এই পরামর্শটি তখনই সঞ্চালিত হয় যখন লক্ষ্য পদ্ধতিটি ত্রুটি ছাড়াই স্বাভাবিকভাবে শেষ হয়।

   যখন দিকগুলিকে ক্লাস হিসাবে উপস্থাপিত করা হয়, আমরা সফলভাবে সমাপ্তির পরে পরামর্শটিকে কার্যকরী হিসাবে চিহ্নিত করতে @AfterReturning টীকা ব্যবহার করতে পারি।

   .aj ফাইল হিসাবে দিকগুলি ব্যবহার করার সময় , এটি হবে after() রিটার্নিং (অবজেক্ট অবজেক্ট) পদ্ধতি।

4. নিক্ষেপের পরে — এই পরামর্শটি এমন উদাহরণগুলির জন্য উদ্দিষ্ট যখন একটি পদ্ধতি, অর্থাৎ জয়েন পয়েন্ট, একটি ব্যতিক্রম নিক্ষেপ করে। আমরা এই পরামর্শ ব্যবহার করতে পারি নির্দিষ্ট ধরণের ব্যর্থ কার্য সম্পাদনের জন্য (উদাহরণস্বরূপ, একটি সম্পূর্ণ লেনদেন রোল ব্যাক করতে বা প্রয়োজনীয় ট্রেস স্তরের সাথে লগ করতে)।

   শ্রেণীগত দিকগুলির জন্য, @AfterThrowing টীকাটি ইঙ্গিত করতে ব্যবহৃত হয় যে এই পরামর্শটি একটি ব্যতিক্রম নিক্ষেপ করার পরে ব্যবহার করা হয়েছে।

   .aj ফাইল হিসাবে দিকগুলি ব্যবহার করার সময় , এটি হবে after() নিক্ষেপ (ব্যতিক্রম e) পদ্ধতি।

5. চারপাশে - সম্ভবত সবচেয়ে গুরুত্বপূর্ণ ধরনের পরামর্শ এক. এটি একটি পদ্ধতিকে ঘিরে থাকে, অর্থাৎ, একটি যোগ বিন্দু যা আমরা ব্যবহার করতে পারি, উদাহরণস্বরূপ, একটি প্রদত্ত যোগ বিন্দু পদ্ধতি সম্পাদন করতে হবে কিনা তা চয়ন করতে পারি।

   আপনি অ্যাডভান্স কোড লিখতে পারেন যা জয়েন পয়েন্ট পদ্ধতিটি কার্যকর করার আগে এবং পরে চলে।

   জয়েন পয়েন্ট পদ্ধতিতে কল করার জন্য আশেপাশের পরামর্শ দায়ী এবং যদি পদ্ধতিটি কিছু রিটার্ন করে তবে রিটার্ন মান। অন্য কথায়, এই পরামর্শে, আপনি কেবলমাত্র একটি টার্গেট পদ্ধতির ক্রিয়াকলাপটিকে কল না করে অনুকরণ করতে পারেন এবং ফেরত ফলাফল হিসাবে আপনি যা চান তা ফেরত দিতে পারেন।

   ক্লাস হিসাবে প্রদত্ত দিক, আমরা @Around টীকা ব্যবহার করে পরামর্শ তৈরি করি যা একটি জয়েন পয়েন্টকে মোড়ানো হয়। .aj ফাইলের আকারে দিকগুলি ব্যবহার করার সময় , এই পদ্ধতিটি প্রায় () পদ্ধতি হবে ।

জয়েন পয়েন্ট - একটি চলমান প্রোগ্রামের বিন্দু (যেমন পদ্ধতি কল, অবজেক্ট তৈরি, পরিবর্তনশীল অ্যাক্সেস) যেখানে পরামর্শ প্রয়োগ করা উচিত। অন্য কথায়, এটি কোড ইনজেকশনের জন্য জায়গাগুলি খুঁজে বের করতে ব্যবহৃত এক ধরণের নিয়মিত অভিব্যক্তি (যে জায়গাগুলিতে পরামর্শ প্রয়োগ করা উচিত)। পয়েন্টকাট — জয়েন পয়েন্টের একটি সেট । একটি পয়েন্টকাট নির্ধারণ করে যে প্রদত্ত পরামর্শ একটি প্রদত্ত জয়েন পয়েন্টে প্রযোজ্য কিনা। দৃষ্টিভঙ্গি - একটি মডিউল বা শ্রেণী যা ক্রস-কাটিং কার্যকারিতা প্রয়োগ করে। দৃষ্টিভঙ্গি কিছু পয়েন্টকাট দ্বারা সংজ্ঞায়িত জয়েন পয়েন্টগুলিতে পরামর্শ প্রয়োগ করে অবশিষ্ট কোডের আচরণ পরিবর্তন করে । অন্য কথায়, এটি পরামর্শ এবং যোগদানের পয়েন্টগুলির সংমিশ্রণ। ভূমিকা— বিদেশী কোডে দিকটির কার্যকারিতা যোগ করতে একটি শ্রেণীর কাঠামো পরিবর্তন করা এবং/অথবা উত্তরাধিকার শ্রেণিবিন্যাস পরিবর্তন করা। টার্গেট — যে বস্তুতে পরামর্শ প্রয়োগ করা হবে। বুনন - পরামর্শ দেওয়া প্রক্সি অবজেক্ট তৈরি করতে অন্যান্য বস্তুর সাথে দিকগুলিকে সংযুক্ত করার প্রক্রিয়া। এটি কম্পাইল টাইম, লোড টাইম বা রান টাইমে করা যেতে পারে। তিন ধরনের বয়ন আছে:

• কম্পাইল-টাইম উইভিং — যদি আপনার কাছে দৃষ্টিভঙ্গির সোর্স কোড এবং কোড থাকে যেখানে আপনি দিকটি ব্যবহার করেন, তাহলে আপনি সরাসরি AspectJ কম্পাইলার ব্যবহার করে সোর্স কোড এবং দিকটি কম্পাইল করতে পারেন;

• পোস্ট-কম্পাইল উইভিং (বাইনারী উইভিং) — আপনি যদি কোডের দিকগুলো বুনতে সোর্স কোড ট্রান্সফরমেশন ব্যবহার করতে না পারেন বা না চান, তাহলে আপনি আগে কম্পাইল করা ক্লাস বা জার ফাইল নিতে পারেন এবং সেগুলিতে দিকগুলো ইনজেক্ট করতে পারেন;

• লোড-টাইম উইভিং — এটি শুধুমাত্র বাইনারি উইভিং যা ক্লাসলোডার ক্লাস ফাইল লোড না করা পর্যন্ত এবং JVM-এর জন্য ক্লাস সংজ্ঞায়িত না করা পর্যন্ত বিলম্বিত হয়।

  এটি সমর্থন করার জন্য এক বা একাধিক বয়ন শ্রেণীর লোডার প্রয়োজন। এগুলি হয় সুস্পষ্টভাবে রানটাইম দ্বারা সরবরাহ করা হয় বা "উইভিং এজেন্ট" দ্বারা সক্রিয় করা হয়।

AspectJ — AOP দৃষ্টান্তের একটি সুনির্দিষ্ট বাস্তবায়ন যা ক্রস-কাটিং কার্য সম্পাদন করার ক্ষমতা প্রয়োগ করে। ডকুমেন্টেশন এখানে পাওয়া যাবে .

জাভাতে উদাহরণ

এর পরে, AOP- এর আরও ভাল বোঝার জন্য , আমরা ছোট "হ্যালো ওয়ার্ল্ড"-স্টাইলের উদাহরণগুলি দেখব। ব্যাটের ডানদিকে, আমি লক্ষ্য করব যে আমাদের উদাহরণগুলি কম্পাইল-টাইম উইভিং ব্যবহার করবে । প্রথমত, আমাদের pom.xml ফাইলে নিম্নলিখিত নির্ভরতা যোগ করতে হবে :

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

একটি নিয়ম হিসাবে, বিশেষ ajc কম্পাইলার হল কিভাবে আমরা দিকগুলি ব্যবহার করি। IntelliJ IDEA এটিকে ডিফল্টরূপে অন্তর্ভুক্ত করে না, তাই এটিকে অ্যাপ্লিকেশন কম্পাইলার হিসাবে বেছে নেওয়ার সময়, আপনাকে অবশ্যই 5168 75 AspectJ বিতরণের পথ নির্দিষ্ট করতে হবে। এই প্রথম উপায় ছিল. দ্বিতীয়টি, যা আমি ব্যবহার করেছি, তা হল 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("Tanner");
  printName("Victor");
  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("Hi, ");
  }
}

এই ফাইলটি একটি ক্লাসের মতো। আসুন দেখি এখানে কি ঘটছে: পয়েন্টকাট হল জয়েন পয়েন্টের একটি সেট; greeting() এই পয়েন্টকাটের নাম; : execution ইঙ্গিত করে যে এটি Main.printName(...) পদ্ধতির সমস্ত ( * ) কলের সম্পাদনের সময় প্রয়োগ করা হবে । এরপরে একটি নির্দিষ্ট পরামর্শ আসে — before() — যা টার্গেট মেথড কল করার আগে কার্যকর করা হয়। : greeting() হল সেই কাটপয়েন্ট যা এই পরামর্শে সাড়া দেয়। ঠিক আছে, এবং নীচে আমরা পদ্ধতির মূল অংশটি দেখি, যা জাভা ভাষায় লেখা, যা আমরা বুঝি। যখন আমরা এই দিকটি উপস্থিত দিয়ে প্রধান চালাই , তখন আমরা এই কনসোল আউটপুটটি পাব: আমরা দেখতে পাচ্ছি যে প্রিন্টনেম পদ্ধতিতে প্রতিটি কল একটি দিককে ধন্যবাদ পরিবর্তন করা হয়েছে। এখন টীকা সহ একটি জাভা ক্লাস হিসাবে দৃষ্টিভঙ্গি কেমন হবে তা একবার দেখে নেওয়া যাক:

@Aspect
public class GreetingAspect{
 
  @Pointcut("execution(* Main.printName(String))")
  public void greeting() {
  }
 
  @Before("greeting()")
  public void beforeAdvice() {
     System.out.print("Hi, ");
  }
}

.aj দৃষ্টিভঙ্গি ফাইলের পরে , সবকিছু এখানে আরও স্পষ্ট হয়ে ওঠে:

• @আসপেক্ট ইঙ্গিত করে যে এই শ্রেণীটি একটি দিক;
• @Pointcut("execution(* Main.printName(String))") হল কাটপয়েন্ট যা Main.printName- এ সমস্ত কলের জন্য একটি ইনপুট আর্গুমেন্ট সহ ট্রিগার করা হয় যার ধরন হল স্ট্রিং ;
• @Before("greeting()") হল পরামর্শ যা অভিবাদন() কাটপয়েন্টে নির্দিষ্ট কোডে কল করার আগে প্রয়োগ করা হয় ।

এই দিকটি দিয়ে প্রধান চালানো কনসোল আউটপুট পরিবর্তন করে না:

উদাহরণ নং 2

ধরুন আমাদের কাছে এমন কিছু পদ্ধতি আছে যা ক্লায়েন্টদের জন্য কিছু অপারেশন করে, এবং আমরা এই পদ্ধতিটিকে প্রধান থেকে বলি :

public class Main {
 
  public static void main(String[] args) {
  performSomeOperation("Tanner");
  }
 
  public static void performSomeOperation(String clientName) {
     System.out.println("Performing some operations for Client " + clientName);
  }
}

আসুন একটি "ছদ্ম-লেনদেন" তৈরি করতে @Around টীকাটি ব্যবহার করি:

@Aspect
public class TransactionAspect{
 
  @Pointcut("execution(* Main.performSomeOperation(String))")
  public void executeOperation() {
  }

  @Around(value = "executeOperation()")
  public void beforeAdvice(ProceedingJoinPoint joinPoint) {
     System.out.println("Opening a transaction...");
     try {
        joinPoint.proceed();
        System.out.println("Closing a transaction...");
     }
     catch (Throwable throwable) {
        System.out.println("The operation failed. Rolling back the transaction...");
     }
  }
  }

ProceedingJoinPoint অবজেক্টের অগ্রসর পদ্ধতির সাথে , পরামর্শে এর অবস্থান নির্ধারণের জন্য আমরা মোড়ানো পদ্ধতিকে বলি। অতএব, উপরের পদ্ধতির কোড joinPoint.proceed(); আগে আছে , যখন নিচের কোডটি পরে । যদি আমরা main চালাই , আমরা কনসোলে এটি পাই: কিন্তু যদি আমরা আমাদের পদ্ধতিতে নিক্ষেপ করি এবং ব্যতিক্রম করি (একটি ব্যর্থ অপারেশন অনুকরণ করতে):

public static void performSomeOperation(String clientName) throws Exception {
  System.out.println("Performing some operations for Client " + 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("<some value>");
     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 ব্যবহার করি এবং তারপরে আমরা চেকভ্যালুকে কল করি এটি 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("Successful execution: method — %s method, class — %s class, return value — %s\n",
              joinPoint.getSignature().getName(),
              joinPoint.getSourceLocation().getWithinType().getName(),
              returningValue);
     }
     else {
        System.out.printf("Successful execution: method — %s, class — %s\n",
              joinPoint.getSignature().getName(),
              joinPoint.getSourceLocation().getWithinType().getName());
     }
  }
 
  @AfterThrowing(value = "methodExecuting()", throwing = "exception")
  public void recordFailedExecution(JoinPoint joinPoint, Exception exception) {
     System.out.printf("Exception thrown: method — %s, class — %s, exception — %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- এর সাথে পরিচিত হয়েছি , এবং আপনি দেখতে পেরেছেন যে এই জন্তুটি ততটা ভীতিকর নয় যতটা মানুষ এটিকে তৈরি করে। বিদায় সবাই!