SpringBoot AOP @AfterThrowing SpringBoot AOP @Around

SpringBoot AOP @AfterReturning

Después de retornarEs un consejo en Spring AOP, generalmente llamado después de que se completa (se ejecuta) el punto de conexión. No se llama si se lanza una excepción. Podemos usar @AfterReturning Comentarios que se implementan después de que se realiza la sugerencia de retorno en la aplicación. Las anotaciones marcan la funcionalidad que debe ejecutarse como sugerencia antes del método cubierto por PointCut.

Después de que se ejecuta la sugerencia de retorno, cuando se ejecuta el método coincidente y se devuelve un valor normal, se ejecuta la sugerencia. El nombre definido en la propiedad return debe coincidir con el nombre del parámetro en el método de asesoramiento. Cuando el método devuelve un valor, ese valor se transmite como el valor del parámetro correspondiente al método de notificación.

Implementemos notificaciones después de que se realice la devolución en nuestra aplicación.

SpringBoot AOP @AfterReturning

Pasos1: Abrir Spring Initializr http://start.spring.io.

Pasos2: Proporcionar Grupo Nombre. Proporcionamos el nombre del grupo com.w3codebox.

Pasos3: Proporciona Artifact Id.Proporcionar Artifact Id aop-después-devolviendo-consejo-ejemplo.

Pasos4: Agregar Spring Web Dependencias.

Pasos5: Hacer clic GenerarBotón. Cuando hacemos clic en el botón "Generar", empaqueta todas las especificaciones. jar del archivo, y descárguelo en el sistema local.

Pasos6: extraer

el7paso: importar usando los siguientes pasoscarpeta:

archivo->importar->proyecto Maven existente->siguiente->explorar carpeta aop-devolviendo-consejo-ejemplo ejemplo->completado.

Pasos8: Abrir pom.xml archivo y agregar lo siguiente AOP dependencias. Es el uso de Spring AOP y AspectJ introducción a la programación orientada a aspectos. AspectJ, Spring AOP, dependencias. Es el uso de

Ejemplo

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-iniciador-aop</artifactId>
</<dependency>
</<dependencies>
pom.xml
<?xml versión="1.0"　codificación="UTF-8"?>
<proyecto xmlns="http://maven.apache.org/POM/4.0.0"　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instancia
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0　http://maven.apache.org/xsd/maven-4.0.0.xsd">
<versión_modelo>4.0.0</versión_modelo>
<grupo_id>com.w3codebox</groupId>
<id_artefacto>aop-después-devolviendo-consejo-ejemplo</artifactId>
<versión>0.0.1-SNAPSHOT</version>
<empaquetado>jar</empaquetado>
<name>aop-después-devolviendo-consejo-ejemplo</name>
<description>proyecto de ejemplo para Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-iniciador-parent</artifactId>
<version>2.2.2.RELEASE</version>
<relativePath/>　<!--　buscar el parent en el repositorio　-->
</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>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-iniciador-aop</artifactId>
</<dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-iniciador-test</artifactId>
<scope>test</<scope>
</<dependency>
</<dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

Pasos9: en src/main/java carpeta crear un nombre de com.w3codebox.model paquete.

Pasos10: en el paquete com.w3en codebox.model crear un paquete llamado Account de la clase.

En la clase "Account", realice las siguientes operaciones:

definieron dos variables de tipo String accountNumber y accountType . Haga clic derecho en el archivo-> Fuente-> Usar campos para generar el constructor > Generar Getters.
Haga clic derecho en el archivo-> Fuente-> Generar Getters y Setters-> Seleccionar Getters-> Generar Generar toString()
Haga clic derecho en el archivo-> Fuente-> Generar toString()...

Account.java

Ejemplo

package com.w3codebox.model;
public class Account　
{
　　　　private String accountNumber;
　　　　private String accountType;
　　　　public Account(String accountNumber, String accountType)　
　　　　{
　　　　　　　　super();
　　　　　　　　this.accountNumber = accountNumber;
　　　　　　　　this.accountType = accountType;
　　　　}
　　　　public String getAccountType()　
　　　　{
　　　　　　　　devuelve accountType;
　　　　}
　　　　public String getAccountNumber()　
　　　　{
　　　　　　　　devuelve accountNumber;
　　　　}
　　　　@Override
　　　　public String toString()
　　　　{
　　　　　　　　devuelve "Cuenta [accountNumber="　+　accountNumber+　", accountType="　+　accountType　+　"]";
　　　　}
}

Pasos11: Crear otro llamado com.w3Paquete de codebox.service.impl.

Pasos12: En este paquete, se crea un nombre de La clase AccountServiceImple.

En esta clase, definimos el servicio de cuenta.

AccountServiceImpl。 Java

Ejemplo

