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

Tutorial de SpringBoot

SpringBoot AOP @AfterThrowing

After throwing é um tipo de sugestão no Spring AOP. Se o método lançar uma exceção, ele garante que a sugestão seja executada. Usamos @AfterThrowing Anotação para implementar sugestão de lançamento.

Sintaxe: 

@AfterThrowing(PointCut="execution(expression) ", throwing="name")

onde:

PointCut: Selecione uma função.

execution(expression):

Lançamento: O nome da exceção a ser retornada.

Vamos implementar after no nosso aplicativo.-sugestão de lançamento.

Exemplo Spring Boot @AfterThrowing

Usaremos o exemplo anterior neste capítulo. Você pode baixar o projeto ou fazer algumas modificações no exemplo anterior.

Passos1: Abra o Spring Initializr http://start.spring.io .

Nº2Passo: Fornece GrupoNome. Fornecemos o nome do grupo com.w3codebox.

Passos3: Fornece Artifact Id.Fornecer Artifact Id aop-after-throwing-advice-example.。

Passos4: Adicionar Spring Web Dependências.

Passos5: clicar 生成botão. Quando clicamos no botão "Gerar", ele empacota todas as especificações dentro jar do arquivo e baixá-lo para o sistema local.

Passos6: Extrair

Nº7Passo: ImportarPasta, execute os seguintes passos:

Arquivo-> Importar- > Projeto Maven existente-> Próximo-> Navegar na pasta aop-throwing-advice-example -> Concluir.

Passos8: Abrir pom.xml arquivo, e adicione o seguinte AOP Dependências. É usado Spring AOP 和 AspectJ Introdução à programação orientada a aspectos.

<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>

Passos9: 在 src/main/java 文件夹 中创建名称为 com.w3codebox.model 的包。

Passos10: no pacote com.w3codebox.model中创建一个名称为 Account da classe.

在"帐户"类中，执行以下操作:

定义了两个类型为String的变量 accountNumber 和 accountType 。 右键单击File -> Source->使用字段生成构造函数 生成Getters。
右键单击File-> Source-> Generate Getters and Setters->选择Getters-> Generate 生成 toString()
右键单击文件->源->生成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 "Account [accountNumber="　+　accountNumber+　", accountType="　+　accountType　+　"]";
}
}

Passos11: 创建另一个名为 com.w3codebox.service.impl的包。

Passos12: 在此程序包中，创建一个名称为 AccountServiceImple的类。

在该类中，我们定义了帐户服务。

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　
{
//armazenando detalhe da conta no HashMap
private static Map<String, Account> map = null;
static
{
map = new HashMap<>();
//adicionando detalhe da conta no mapa
map.put("M4546779", new Account("10441117000", "Saving Account");
map.put("K2434567", new Account("10863554577", "Current Account");
}
@Override
public Account getAccountByCustomerId(String customerId) throws Exception
{
if (customerId == null)
{
throw new Exception("Inválido! Id do 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;
}
}

Passos13: no pacote com.w3codebox.service.impl. em criar um nome de AccountService a interface.

AccountService.java 

package com.w3codebox.service.impl;
import com.w3codebox.model.Account;
//criando uma interface que lança exceção se o id do cliente não for encontrado　
public interface AccountService　
{
public abstract Account getAccountByCustomerId(String customerId)
throws Exception;
}

Passos14: Criar um nome de com.w3o pacote codebox.aspect.

Passos15: no pacote com.w3codebox.aspect em criar um nome de AccountAspect da classe.

Nesta classe, implementamos a anotação de conselho após o lançamento de exceção usando a seguinte maneira @AfterThrowing。 Também definimos afterThrowingAdvice()método.

Atenção: O nome definido no atributo throwing (ex) deve corresponder ao nome do parâmetro no método advice. Caso contrário, o conselho não será executado.

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 aconselhamento após a lançamento de exceção　　　　
@AfterThrowing(value="execution("*　com.w3codebox.service.impl.AccountServiceImpl.*(..)", throwing="ex")
public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex)
{
System.out.println("Depois de lançar exceção no método:")+joinPoint.getSignature());
System.out.println("Exception é:")+ex.getMessage());
}　　　
}

Passos16: Abrir AopAfterThrowingAdviceExampleApplication.java Adicionar anotação ao arquivo @EnableAspectJAutoProxy.

Suporte de anotação para o processamento com AspectJ @Aspect Componente de anotação. Ele é usado juntamente com a anotação @Configuration.

usamos a anotação @EnableAspectJAutoProxy. proxyTargetClass propriedade. Propriedade proxyTargetClass = true permite-nos usar CGLIB (biblioteca de geração de código) proxy, em vez do método de proxy JDK baseado em interface padrão.

ConfigurableApplicationContext é uma interface, além dos métodos de cliente do contexto de aplicação ApplicationContext, também oferece ferramentas para configurar o contexto de aplicação.

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
//@EnableAspectJAutoProxy anotação suporta o processamento de componentes marcados com @Aspect. Ela é semelhante ao sinalizador no configuração xml.
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopAfterThrowingAdviceExampleApplication
{
　　　　public static void main(String[] args)　　
　　　　{
　　　　　　　　ConfigurableApplicationContext ac = SpringApplication.run(AopAfterThrowingAdviceExampleApplication.class, args);
　　　　　　　　//Obter objeto account do contexto da aplicação
　　　　　　　　AccountService accountService = ac.getBean("accountServiceImpl", AccountServiceImpl.class);
　　　　　　　　Account account;
　　　　　　　　try　
　　　　　　　　{
　　　　　　　　//Geração de Exceção
　　　　　　　　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();
　　　　　　　　}
　　　　}
}

Após criar todas as classes e pacotes, a estrutura do diretório do projeto será conforme abaixo:

Passos17: Abrir AopAfterThrowingAdviceExampleApplication.java Arquivo e execute-o como um aplicativo Java. Ele exibe a saída conforme abaixo:


SpringBoot JDBCSpringBoot AOP @AfterReturning