Spring Boot – AOP después de devolver el 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 de trabajo de After Return Advice.

After Returning Advice se ejecuta después de que un método de punto de unión se ejecuta con éxito. Se indica mediante la anotación @AfterReturning. Si se genera alguna excepción del método, no se ejecutará después de devolver el aviso.

Pasos para implementar AOP después de devolver el asesoramiento en la aplicación Spring Boot

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

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

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

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_returning_advice.model. y agréguele una clase de modelo Student.

Clase de estudiante:

package com.after_returning_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_returning_advice.service y agréguele una clase de servicio para estudiantes. Agregue un método para agregar estudiantes con argumentos de nombre dado.

Clase StudentService:

package com.after_returning_advice.service;
 
import org.springframework.stereotype.Service;
import com.after_returning_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_returning_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_returning_advice.controller;
 
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;
 
import com.after_returning_advice.model.Student;
import com.after_returning_advice.service.StudentService;
 
@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_returning_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_returning_advice.aspect;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
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_returning_advice.service.StudentService
    // class of any return type with 0 or more number of arguments
    @Pointcut("execution(* com.after_returning_advice.service.StudentService.*(..)) ")
   
      // the pointcut signature
      private void anyStudentService() {}
     
    @AfterReturning("anyStudentService() && args(fname, sname)")
    public void afterReturningAdvice(JoinPoint joinPoint, String fname, String sname)
    {
        System.out.println("After Returning 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 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 After Returning no se ejecutará.

Como se ve en el resultado, después de devolver el aviso, se llama después de que el método de servicio se ejecuta correctamente.