English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
SpringBoot AOP After Advice wird verwendet, um zu überschneiden. Dies ist ein Ratstyp, der sicherstellt, dass der Rat nach der Ausführung des Verfahrens ausgeführt wird. Wir verwenden @After Anmerkungen, um After-Ratschläge durchzusetzen.
Lassen Sie uns durch ein Beispiel verstehen, wie man After-Ratschläge durchsetzt.
Schritt1: Öffnen Sie Spring Initializr http://start.spring.io .
Schritt2: bereiten Group Name. Wir bieten den Gruppennamen com.w3codebox.
Schritt3: bereitet Artifact Id.Bereitstellung von Artifact Id aop-after-advice-example.
Schritt4: hinzufügen Spring Web Abhängigkeiten.
Schritt5: klicken ErstellenKнопка. Wenn wir auf die Schaltfläche "Erstellen" klicken, packt sie alle Normen ein jar Datei und laden Sie sie auf das lokale System herunter.
Schritt6: Extrahierenheruntergeladenen jar-Datei.
Schritt7: Importieren Sie die folgenden SchritteVerzeichnis:
Datei->Importieren->Bestehendes Maven-Projekt->Nächste->Verzeichnis durchsuchen aop-after-advice-example ->Fertig.
Schritt8: Öffnen pom.xml Datei und fügen Sie die folgenden AOP Abhängigkeiten. Es wird Spring AOP und AspectJ Einführung in die aspektorientierte Programmierung.
<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>
Schritt9: Öffnen AopAfterAdviceExampleApplication.java Datei und fügen Sie die Annotation hinzu @EnableAspectJAutoProxy.
@EnableAspectJAutoProxy(proxyTargetClass=true)
es unterstützt die Verarbeitung von Dateien mit AspectJ- @Aspect Komponenten mit Annotationen. Es wird zusammen mit der @Configuration-Annotation verwendet. Wir können proxyTargetClass Eigenschaft, um den Typ des Proxies zu steuern. Der Standardwert ist 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);
}
}
Schritt10: Erstellen eines Namens]} com.w3Das Paket codebox.model.
Schritt11: Im Paket com.w3Erstellen Sie eine Klasse unter codebox.model. Wir haben eine benannt Die Klasse Employee. In der Klasse, definieren Sie den folgenden Inhalt:
definieren drei String-Variable empId, firstName,und secondName . ErstellenGetter und Setter. Erstellendefault
Employee.java
package com.w3codebox.model;
public class Employee
{
private String empId;
private String firstName;
private String secondName;
//Standardkonstruktor
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;
}
}
Schritt12: Erstellen Sie eine mit dem Namen com.w3Das Paket codebox.controller.
Schritt13: Im Paket com.w3Unter codebox.controller erstellen wir eine Kontrollklasse. Wir haben eine benannt Die Klasse EmployeeController.
In der Kontrollklasse definieren wir zwei Abbildungen, eine zum Hinzufügen von Mitarbeitern und eine zum Löschen von Mitarbeitern.
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 removed";
}
}
Schritt14: Erstellen eines Namens]} com.w3The package of codebox.service.
Schritt15: Im Paket com.w3Create a Service class under codebox.service. Wir haben eine benannt The EmployeeService class.
In the Service class, we define two methods createEmployee und 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)
{
}
}
Schritt16: Erstellen eines Namens]} com.w3Paket codebox.aspect.
Schritt17: Im Paket com.w3Eine Aspektklasse unter codebox.aspect erstellen. Wir haben eine benannt Klasse von EmployeeServiceAspect.
In der Aspektklasse haben wir die Logik nach dem Rat definiert.
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.*(..)) und args(empId, fname, sname)")
public void afterAdvice(JoinPoint joinPoint, String empId, String fname, String sname) {
System.out.println("Nach Methode:") + joinPoint.getSignature());
System.out.println("Creating Employee with first name - " + fname + ", zweiter Name - " + sname + " und id - " + empId);
}
}
In der obigen Klasse:
execution(expression): Ein Ausdruck ist eine Methode, die Ratschläge anwenden kann. @After: Mit @After Die annotierten Methoden werden nach allen Methoden ausgeführt, die mit dem切入点 Ausdruck übereinstimmen.
Nach der Erstellung aller Module sieht der Projektordner wie folgt aus:
Wir haben alle Module eingerichtet. Jetzt werden wir die Anwendung ausführen.
Der18Schritt: Öffnen AopAfterAdviceExampleApplication.java Datei und führen Sie sie als Java-Anwendung aus.
Schritt19: Öffnen Sie den Browser und rufen Sie die folgende URL auf: http://localhost:8080/add/employee?empId = {id}＆firstName = {fname}＆secondName = {sname}
in der obigen URL /add/employee ist die Abbildung, die wir im Controller-Klasse erstellt haben. Wir haben zwei Trennzeichen verwendet (？)und (＆)zur Trennung der beiden Werte zugewiesen.
In der obigen Ausgabe haben wir emId 102，firstName = Sachin，und secondName = Bansal.
Lassen Sie uns den Console-Bildschirm betrachten. Wir sehen, dass bei der Aufrufung EmployeeService der Klasse createEmployee nach der Methode() EmployeeServiceAspect Methode der Klasse afterAdvice()wie im folgenden gezeigt.
Gleichzeitig können wir auch durch Aufruf der URL http: //localhost: 8080/remove/employee？empId = 102um Mitarbeiter zu löschen. Es wird eine Nachricht zurückgegeben Entlassene Mitarbeiterwie im folgenden Bild gezeigt.
In diesem Abschnitt haben wir die Funktionsweise von After Advice gelernt. Im nächsten Abschnitt werden wir die umfassende Beratung lernen.