Spring Boot – AOP alrededor de consejos

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 la transacción, el registro no 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. En este artículo, cubriremos un ejemplo práctico de Around Advice.

Sugerencia: Se requiere la programación orientada a aspectos y AOP en Spring Framework como requisito previo antes de continuar.

Around Advice es el consejo más fuerte entre todos los consejos, ya que se ejecuta «alrededor» de la ejecución de un método coincidente, es decir, antes y después del método recomendado. Puede elegir si continuar con el punto de unión o pasar por alto el punto de unión devolviendo su propio valor de retorno o lanzando una excepción. Este tipo de consejo se usa cuando necesitamos acceso frecuente a un método o base de datos como el almacenamiento en caché o para compartir el estado antes y después de la ejecución de un método de manera segura para subprocesos (por ejemplo, iniciar y detener un temporizador). 

Se indica con la anotación @ Around . El método de asesoramiento requiere parámetros especiales. El primer parámetro debe ser del tipo ProceedingJoinPoint. Llamamos al método proceder() en esto para ejecutar el método de punto de unión. Podemos pasar una array de objetos para proceder métodos que se utilizarán como argumentos para la ejecución del método cuando proceda.

Pasos para implementar AOP Around Advice en la aplicación Spring Boot

Paso 1: Abra Spring Initializr 

Paso 2: Proporcione el nombre del grupo : com.around

Paso 3: Proporcione la identificación del artefacto : aop-around-example

Paso 4: Agregue la dependencia Spring Web .

Paso 5: Haga clic en el botón Generar . Se descargará un archivo zip en el sistema. Extraelo.

Paso 6: importe la carpeta en el IDE siguiendo los siguientes pasos:

File -> 
    Import -> 
        Existing Maven Projects -> 
            Next -> 
                Browse -> 
                    Look for the folder aop-around-advice-example 
                         -> Finish

Cuando se importe el proyecto, instalará las dependencias. Una vez hecho esto, sigue los siguientes pasos.

Paso 7: agregue la dependencia para Spring AOP en pom.xml

A. pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                            http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.around_advice</groupId>
<artifactId>aop-around-advice-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
 
<packaging>jar</packaging> 
 
<name>aop-around-advice-example</name>
<description>Demo project for Spring Boot AOP Around Advice</description>
 
 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
    <relativePath /> <!-- lookup parent from repository -->
 </parent>
 
 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
 </properties>
 
<dependencies>
      <!-- dependency for spring web -->
      <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
 
      <!-- added dependency for spring aop -->
      <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-aop</artifactId>
       </dependency>
</dependencies>
 
<build>
<plugins>
 <plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
</plugins>
</build>
 
</project>

Guarda los cambios y descargará los jars. Una vez hecho esto, continúe con los siguientes pasos.

Nota: Si los frascos no se agregan correctamente, es posible que obtenga algunos errores.

Paso 8: Cree un paquete con el nombre com.around_advice.model. y agréguele una clase de modelo Student.

B. Clase de estudiante

// Java Program to Illustrate Student class
 
package com.around_advice.model;
 
// Class
public class Student {
 
    // Class data members
    private String firstName;
    private String secondName;
 
    // Constructors
    public Student() {}
 
    // Getter
    public String getFirstName() { return firstName; }
 
    // Setter
    public void setFirstName(String firstName)
    {
        // This keyword refers to current instance itself
        this.firstName = firstName;
    }
 
    // Getter
    public String getSecondName() { return secondName; }
 
    // Setter
    public void setSecondName(String secondName)
    {
        this.secondName = secondName;
    }
}

Paso 9: cree un paquete con el nombre com.around_advice.service y agréguele una clase de servicio para estudiantes. Agregue un método para agregar estudiantes con argumentos de nombre dado.

C. Clase StudentService

// Java Program to Illustrate StudentService Class
 
package com.around_advice.service;
 
// Importing required classes
import com.around_advice.model.Student;
import org.springframework.stereotype.Service;
 
// Annotation
@Service
// Class
public class StudentService {
 
    // Method
    public Student addStudent(String fname, String sname)
    {
        // Printing name of corresponding student
        System.out.println(
            "Add student service method called, firstname: "
            + fname + " secondname: " + sname);
 
        Student stud = new Student();
        stud.setFirstName(fname);
        stud.setSecondName(sname);
 
        // If first name i lesser than 4 words
        //  display below command
        if (fname.length() <= 3)
            throw new RuntimeException(
                "Length of firstname must be 4 or more");
 
        return stud;
    }
}

Paso 10: Cree un paquete con el nombre com.around_advice.controller. y agréguele una clase de Student Controller. Agregue un método para manejar las requests de obtención y llamar al servicio de estudiantes desde él.

D. Clase StudentController

// Java Program to Illustrate StudentController Class
 
package com.around_advice.controller;
 
// Importing required classes
import com.around_advice.model.Student;
import com.around_advice.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
 
// Annotation
@RestController
// Class
public class StudentController {
 
    @Autowired private StudentService studentService;
 
    @GetMapping(value = "/add")
    public Student addStudent(
        @RequestParam("firstName") String firstName,
        @RequestParam("secondName") String secondName)
    {
        return studentService.addStudent(firstName,
                                         secondName);
    }
}

Paso 11: Cree un paquete con el nombre com.around_advice.aspect y agréguele una clase de Aspecto de servicio para estudiantes. Aquí agregaremos nuestro método Advice y la expresión PointCut.

E. Clase StudentServiceAspect

package com.around_advice.aspect;
 
// Importing required classes
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
 
// Annotation
@Aspect
@Component
// Class
public class StudentServiceAspect {
 
    // pointcut expression specifying execution
    // of any method in class of any return type
    // with 0 or more number of arguments
 
    @Pointcut(
        "execution(* com.around_advice.service.StudentService.*(..)) ")
 
    // pointcut signature
    private void
    anyStudentService()
    {
    }
 
    @Around("anyStudentService() && args(fname, sname)")
 
    // Method
    public Object
    beforeAdvice(ProceedingJoinPoint proceedingJoinPoint,
                 String fname, String sname)
        throws Throwable
    {
        // Print statements
        System.out.println(
            "Around method:"
            + proceedingJoinPoint.getSignature());
        System.out.println(
            "Before calling joint point service method");
 
        Object stud = proceedingJoinPoint.proceed();
 
        // Print statement
        System.out.println(
            "After calling joint point service method ");
 
        return stud;
    }
}

Paso 12:  Hemos terminado con la estructura del código. Ahora, para ejecutar la aplicación, iníciela como «ejecutar como aplicación de arranque». Abra el navegador y presione la siguiente URL para realizar una llamada de solicitud de obtención: http://localhost:{portNumber}/add?firstName={fname}&secondName={sname}

Para la demostración, estamos accediendo a la URL con fname como Harry y sname como Potter. En este caso, el método se ejecutará normalmente.

Cuando presionamos la URL con fname como Tom, el método de servicio generará una excepción. El aviso de alrededor no se ejecutará.

Como se ve en el resultado, el consejo Around llama al punto de unión a través de proceder() y podemos agregar lógica para que se ejecute antes y después de eso.