في هذا المنشور، سنقوم بإزالة الغموض عن الآليات الداخلية للبرمجة الموجهة نحو الجوانب (AOP) في الربيع. سيكون التركيز على فهم كيفية تحقيق AOP لوظائف مثل التسجيل، والتي غالبًا ما تعتبر شكلاً من أشكال "السحر". من خلال الاطلاع على تطبيق Java الأساسي، سنرى كيف أن الأمر كله يتعلق بانعكاس Java وأنماط الوكيل والتعليقات التوضيحية بدلاً من أي شيء سحري حقًا.

المتطلبات الأساسية

• واجهة برمجة تطبيقات Java Core Proxy
• واجهة برمجة تطبيقات الانعكاس
• واجهة برمجة تطبيقات التعليقات التوضيحية

هذه كلها جزء من حزم java.lang.reflect وjava.lang.annotation وjavassist.util.proxy.

الآلية الأساسية

في قلب Spring AOP يكمن مفهوم الكائنات الوكيلة ومعترضات الطريقة والانعكاس. اللاعب الرئيسي في هذا النمط هو MethodHandler (أو معالج الاستدعاء). يتحكم هذا المعالج في سلوك كائن الوكيل عن طريق اعتراض استدعاءات الطريقة. عندما يتم استدعاء أسلوب ما على الوكيل، يتم تمريره عبر المعالج، حيث يمكن استبطان التعليقات التوضيحية عبر الانعكاس. واستنادا إلى التعليقات التوضيحية المطبقة، يمكن تنفيذ المنطق الضروري (على سبيل المثال، التسجيل) قبل أو بعد أو عند الاستثناء.

كسرها

1. كائنات الوكيل: هذه كائنات تم إنشاؤها ديناميكيًا لتحل محل كائنات عملك الفعلية، وتستدعي أسلوب التوجيه من خلال معالج الأسلوب.
2. معالجات الاستدعاء: هذا هو المكان الذي يحدث فيه سحر الاعتراض. باستخدام الانعكاس، يمكن للمعالج فحص التعليقات التوضيحية الموجودة في الطريقة المستهدفة وتغيير السلوك وفقًا لذلك.
3. التعليقات التوضيحية المخصصة: يمكنك تحديد التعليقات التوضيحية المخصصة، والتي تعمل كعلامات لتشغيل وظائف إضافية مثل التسجيل أو فحوصات الأمان أو إدارة المعاملات.

مثال: لنفترض أننا نريد إضافة التسجيل قبل وبعد عمليات تنفيذ طريقة معينة. بدلاً من التسجيل الثابت في كل مكان، يمكننا إضافة تعليقات توضيحية للطرق باستخدام @BeforeMethod و@AfterMethod. يقوم معالجنا بفحص طريقة هذا التعليق التوضيحي ويضيف منطق التسجيل المناسب ديناميكيًا.

فيما يلي الفئات التي تبدو عليها وحدة التحكم والخدمة في مثالنا.

WorkerController.java

package edu.pk.poc.aop.controller;

import edu.pk.poc.aop.annotation.AfterMethod;
import edu.pk.poc.aop.annotation.All;
import edu.pk.poc.aop.annotation.BeforeMethod;
import edu.pk.poc.aop.helper.ProxyFactory;
import edu.pk.poc.aop.service.Worker;
import edu.pk.poc.aop.service.WorkerService;
import edu.pk.poc.aop.service.WorkerServiceImpl;

public class WorkerController {
    WorkerService workerService = ProxyFactory.createProxy(WorkerServiceImpl.class);
    /**
     * This Method 1s annotated with @BeforeMethod and @AfterMethod, So the log statements
     * will be generated before and after method call.
     */
    @BeforeMethod
    @AfterMethod
    public void engageFullTimeWorker() throws Exception {
        Worker fullTimeWorker = new Worker();
        fullTimeWorker.setName("FullTime-Worker");
        fullTimeWorker.setPartTime(false);
        fullTimeWorker.setDuration(9);
        workerService.doWork(fullTimeWorker);
    }
    /**
     * This Method is annotated with @All, So the log statements will be generated before and after method call
     * along with exception if raised.
     */
    @All
    public void engagePartTimeWorker() throws Exception {
        Worker partTimeWorker = new Worker();
        partTimeWorker.setName("PartTime-Worker");
        partTimeWorker.setPartTime(true);
        partTimeWorker.setDuration(4);
        workerService.doWork(partTimeWorker);
    }
}

WorkerServiceImpl.java

package edu.pk.poc.aop.service;

import edu.pk.poc.aop.annotation.AfterMethod;

