Programación Orientada a Aspectos y AOP en Spring Framework

La programación orientada a aspectos (AOP) , como su nombre indica, utiliza aspectos en la programación. Se puede definir como la división del código en diferentes módulos, también conocida como modularización , donde el aspecto es la unidad clave de la modularidad. Los aspectos permiten la implementación de preocupaciones transversales, como transacciones, el registro no es central para la lógica comercial sin saturar el núcleo del código para su funcionalidad. Lo hace agregando un comportamiento adicional que es el consejo para el código existente. Por ejemplo, la seguridad es una preocupación transversal, en muchos métodos en una aplicación se pueden aplicar reglas de seguridad, por lo tanto, repetir el código en cada método, definir la funcionalidad en una clase común y controlar dónde aplicar esa funcionalidad en toda la aplicación.

Marcos dominantes en AOP:
AOP incluye métodos de programación y marcos en los que se admite e implementa la modularización del código. Echemos un vistazo a los tres marcos dominantes en AOP :

AspectJ: Es una extensión para programación Java creada en el centro de investigación PARC . Utiliza una sintaxis similar a Java e incluye integraciones IDE para mostrar la estructura transversal. Tiene su propio compilador y tejedor, al usarlo permite el uso completo del lenguaje AspectJ.
JBoss: Es un servidor de aplicaciones Java de código abierto desarrollado por JBoss, utilizado para el desarrollo de Java.
Spring : utiliza una configuración basada en XML para implementar AOP, también utiliza anotaciones que se interpretan mediante el uso de una biblioteca proporcionada por AspectJ para analizar y comparar.

Actualmente, las bibliotecas de AspectJ con el marco Spring son dominantes en el mercado, por lo tanto, comprendamos cómo funciona la programación orientada a aspectos con Spring.

Cómo funciona la programación orientada a aspectos con Spring:
uno puede pensar que invocar un método implementará automáticamente preocupaciones transversales, pero ese no es el caso. La simple invocación del método no invoca el consejo (el trabajo que debe realizarse). Spring utiliza un mecanismo basado en proxy, es decir, crea un objeto proxy que envolverá el objeto original y tomará el consejo que es relevante para la llamada al método. Los objetos de proxy se pueden crear manualmente a través del bean de fábrica de proxy o mediante la configuración automática de proxy en el archivo XML y se destruyen cuando se completa la ejecución. Los objetos proxy se utilizan para enriquecer el comportamiento original del objeto real.

Terminologías comunes en AOP:

Aspecto: la clase que implementa las preocupaciones transversales de la aplicación JEE (transacción, registrador, etc.) se conoce como el aspecto. Puede ser una clase normal configurada a través de la configuración XML o mediante clases regulares anotadas con @Aspect.

Tejido: El proceso de vincular Aspectos con un Objeto Aconsejado. Se puede hacer en tiempo de carga, tiempo de compilación o en tiempo de ejecución. Spring AOP teje en tiempo de ejecución.

Escribamos nuestra primera clase de aspecto, pero antes de eso, eche un vistazo a los archivos jar necesarios y al archivo de configuración de Bean para AOP.

package com.aspect
  
    import org.aspectj.lang.annotation.Aspect;
import Java.lang.RuntimeException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
  
// Logging class is anotated with @Aspect
// and will contain advices.
@Aspect
class Logging {
}
  
// The class ImplementAspect
// contains method Aspectcall
// and the advices will be applied
// on that method for demo.
public class ImplementAspect {
    public static void main(String args[])
    {
  
        Scanner sc = new Scanner(System.in);
        System.out.println("my first aspect");
  
        // **Add beanconfiguration file
        // in your programme when executing.**
        ApplicationContext ctx
            = new ClassPathXmlApplicationContext("beanconfigfile.XML");
  
        ImplementAspect call
            = (ImplementAspect)ctx.getbean("aspect");
  
        System.out.println("enter an integer");
        int a = sc.nextInt();
        if (a == 1) {
            throw new RuntimeException(msg);
        }
        else {
            call.aspectCall();
        }
        call.myMethod();
    }
  
    public void aspectCall()
    {
        System.out.println("Applying advices"
                           + " for the first time");
    }
  
    public void myMethod()
    {
        System.out.println("This is an"
                           + " extra method");
    }
}

