Spring Boot – AOP después del consejo

Prerrequisito : 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 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 si se aplicara esa funcionalidad en toda la aplicación. En este artículo, cubriremos un ejemplo práctico de After Advice.

After Advice se ejecuta después de la ejecución de un punto de unión. Se indica mediante la anotación @After . El método de aviso se ejecuta independientemente del flujo de ejecución del método emparejado. Si el método se ejecuta normalmente o se produce alguna excepción después de que se ejecute el consejo de todos modos. Esto es contrario a la ejecución de after-returning, donde el consejo se ejecuta solo si el método se completa con éxito, y after-throwing donde el consejo se ejecuta solo si el método sale lanzando una excepción. Después de los consejos se utiliza generalmente para liberar recursos.

Pasos para implementar AOP después de los consejos en la aplicación Spring Boot

Paso 1: Abra Spring Initializer http://start.spring.io

Paso 2: proporcione el nombre del grupo : com.after_advice

Paso 3: Proporcione la identificación del artefacto : aop-after-advice-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:

Archivo -> Importar -> Proyectos Maven existentes -> Siguiente -> Examinar -> Busque la carpeta aop-after-advice-example -> Finalizar. 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

archivo 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.before_advice</groupId>
 <artifactId>aop-before-advice-example</artifactId>
 <version>0.0.1-SNAPSHOT</version>
  
 <packaging>jar</packaging> 
 
 <name>aop-before-advice-example</name>
 <description>Demo project for Spring Boot</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.after_advice.model. y agréguele una clase de modelo Student.

Clase de estudiante:

package com.after_advice.model;
 
public class Student {
    private String firstName;
    private String secondName;
 
    public Student() {
    }
 
    public String getFirstName() {
        return firstName;
    }
 
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
 
    public String getSecondName() {
        return secondName;
    }
 
    public void setSecondName(String secondName) {
        this.secondName = secondName;
    }
}

Paso 9: Cree un paquete con el nombre com.after_advice.service. y agréguele una clase de Servicio al estudiante. Agregue un método para agregar estudiantes con argumentos de nombre dado.

Clase StudentService:

package com.after_advice.service;
 
import org.springframework.stereotype.Service;
 
import com.after_advice.model.Student;
 
@Service
public class StudentService {
 
    public Student addStudent(String fname, String sname) {
        System.out.println("Add student service method called");
        Student stud = new Student();
        stud.setFirstName(fname);
        stud.setSecondName(sname);
        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.after_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.

Clase StudentController:

package com.after_advice.controller;
 
import com.after_advice.model.Student;
import com.after_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;
 
@RestController
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.after_advice.aspect. y agréguele una clase de Aspecto de servicio para estudiantes. Aquí agregaremos nuestro método Advice y la expresión PointCut.

Clase StudentServiceAspect:

package com.after_advice.aspect;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class StudentServiceAspect {
   
    // the pointcut expression specifying execution of any
    // method in com.after_advice.service.StudentService
    // class of any return type with 0 or more number of
    // arguments
    @Pointcut("execution(* com.aftere_advice.service.StudentService.*(..)) ")
      // the pointcut signature
    private void anyStudentService()  { }
 
    @After("anyStudentService() && args(fname, sname)")
    public void afterAdvice(JoinPoint joinPoint,
                             String fname, String sname)
    {
        System.out.println(
            "After method:" + joinPoint.getSignature()
            + "\n "
            + "Added Student with first name - " + fname
            + ", second name - " + sname);
    }
}

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 una 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. Se ejecutará el consejo After.

Como se ve en el resultado, el método de aviso se llama después de que el método de servicio se ejecuta correctamente o se genera una excepción.