public class WorkerServiceImpl implements WorkerService {
    /**
     * Here this method is annotated with only @AfterMethod, So only log statement
     * will be generated after method call
     */
    @AfterMethod
    @Override
    public void doWork(Worker worker) throws Exception {
        if (worker.isPartTime()) {
            throw new Exception("Part time workers are not permitted to work.");
        }
        System.out.print("A full time worker is working for "   worker.getDuration()   " hours :: ");
        for (int i = 1; i 



  فئة اختبار Main.java  


package edu.pk.poc.aop.test;

import edu.pk.poc.aop.controller.WorkerController;
import edu.pk.poc.aop.helper.ProxyFactory;
import edu.pk.util.Logger;

public class Main {
    public static void main(String[] args) {
        WorkerController controller = ProxyFactory.createProxy(WorkerController.class);
        Logger logger = new Logger();
        try {
            System.out.println("Testing @BeforeMethod and @AfterMethod");
            System.out.println("-----------------------------------------");
            controller.engageFullTimeWorker();
            System.out.println("Testing @All");
            System.out.println("-----------------------------------------");
            controller.engagePartTimeWorker();
        } catch (Exception e) {
            logger.error("Exception caught in Main class");
        }
    }
}




الإخراج


Testing @BeforeMethod and @AfterMethod
-----------------------------------------
>>> Entering into edu.pk.poc.aop.controller.WorkerController.engageFullTimeWorker()
A full time worker is working for 9 hours :: * * * * * * * * 
>>> Exiting from edu.pk.poc.aop.service.WorkerServiceImpl.doWork()
>>> Exiting from edu.pk.poc.aop.controller.WorkerController.engageFullTimeWorker()
Testing @All
-----------------------------------------
>>> Entering into edu.pk.poc.aop.controller.WorkerController.engagePartTimeWorker()
>>> Exception in edu.pk.poc.aop.controller.WorkerController.engagePartTimeWorker()
Exception caught in Main class





  
  
  كيف يعمل


 عندما يتم استدعاء أسلوب ما على كائن وكيل، يتم اعتراض المكالمة بواسطة المعالج، الذي يستخدم الانعكاس لفحص جميع التعليقات التوضيحية على الأسلوب الهدف. بناءً على هذه التعليقات التوضيحية، يقرر المعالج ما إذا كان سيتم تسجيل الدخول/الخروج من الطريقة، أو تسجيل الاستثناءات، أو تخطي التسجيل تمامًا.

إليك كيف يمكنك تصور ذلك:

• قبل التنفيذ: إدخال طريقة السجل.
• بعد التنفيذ: الخروج من طريقة السجل أو النجاح.
• الكل: إدخال طريقة السجل وإدخال الطريقة والاستثناء إذا تم رفعه. يُظهر هذا السلوك الديناميكي أن Spring AOP يستفيد من واجهات برمجة تطبيقات Java الأساسية بدلاً من استخدام بعض الحيل السحرية.

تحديد التعليقات التوضيحية

package edu.pk.poc.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AfterMethod {

}

package edu.pk.poc.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BeforeMethod {

}

package edu.pk.poc.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface All {

}

تعريف مصنع الوكيل

package edu.pk.poc.aop.helper;

/**
 * The {@code ProxyFactory} class is responsible for creating proxy objects using the Javassist library.
 * It allows for dynamic generation of proxies for classes or interfaces, with support for method interception.
 */
public class ProxyFactory {

    /**
     * A Javassist ProxyFactory instance used to generate proxy classes.
     */
    private static final javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory();

    /**
     * Creates a proxy object for the given class or interface.
     * If the class is an interface, the proxy implements the interface.
     * If it's a concrete class, the proxy extends the class.
     *
     * @param    the type of the class or interface for which the proxy is to be created
     * @param klass the {@code Class} object representing the class or interface to proxy
     * @return a proxy instance of the specified class or interface, or {@code null} if proxy creation fails
     */
    public static  T createProxy(Class klass) {
        if (klass.isInterface())
            factory.setInterfaces(new Class[]{klass});
        else
            factory.setSuperclass(klass);
        try {
            return (T) factory.create(new Class>[0], new Object[0], new AOPLoggingMethodHandler());
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return null;
    }
}

تعريف معالج الطريقة

package edu.pk.poc.aop.helper;

import edu.pk.poc.aop.annotation.AfterMethod;
import edu.pk.poc.aop.annotation.All;
import edu.pk.poc.aop.annotation.BeforeMethod;
import edu.pk.poc.aop.annotation.OnException;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import edu.pk.util.Logger;
import javassist.util.proxy.MethodHandler;

public class AOPLoggingMethodHandler implements MethodHandler {

    private static final Logger logger = new Logger();

    public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
        if (proceed != null) { // Concrete Method
            Object result = null;
            String className = resolveClassName(self);
            try {
                if (isAnnotationPresent(thisMethod, BeforeMethod.class) || isAnnotationPresent(thisMethod, All.class)) {
                    logger.info(">>> Entering into "   className   "."   thisMethod.getName()   "()");
                }
                result = proceed.invoke(self, args);
                if (isAnnotationPresent(thisMethod, AfterMethod.class) || isAnnotationPresent(thisMethod, All.class)) {
                    logger.info(">>> Exiting from "   className   "."   thisMethod.getName()   "()");
                }
            } catch (Throwable t) {
                if (isAnnotationPresent(thisMethod, OnException.class) || isAnnotationPresent(thisMethod, All.class)) {
                    logger.error(">>> Exception in "   className   "."   thisMethod.getName()   "()");
                }
                throw t;
            }
            return result;
        }
        throw new RuntimeException("Method is Abstract");
    }

    private boolean isAnnotationPresent(Method method, Class klass) {
        Annotation[] declaredAnnotationsByType = method.getAnnotationsByType(klass);
        return declaredAnnotationsByType != null && declaredAnnotationsByType.length > 0;
    }

    private String resolveClassName(Object self) {
        String className = self.getClass().getName();
        if (className.contains("_$$")) {
            className = className.substring(0, className.indexOf("_$$"));
        }
        return className;
    }
}

خاتمة

Spring AOP هي أداة قوية للمخاوف الشاملة، لكنها لا تفعل أي شيء ثوري. إنها مبنية على مفاهيم Java الأساسية مثل الانعكاس والوكلاء، المتوفرة في اللغة نفسها. من خلال فهم ذلك، يمكنك أن تقدر بشكل أفضل كيف يبسط Spring هذه الآليات ذات المستوى الأدنى لراحة المطورين.