package com.w3codebox.service.impl;
import　java.util.HashMap;
import　java.util.Map;
import　java.util.Map.Entry;
import　java.util.Set;
import　org.springframework.stereotype.Service;
import com.w3codebox.model.Account;
@Service
public　class　AccountServiceImpl　implements　AccountService　
{
　　　　//Almacenar detalles de la cuenta en el HashMap
　　　　private　static　Map<String,Account>　map　=　null;
　　　　static
　　　　{
　　　　　　　　map　=　new　HashMap<>();
　　　　　　　　//Agregar detalles de la cuenta en el map
　　　　　　　　map.put("M4546779",　new　Account("10441117000",　"Cuenta de Ahorro"));
　　　　　　　　map.put("K2434567",　new　Account("10863554577",　"Cuenta Actual"));
　　　　}
　　　　@Override
　　　　public　Account　getAccountByCustomerId(String　customerId)　throws　Exception
　　　　{
　　　　if(customerId　==null)
　　　　{
　　　　　　　　throw　new　Exception("¡Inválido! Id de Cliente");
　　　　}
　　　　Account　account=　null;
　　　　Set<Entry<String,　Account>>　entrySet　=　map.entrySet();
　　　　for　(Entry<String,　Account>　entry　:　entrySet)　
　　　　{
　　　　　　　　if(entry.getKey().equals(customerId))
　　　　　　　　{
　　　　　　　　　　　　account=　entry.getValue();
　　　　　　　　}
　　　　}
　　　　return　account;
　　　　}
}

Pasos13: en com.w3codebox.service.impl。en el paquete se crea un nombre de AccountService de la interfaz.

AccountService.java

Ejemplo

package com.w3codebox.service.impl;
import com.w3codebox.model.Account;
//Se está creando una interfaz, si no se encuentra el id del cliente se lanza una excepción
public interface AccountService　
{
　　　　public abstract Account getAccountByCustomerId(String customerId) throws Exception;
}

Pasos14: Crear un nombre de com.w3paquete codebox.aspect.

Pasos15: en el paquete com.w3codebox.aspect para crear un nombre de AccountAspect de la clase.

En esta clase, usamos la anotación @AfterReturning。 También definimos afterReturningAdvice()método.

Nota: En definido en name(account) > returning las propiedades deben coincidir con método de consejoque corresponden a los nombres de parámetros.

AccountAspect.java

Ejemplo

package com.w3codebox.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import com.w3codebox.model.Account;
@Aspect
@Component
public class AccountAspect　
{
//implementando consejos de retorno después　　　
@AfterReturning(value="execution("*　com.w3codebox.service.impl.AccountServiceImpl.*(..))", returning="account")
public void afterReturningAdvice(JoinPoint joinPoint, Account account)
{
System.out.println("Después de retornar método:")+joinPoint.getSignature());
System.out.println(account);
}
}

Pasos16: Abrir AopAfterReturningAdviceExampleApplication.java Añadir la anotación al archivo @EnableAspectJAutoProxy。

Soporte de anotaciones para el procesamiento con AspectJ @Aspect anotación de componentes. Se utiliza junto con la anotación @Configuration.

usamos la anotación @EnableAspectJAutoProxy proxyTargetClass propiedad. Propiedad proxyTargetClass = true permite que utilicemos CGLIB (biblioteca de generación de código) proxy, en lugar del método de proxy basado en interfaz JDK predeterminado.

ConfigurableApplicationContext es una interfaz, además de proporcionar métodos del cliente del contexto de aplicación de ApplicationContext, también ofrece herramientas para configurar el contexto de aplicación.

AopAfterReturningAdviceExampleApplication.java

Ejemplo

package com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import com.w3codebox.model.Account;
import com.w3codebox.service.impl.AccountService;
import com.w3codebox.service.impl.AccountServiceImpl;
@SpringBootApplication
//@EnableSpectProxy anotación admite el procesamiento de componentes marcados con @Aspect. Es similar a la etiqueta en la configuración xml.
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopAfterReturningAdviceExampleApplication
{
　　　　public static void main(String[] args)　　
　　　　{
　　　　ConfigurableApplicationContext ac = SpringApplication.run(AopAfterReturningAdviceExampleApplication.class, args);
　　　　//Obtener el objeto account del contexto de la aplicación
　　　　AccountService accountService = ac.getBean("accountServiceImpl", AccountServiceImpl.class);
　　　　Account account;
　　　　try　
　　　　{
　　　　　　　　account = accountService.getAccountByCustomerId("K2434567);
　　　　　　　　if (account != null)
　　　　　　　　　　　　System.out.println(account.getAccountNumber()+"\t"+account.getAccountType());
　　　　　　　　}　
　　　　　　　　catch (Exception e)　
　　　　　　　　{
　　　　　　　　　　　　System.out.println(e.getMessage());
　　　　　　　　}
　　　　}
}

Después de crear todas las clases y paquetes, la estructura del directorio del proyecto es como se muestra a continuación:

Pasos17: Abrir AopAfterReturningAdviceExampleApplication.java Ejecutar el archivo como una aplicación Java. Muestra la salida, como se muestra a continuación:

En la siguiente sección, entenderemos después de hacer sugerencias.

SpringBoot AOP @AfterThrowing SpringBoot AOP @Around

Tutoriales de SpringBoot

SpringBoot AOP @AfterReturning

SpringBoot AOP @AfterReturning