English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
SpringBoot AOP After Advice se utiliza para implementar la intersección. Este es un tipo de consejo que asegura que el consejo se ejecute después de la ejecución del método. Usamos @After anotaciones para implementar consejos postfactum.
permítanos entender el consejo postfactum a través de un ejemplo.
Paso1: abrir Spring Initializr http://start.spring.io.
Paso2: proporcionar Grupo nombre. Proporcionamos el nombre del grupo com.w3codebox.
Paso3: proporciona Artifact Id.proporcionar Artifact Id aop-after-advice-ejemplo.
Paso4: agregar Spring Web dependencias.
Paso5: hacer clic generarbotón. Cuando hacemos clic en el botón "Generar", envuelve todas las normativas en jar y descargarlo en el sistema local.
Paso6: Extraerdescargados como archivos jar.
Paso7: Importar los siguientes pasoscarpeta:
archivo->Importar->Proyecto Maven existente->Siguiente->Explorar carpeta aop-after-advice-ejemplo ->completado.
Paso8: abrir pom.xml agregar el siguiente AOP las dependencias. Es utilizado Spring AOP y AspectJ para comenzar a programar orientado 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>
Paso9: abrir AopAfterAdviceExampleApplication.java archivo, y agregar la anotación @EnableAspectJAutoProxy。
@EnableAspectJAutoProxy(proxyTargetClass=true)
soporta el procesamiento de archivos con AspectJ @Aspect componente de anotación. Se utiliza junto con la anotación @Configuration. Podemos usar proxyTargetClass propiedad para controlar el tipo de proxy. Su valor predeterminado es 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);
}
}
Paso10: Crear un nombre de com.w3paquete codebox.model.
Paso11: en el paquete com.w3Crear una clase en codebox.model. Hemos creado una clase llamada clase Employee. En la clase, definir lo siguiente:
definir tres variables de tipo String empId, firstName,y secondName 。 generarGetters and Setters。 creardefault
Employee.java
package com.w3codebox.model;
public class Employee
{
private String empId;
private String firstName;
private String secondName;
//Constructor por defecto
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;
}
}
Paso12: Crear un nombre de com.w3El paquete codebox.controller.
Paso13: en el paquete com.w3Crear una clase de controlador debajo de codebox.controller. Hemos creado una clase llamada La clase EmployeeController.
En la clase del controlador, definimos dos mapeos, uno para agregar empleados y otro para eliminar empleados.
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 = "/agregar/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 = "/eliminar/employee, método = RequestMethod.GET)
public String removeEmployee(@RequestParam("empId") String empId)
{
employeeService.deleteEmployee(empId);
return "Employee removed";
}
}
Paso14: Crear un nombre de com.w3El paquete codebox.service.
Paso15: en el paquete com.w3Crea una clase Service en codebox.service. Hemos creado una clase llamada La clase EmployeeService.
En la clase Service, definimos dos métodos createEmployee y 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)
{
}
}
Paso16: Crear un nombre de com.w3el paquete codebox.aspect.
Paso17: en el paquete com.w3Crear una clase de aspecto en codebox.aspect. Hemos creado una clase llamada la clase EmployeeServiceAspect.
En la clase de aspecto, definimos la lógica de recomendación posterior.
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.*(..)) and args(empId, fname, sname)")
public void afterAdvice(JoinPoint joinPoint, String empId, String fname, String sname) {
System.out.println("Después del método:") + joinPoint.getSignature());
System.out.println("Creando Empleado con primer nombre - " + fname + ", segundo nombre - " + sname + " and id - " + empId);
}
}
En la clase superior:
execution(expression): La expresión es un método que puede aplicar recomendaciones. @After: usar @After El método anotado se ejecuta después de todos los métodos que coinciden con la expresión de punto de entrada.
Después de crear todos los módulos, la estructura del directorio del proyecto es la siguiente:
Hemos configurado todos los módulos. Ahora ejecutaremos la aplicación.
el18paso: abrir AopAfterAdviceExampleApplication.java archivo y ejecútalo como una aplicación Java.
Paso19: Abra el navegador y llame a la siguiente URL: http://localhost:8080/agregar/employee?empId = {id}＆firstName = {fname}＆secondName = {sname}
en la URL superior, /agregar/employee es el mapeo que creamos en la clase Controller. Usamos dos delimitadores (？)y (＆)para separar los dos valores.
En la salida superior, asignamos emId 102firstName = Sachin,y secondName = Bansal.
Veamos la consola. Vemos que al llamar EmployeeService clase createEmployee método () después de EmployeeServiceAspect método de la clase afterAdvice()como se muestra a continuación.
Del mismo modo, también podemos llamar a la URL http: //localhost: 8080/eliminar/employee?empId = 102para eliminar al empleado. Devolverá un mensaje Empleado despedidocomo se muestra en la siguiente imagen.
En esta sección, aprendimos el principio de funcionamiento de After Advice. En la próxima sección, aprenderemos sobre el consejo alrededor.