Consejo: El trabajo que debe realizar un Aspecto o puede definirse como la acción realizada por el Aspecto en un punto particular. Hay cinco tipos de consejos, a saber: antes, después, alrededor, después de tirar y después de devolver. Tengamos una breve discusión sobre los cinco tipos.
Tipos de consejos:
Antes: se ejecuta antes de que se invoque el método recomendado. Se denota por @Antes de la anotación.
Después: se ejecuta después de que se complete el método recomendado, independientemente del resultado, ya sea exitoso o no. Se indica mediante la anotación @After .
AfterReturning: se ejecuta después de que el método recomendado se complete con éxito, es decir, sin excepciones de tiempo de ejecución. Se indica mediante la anotación @AfterReturning .
Around: este es el consejo más fuerte entre todos los consejos, ya que se ejecuta antes y después del método recomendado. Este tipo de consejo se usa cuando necesitamos acceso frecuente a un método o base de datos como el almacenamiento en caché. Se indica mediante la anotación @Around .
AfterThrowing: se ejecuta después de que el método recomendado lanza una excepción de tiempo de ejecución. Se indica mediante la anotación @AfterThrowing .

Implementemos los cinco consejos en nuestro registrador de clase de aspecto

// Program to show types of Advices
  
@Aspect
class Logging {
  
    // Implementing all the five pieces of advice
    // to execute AfterThrowing advice enter integer value as 1.
  
    // **Before**
    @Before("execution(public void com.aspect.ImplementAspect.aspectCall())")
    public void loggingAdvice1()
    {
        System.out.println("Before advice is executed");
    }
  
    // **After**
    @After("execution(public void com.aspect.ImplementAspect.aspectCall())")
    public void loggingAdvice2()
    {
        System.out.println("Running After Advice.");
    }
  
    // **Around**
    @Around("execution(public void com.aspect.ImplementAspect.myMethod())")
    public void loggingAdvice3()
    {
        System.out.println("Before and After invoking method myMethod");
    }
  
    // **AfterThrowing**
    @AfterThrowing("execution(" public void com.aspect.ImplementAspect.aspectCall())
    ")
        public void
        loggingAdvice4()
    {
        System.out.println("Exception thrown in method");
    }
  
    // **AfterRunning**
    @AfterReturning("execution(public void com.aspect.ImplementAspect.myMethod())")
    public void loggingAdvice5()
    {
        System.out.println("AfterReturning advice is run");
    }
}

JoinPoints: Una aplicación tiene miles de oportunidades o puntos para aplicar Consejos. Estos puntos se conocen como puntos de unión. Por ejemplo, los consejos se pueden aplicar en cada invocación de un método o excepción lanzada o en varios otros puntos. Pero Spring AOP actualmente solo admite puntos de unión de ejecución de métodos (recomendando la ejecución de métodos en Spring beans).

Veamos qué hace un punto de unión en nuestra clase @Aspect(Logger)

// Program to show JoinPoints
  
@Aspect
class Logging {
  
    // Passing a JoinPoint Object
    // into parameters of the method
    // with the annotated advice
    // enables to print the information
    /// when the advice is executed
    // with the help of toString() method
    // present in it.
  
    @Before("execution(public void com.aspect.ImplementAspect.aspectCall())")
    public void loggingAdvice1(JoinPoint joinpoint)
    {
        System.out.println("Before advice is executed");
        System.out.println(joinpoint.toString());
    }
}

Pointcut: dado que no es factible aplicar consejos en todos los puntos del código, por lo tanto, los puntos de unión seleccionados donde finalmente se aplican los consejos se conocen como Pointcut. A menudo, estos puntos de corte se especifican mediante nombres de métodos y clases explícitos o mediante expresiones regulares que definen patrones de nombres de métodos y clases coincidentes. Ayuda a reducir la repetición de código escribiendo una vez y usándolo en múltiples puntos, veamos cómo.

// Program to shgw PointCuts
  
@Aspect
class Logging {
  
    // pointcut() is a dummy method
    // required to hold @Pointcut annotation
    // pointcut() can be used instead of writing line 1
    // whenever required, as done in line 4.
    // This prevents a repetition of code.
  
    @Pointcut("execution(public void com.aspect.ImplementAspect.aspectCall())") // line 1
    public void pointCut()
    {
    }
  
    // pointcut() is used to avoid repetition of code
    @Before("pointcut()")
    public void loggingAdvice1()
    {
        System.out.println("Before advice is executed");
    }
}

Publicación traducida automáticamente

Artículo escrito por shrivastavaditi02 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta