English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Le conseil après AOP de SpringBoot est utilisé pour la cross-cutting. C'est un type de conseil qui garantit que le conseil s'exécute après l'exécution de la méthode. Nous utilisons @After annotations pour réaliser les conseils postérieurs.
Commençons par un exemple pour comprendre les conseils postérieurs.
Étape1: Ouvrir Spring Initializr http://start.spring.io .
Étape2: fournir Groupe nom. Nous fournissons le nom du groupe com.w3codebox.
Étape3: fournit ID d'artefact.fournir l'ID d'artefact aop-after-advice-example.
Étape4: ajouter Spring Web dépendances.
Étape5: cliquer générerbouton. Lorsque nous cliquons sur le bouton "Générer", il enveloppe toutes les normes jar les fichiers du dossier, et les télécharger sur le système local.
Étape6: Extraire: Télécharger les fichiers jar téléchargés.
Étape7: Importer les fichiers suivantsDossier:
Fichier->Importer->Projet Maven existant->Suivant->Parcourir le dossier aop-after-advice-example ->Terminé。
Étape8: ouvrir pom.xml ajouter les fichiers suivants AOP Dépendances. Il utilise Spring AOP et AspectJ Pour introduire la programmation orientée aspect (AOP)。
<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>
Étape9: ouvrir AopAfterAdviceExampleApplication.java fichier, et ajouter les annotations @EnableAspectJAutoProxy.
@EnableAspectJAutoProxy(proxyTargetClass=true)
il prend en charge le traitement des fichiers avec AspectJ @Aspect composant annoté. Il est utilisé avec l'annotation @Configuration. Nous pouvons utiliser proxyTargetClass une propriété pour contrôler le type d'proxy. Sa valeur par défaut est 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);
}
}
Étape10: créer un nom de com.w3paquet codebox.model.
Étape11: dans le paquet com.w3créer une classe sous codebox.model. Nous avons créé une classe nommée classe Employee. Dans la classe, définir ce contenu :
définir trois variables de type String empId, firstName,et secondName . générerGetters and Setters. créerdefault
Employee.java
package com.w3codebox.model;
public class Employee
{
private String empId;
private String firstName;
private String secondName;
//Constructeur par défaut
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;
}
}
Étape12: Créer un nom de com.w3Le paquet codebox.controller.
Étape13: dans le paquet com.w3Créer une classe contrôleur sous codebox.controller. Nous avons créé une classe nommée La classe EmployeeController.
Dans la classe de contrôleur, nous définissons deux mappings, l'un pour ajouter un employé et l'autre pour supprimer un employé.
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, method = 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, method = RequestMethod.GET)
public String removeEmployee(@RequestParam("empId") String empId)
{
employeeService.deleteEmployee(empId);
return "Employee supprimé";
}
}
Étape14: créer un nom de com.w3Le paquet codebox.service.
Étape15: dans le paquet com.w3Créer une classe Service sous codebox.service. Nous avons créé une classe nommée La classe EmployeeService.
Dans la classe Service, nous définissons deux méthodes createEmployee et 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)
{
}
}
Étape16: créer un nom de com.w3paquet codebox.aspect.
Étape17: dans le paquet com.w3créer une classe aspect sous codebox.aspect. Nous avons créé une classe nommée classe EmployeeServiceAspect.
Dans la classe aspect, nous définissons la logique de conseil aprè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.*(..)) et args(empId, fname, sname)")
public void afterAdvice(JoinPoint joinPoint, String empId, String fname, String sname) {
System.out.println("Après la méthode :" + joinPoint.getSignature());
System.out.println("Création d'un Employé avec le prénom" - " + fname + ", deuxième nom - " + sname + "et id - " + empId);
}
}
Dans la classe suivante:
execution(expression): L'expression est une méthode de conseil qui peut être appliquée. @After: en utilisant @After Les méthodes annotées sont exécutées après les méthodes correspondant à l'expression de point d'entrée.
Après avoir créé tous les modules, le répertoire du projet est le suivant:
Nous avons configuré tous les modules. Nous allons maintenant exécuter l'application.
le18étape: ouvrir AopAfterAdviceExampleApplication.java Fichier et exécutez-le en tant qu'application Java.
Étape19: Ouvrez le navigateur et appellez l'URL suivant: http://localhost:8080/add/employee?empId = {id}＆firstName = {fname}＆secondName = {sname}
Dans l'URL ci-dessus /add/employee est la correspondance que nous avons créée dans la classe Controller. Nous avons utilisé deux séparateurs (？)et (＆)pour séparer les deux valeurs.
Dans la sortie ci-dessus, nous avons alloué emId 102，firstName = Sachin，et secondName = Bansal.
Voyons la console. Nous voyons que lors de l'appel EmployeeService de la classe createEmployee après la méthode () EmployeeServiceAspect méthode de la classe afterAdvice()comme indiqué ci-dessous.
De même, nous pouvons également appeler l'URL http: //localhost: 8080/remove/employee?empId = 102Pour supprimer un employé. Il retournera un message Ancien employécomme indiqué dans l'image suivante.
Dans cette section, nous avons appris le principe de fonctionnement de l'Advice After. Dans la section suivante, nous allons apprendre autour de l'Advice.