Spring Boot – AOP después de lanzar consejos

Spring es ampliamente utilizado para crear aplicaciones escalables. Para aplicaciones web Spring proporciona. Spring MVC es un módulo de Spring ampliamente utilizado que se utiliza para crear aplicaciones web escalables. Mientras que 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.

Nota: es imprescindible comprender   Spring Boot y la programación orientada a aspectos. 

¿Qué son los consejos para después de lanzar?

Sabemos que Spring usa proxies dinámicos J2SE estándar o proxies CGLIB para representar un objeto de destino. La programación orientada a aspectos se ocupa de abordar cuestiones transversales como el registro y la protección de múltiples capas como el controlador, la capa de servicio, DAO, etc.

Después de lanzar el consejo, se ejecuta si un objeto proxy mientras se ejecuta el método de destino lanza una excepción. Tenga en cuenta que el objeto solo se representa mediante proxy si el punto de unión coincide con la expresión de corte de punto. Tenga en cuenta que los proxies en Spring AOP se crean en tiempo de ejecución y el punto de unión siempre representa la ejecución de un método en Spring AOP.

A ver después de tirar consejos con la ayuda de un ejemplo.

Generando el proyecto básico con la ayuda de Spring initializr

Dirígete a Spring Initializr y copia la configuración que se menciona a continuación.

Después de seleccionar esta configuración, haga clic en generar proyecto , extraiga el archivo ZIP y ábralo en cualquier IDE de su elección.

Hay una dependencia más para agregar, Spring eliminó el iniciador AOP de la lista de agregar dependencia, por lo que tendríamos que agregarlo manualmente, solo agregue la dependencia mencionada a continuación a su archivo pom.xml.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Paso 1: primero creemos un paquete en com.geeksforgeeks.demo llamado dao en el que crearemos nuestro objeto de acceso a datos simulado. Por lo general, los proyectos contienen una capa intermedia entre el controlador y el dao llamada capa de servicio , pero para simplificar las cosas, transferiremos datos directamente desde el dao al controlador .

Ejemplo:

// Java Program to illustrate MockDAO Class
 
// Importing required classes
import java.util.Arrays;
import java.util.List;
import org.springframework.stereotype.Repository;
 
// Annotation
@Repository
 
// Class
public class MockDAO {
 
    // Not actually accessing a database,
    // just giving a mock data
    public List<String> getEmployees(boolean exception)
    {
        if (exception) {
            throw new RuntimeException("You asked for it");
        }
 
        return Arrays.asList("Mary", "Jerome", "Vyom");
    }
}

@Repository se usa para especificar que la clase proporciona un mecanismo de almacenamiento, actualización, eliminación, etc. Pero para simplificar las cosas, simplemente agregaremos la operación de lectura. Tenemos un parámetro llamado excepción que se usará como bandera, ya sea para lanzar una excepción o no.

Paso 2: ahora que hemos configurado nuestro dao , configuremos el controlador, creemos un paquete llamado controlador en com.geeksforgeeks.demo

Ejemplo:

// Java Program to Illustrate DefaultWebController Class
 
// Importing required classes
import com.geeksforgeeks.springbootaopafterthrowing.dao.MockDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
 
// Annotation
@Controller
 
// Class
public class DefaultWebController {
 
    // Class data member
    private final MockDAO mockDAO;
 
    // Annotation
    @Autowired public DefaultWebController(MockDAO mockDAO)
    {
        // This keyword refers to current instance itself
        this.mockDAO = mockDAO;
    }
 
    // Annotation
    @GetMapping("/")
 
    // Method
    public String homePage(Model model)
    {
        model.addAttribute("list",
                           mockDAO.getEmployees(false));
        return "index";
    }
}

Nada especial bajo el controlador, solo especificamos un mapeo de obtención para la página de destino predeterminada, agregamos un atributo al modelo y lo pasamos a la página index.html . 

Paso 3: Después de eso, agregaremos la página index.html en el paquete resources.templates .

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Homepage</title>
</head>
<body>
<table>
    <thead>
    <tr>
        <th>Name:</th>
    </tr>
    </thead>
    <tbody>
    <tr th:each="emp : ${list}">
        <td th:text="${emp}"></td>
    </tr>
    </tbody>
</table>
</body>
</html>

No es una página HTML elegante, solo una muy simple. No se preocupe si no conoce Thymeleaf, básicamente accedemos a ese atributo de modelo que pasó DefaultWebController , ya que se pasó una lista, solo iteramos sobre cada entrada y la imprimimos.

Tenemos la configuración básica para ejecutar esto en nuestro sistema y verificar si la aplicación web funciona en este momento (sin la parte de aspecto).

Paso 4: Simplemente abre el proyecto en la terminal y ejecuta 

mvn spring-boot:run

El proyecto se iniciará, abrirá su navegador y abrirá http://localhost:8080/ . Debería ver una página similar.

Producción

Paso 5: Después de haber llegado a este paso, ahora es el momento de agregar un aspecto a nuestro código. Entonces, creando un paquete llamado aspecto en ‘com.geeksforgeeks.demo’

Ejemplo

// Java Program to Illustrate LoggingAspect Class
 
// Importing required classes
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
 
// Annotation
@Aspect
@Component
 
// Class
public class LoggingAspect {
 
    // Annotation
    @AfterThrowing(
        "execution(public java.util.List com.geeksforgeeks.demo"
        + ".dao.MockDAO.getEmployees(..))")
 
    public void
    afterThrowingExceptionAdvice()
    {
        // Print statement
        System.out.println(
            "\n ======>> Oh No an exception was thrown\n");
    }
}

Spring AOP genera proxies en tiempo de ejecución, por lo que debemos anotar la clase con @Component , estos se usarán como beans y se inyectarán por Spring bajo el capó. @Aspect especifica que este es un aspecto, proviene de la biblioteca AspectJ.

La anotación @AfterThrowing hace exactamente lo que significa su nombre, se ejecuta después de que el método especificado en la expresión pointcut lanza una excepción. El programa simplemente imprime en la consola después de que se lanza una excepción.

La expresión pointcut especifica el método después del cual se debe ejecutar el consejo.

public java.util.List com.geeksforgeeks.demo.dao.MockDAO.getEmployees(..)

Este es el nombre del método con la ruta completa del tipo de retorno y el propio nombre del método, (..)   coincide con un método con 0 o más argumentos de cualquier tipo.

Paso 6: Ahora veamos esto en acción, simplemente cambie el falso a verdadero en el código del controlador.

model.addAttribute("list", mockDAO.getEmployees(true));

Nuevamente, ejecutemos el programa con mvn spring-boot:run , después de que el programa se inicie, simplemente visite http://localhost:8080/

Yay, Éxito, la página no se pudo cargar porque lanzamos una excepción antes de que el nombre de la vista pudiera ser reenviado a la resolución de la vista. Debería ver el siguiente resultado como se muestra a continuación de la siguiente manera: 

Producción

Y nuestra salida de terminal debe ser similar a la que se muestra a continuación de la siguiente manera:

Salida terminal