Spring Boot – AOP antes 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 funcional de BeforeConsejo. Before Advice se ejecuta antes de la ejecución de un punto de unión. Se denota por @Antes de la anotación.

Pasos para implementar AOP antes del asesoramiento en la aplicación Spring Boot

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

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

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

Paso 4: Agregue la dependencia Spring Web .

Paso 5: Haga clic en el botón Generar . Se descargará un archivo jar 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-before-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

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

Clase de estudiante:

package com.before_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.before_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.before_advice.service;
 
import com.before_advice.model.Student;
import org.springframework.stereotype.Service;
 
@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);
        return stud;
    }
}

Paso 10: Cree un paquete con el nombre com.before_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.before_advice.controller;
 
import com.before_advice.model.Student;
import com.before_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.before_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.before_advice.aspect;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
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.before_advice.service.StudentService
    // class of any return type with 0 or more number of
    // arguments
    @Pointcut("execution(* com.before_advice.service.StudentService.*(..)) ")
    private void anyStudentService() {} // the pointcut signature
 
    @Before("anyStudentService() && args(fname, sname)")
    public void beforeAdvice(JoinPoint joinPoint,
                             String fname, String sname)
    {
        System.out.println(
            "Before method:" + joinPoint.getSignature()+ "\n Adding 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

Como se ve en el resultado, se llama al método de asesoramiento antes de que se ejecute el método de servicio. Si ocurre alguna excepción en el método de aviso, no se ejecutará el método de servicio.