English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriales de SpringBoot

SpringBoot AOP @AfterThrowing

After throwing es un tipo de recomendación en Spring AOP. Si el método lanza una excepción, asegura que se ejecute la recomendación. Usamos @AfterThrowing anotaciones para implementar recomendaciones de lanzamiento.

Sintaxis: 

@AfterThrowing(PointCut="ejecución(expresión) ", 
lanzando="name")

donde:

PointCut: Elija una función.

ejecución(expresión):

lanzando: El nombre del异常 a retornar.

Implementemos after en nuestra aplicación.-recomendaciones de lanzamiento.

Ejemplo de Spring Boot @AfterThrowing

Usaremos el ejemplo anterior en esta sección. Puede descargar el proyecto o realizar algunos cambios en el ejemplo anterior.

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

El2Paso: proporciona GrupoNombre. Proporcionamos el nombre del grupo com.w3codebox。

Pasos3: proporciona Artifact Id。Proporcionar Artifact Id aop-after-throwing-advice-ejemplo.。

Pasos4: Agregar Spring Web 依赖项。

Pasos5: hacer clic Generarbotón. Al hacer clic en el botón "Generar", todos los estándares se encapsulan en jar descargarlo en el sistema local.

Pasos6: Extraer

El7Paso: ImportarSiga los siguientes pasos en la carpeta:

Archivo-> Importar- > Proyecto Maven existente-> Siguiente-> Navegar por la carpeta aop-throwing-advice-ejemplo -> Finalizar。

Pasos8: Abrir pom.xml 文件，并添加以下 AOP 依赖项。它是使用 Spring AOP y AspectJ 开始学习面向方面编程。

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

pom.xml 

<?xml version="1.0" encoding="UTF-8"?>
<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.w3codebox</groupId>
<artifactId>aop-after-throwing-advice-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>aop-after-throwing-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>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-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 en el paquete com.w3codebox.model paquete.

Pasos10: en el paquete com.w3en el paquete codebox.model crea un nombre de de la clase.

En la clase \

definieron dos variables de tipo String accountNumber y accountType . Haga clic derecho en el archivo -> Fuente-> Usar campos para generar 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 

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()　
{
return accountType;
}
public String getAccountNumber()　
{
return accountNumber;
}
@Override
public String toString()
{
return \　+　accountNumber+　", accountType="　+　accountType　+　"]";
}
}

Pasos11: Crea otro nombre de com.w3paquete codebox.service.impl.

Pasos12: En este paquete, crea un nombre de Clase AccountServiceImple.

En esta clase, definimos el servicio de cuenta.

AccountServiceImpl.Java 

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　
{
//almacenando detalles de la cuenta en el HashMap
private static Map<String, Account> map = null;
static
{
map = new HashMap<>();
//agregando detalles de la cuenta en el mapa
map.put("M4546779", new Account("10441117000", "Cuenta de Ahorros"));
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 el paquete com.w3codebox.service.impl. en crear un nombre de AccountService la interfaz.

AccountService.java 

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

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

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

En esta clase, hemos implementado la anotación de consejo después de lanzar utilizando la siguiente manera @AfterThrowing。 También hemos definido afterThrowingAdvice()método.

Atención: El nombre definido en la propiedad throwing (ex) debe coincidir con el nombre del parámetro en el método advice. De lo contrario, el consejo no se ejecutará.

AccountAspect.java 

package com.w3codebox.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class AccountAspect　
{
//implementando el consejo después de lanzar　　　　
@AfterThrowing(value="execution("*　com.w3codebox.service.impl.AccountServiceImpl.*(..)", throwing="ex")
public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex)
{
System.out.println("Después de lanzar la excepción en el método:")+joinPoint.getSignature());
System.out.println("La excepción es:")+ex.getMessage());
}　　　
}

Pasos16: Abrir AopAfterThrowingAdviceExampleApplication.java archivo y agregar la anotación @EnableAspectJAutoProxy.

soporte de anotación para el procesamiento con AspectJ @Aspect Componente de comentario. Se utiliza junto con la anotación @Configuration.

usamos la anotación @EnableAspectJAutoProxy. proxyTargetClass propiedad. Propiedad proxyTargetClass = true permite que usemos 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 que, además de los métodos del cliente del contexto de aplicación de ApplicationContext, proporciona herramientas para configurar el contexto de la aplicación.

AopAfterThrowingAdviceExampleApplication.java 

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
//La anotación @EnableAspectJAutoProxy permite manejar componentes marcados con @Aspect. Es similar a las etiquetas en la configuración XML.
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopAfterThrowingAdviceExampleApplication
{
　　　　public static void main(String[] args)　　
　　　　{
　　　　　　　　ConfigurableApplicationContext ac = SpringApplication.run(AopAfterThrowingAdviceExampleApplication.class, args);
　　　　　　　　//Obtener el objeto account del contexto de la aplicación
　　　　　　　　AccountService accountService = ac.getBean("accountServiceImpl", AccountServiceImpl.class);
　　　　　　　　Account account;
　　　　　　　　try　
　　　　　　　　{
　　　　　　　　//Generar excepción
　　　　　　　　account = accountService.getAccountByCustomerId(null);
　　　　　　　　if (account != null)
　　　　　　　　　　　　System.out.println(account.getAccountNumber()+"\t"+account.getAccountType());
　　　　　　　　}　
　　　　　　　　catch (Exception e)　
　　　　　　　　{
　　　　　　　　　　　　System.out.println(e.getMessage());
　　　　　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　}
}

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

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


JDBC de SpringBootSpringBoot AOP @AfterReturning