English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
SpringBoot AOP After Advice é usado para implementar cruzamento. Este é um tipo de conselho que garante que o conselho seja executado após a execução do método. Usamos @After anotações para implementar conselhos pós-fato.
vamos entender o conselho pós-fato através de um exemplo.
Passos1: abrir Spring Initializr http://start.spring.io.
Passos2: fornecer Group nome. Fornecemos o nome do grupo com.w3codebox.
Passos3: fornecemos Artifact Id.fornecer Artifact Id aop-after-advice-example.
Passos4: adicionar Spring Web dependências.
Passos5: clicar gerarbotão. Quando clicamos no botão "Gerar", ele encapsula todas as especificações jar do arquivo, e baixá-lo para o sistema local.
Passos6: ExtrairO arquivo jar baixado.
Passos7: Siga os seguintes passos para importarPasta:
Arquivo->Importar->Projeto Maven existente->Próximo->Navegar na pasta aop-after-advice-example ->Concluído.
Passos8: abrir pom.xml Adicionar o seguinte ao arquivo AOP Dependências. É usado Spring AOP e AspectJ Início da programação orientada a aspectos.
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> </dependencies>
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.w3codebox</groupId> <artifactId> aop-after-advice-example</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>aop-after-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-web</artifactId> </dependency> <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>
Passos9: abrir AopAfterAdviceExampleApplication.java arquivo, e adicionar anotações @EnableAspectJAutoProxy。
@EnableAspectJAutoProxy(proxyTargetClass=true)
ele suporta o processamento de arquivos com AspectJ @Aspect componente anotado. Ele é usado juntamente com a anotação @Configuration. Podemos usar proxyTargetClass propriedade para controlar o tipo de proxy. Seu valor padrão é false 。
AopAfterAdviceExampleApplication.java
package com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopAfterAdviceExampleApplication
{
public static void main(String[] args) {
SpringApplication.run(AopAfterAdviceExampleApplication.class, args);
}
}
Passos10: Crie um nome de com.w3pacote codebox.model.
Passos11: No pacote com.w3criar uma classe sob codebox.model. Criamos uma classe chamada classe Employee. Dentro da classe, definir o seguinte:
definir três variáveis do tipo String empId, firstName,e secondName 。 gerarGetters and Setters。 criardefault
Employee.java
package com.w3codebox.model;
public class Employee
{
private String empId;
private String firstName;
private String secondName;
//Default constructor
public Employee()
{
}
public String getEmpId()
{
return empId;
}
public void setEmpId(String empId)
{
this.empId = empId;
}
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;
}
}
Passos12: Create a name of com.w3The package of codebox.controller.
Passos13: No pacote com.w3Create a controller class under codebox.controller. Criamos uma classe chamada The class of EmployeeController.
No controller class is defined here, two mappings are defined, one for adding employees and another for deleting employees.
EmployeeController.java
package com.w3codebox.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.w3codebox.model.Employee;
import com.w3codebox.service.EmployeeService;
@RestController
public class EmployeeController
{
@Autowired
private EmployeeService employeeService;
@RequestMapping(value = "/add/employee, método = RequestMethod.GET)
public com.w3codebox.model.Employee addEmployee(@RequestParam("empId") String empId, @RequestParam("firstName") String firstName, @RequestParam("secondName") String secondName)
{
return employeeService.createEmployee(empId, firstName, secondName);
}
@RequestMapping(value = "/remove/employee, método = RequestMethod.GET)
public String removeEmployee(@RequestParam("empId") String empId)
{
employeeService.deleteEmployee(empId);
return "Employee removido";
}
}
Passos14: Crie um nome de com.w3Pacote codebox.service.
Passos15: No pacote com.w3Crie um Service classe sob codebox.service. Criamos uma classe chamada Classe EmployeeService.
No Service classe, definimos dois métodos createEmployee e deleteEmployee。
EmployeeService .java
package com.w3codebox.service;
import org.springframework.stereotype.Service;
import com.w3codebox.model.Employee;
@Service
public class EmployeeService
{
public Employee createEmployee(String empId, String fname, String sname)
{
Employee emp = new Employee();
emp.setEmpId(empId);
emp.setFirstName(fname);
emp.setSecondName(sname);
return emp;
}
public void deleteEmployee(String empId)
{
}
}
Passos16: Crie um nome de com.w3Pacote codebox.aspect.
Passos17: No pacote com.w3Crie uma classe de aspecto dentro de codebox.aspect. Criamos uma classe chamada Classe EmployeeServiceAspect.
Dentro da classe de aspecto, definimos a lógica do conselho após.
EmployeeServiceAspect.java
package com.w3codebox.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.After;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class EmployeeServiceAspect
{
@After(value = "execution(")* com.w3codebox.service.EmployeeService.*(..)) e args(empId, fname, sname)")
public void afterAdvice(JoinPoint joinPoint, String empId, String fname, String sname) {
System.out.println("Depois do método:") + joinPoint.getSignature());
System.out.println("Criando Employee com nome - " + fname + ", segundo nome - " + sname + "e id - " + empId);
}
}
Na classe acima:
execution(expression): A expressão é um método que pode aplicar aconselhamento. @After: usar @After Os métodos anotados são executados após todos os métodos que correspondem à expressão de ponto de entrada.
Após criar todos os módulos, a estrutura do diretório do projeto será como segue:
Já configuramos todos os módulos. Agora vamos executar o aplicativo.
o18Passo: abrir AopAfterAdviceExampleApplication.java Arquivo e execute-o como um aplicativo Java.
Passos19: Abra o navegador e chame a seguinte URL: http://localhost:8080/add/employee?empId = {id}＆firstName = {fname}＆secondName = {sname}
na URL acima, /add/employee é o mapeamento criado na classe Controller. Usamos dois delimitadores (？)e (＆)para separar os dois valores.
No output acima, atribuímos emId 102primeiroNome = Sachin,e secondName = Bansal.
Vamos ver o console. Vemos que, ao chamar EmployeeService da classe createEmployee após o método EmployeeServiceAspect método da classe afterAdvice()como mostrado a seguir.
Da mesma forma, também podemos chamar a URL http: //localhost: 8080/remove/employee?empId = 102para deletar um funcionário. Ele retornará uma mensagem Funcionários Demitidoscomo mostrado na figura a seguir.
Nesta seção, aprendemos o funcionamento do After Advice. Na próxima seção, vamos aprender sobre o conselho ao redor.