In diesem Artikel wird die Methode zur Verwendung von AOP im Springboot -Projekt vorgestellt. Ich werde es mit Ihnen teilen. Die Details sind wie folgt:
1. Übersicht
Die Verwendung der allgemeinen Logik zur Implementierung der AOP -Technologie kann das Schreiben von Programmen wie die Signaturüberprüfung, Authentifizierung usw. erheblich vereinfachen. Die deklarativen Transaktionen von Spring werden auch durch AOP -Technologie implementiert.
Für einen bestimmten Code finden Sie auf dem Beispielprojekt https://github.com/qihaiyan/springcamp/tree/master/spring-aop
Die AOP -Technologie von Spring hat vier Kernkonzepte:
Pointcut: Point Cut, verwendet, um zu definieren, welche Methode abgefangen wird, z. B. Ausführung (*cn.springcamp.springaop.Service.*.*(..))
Ratschläge: Die Aktion, die nach dem Abfangen der Methode ausgeführt werden soll
Aspekt: Slice, kombinieren Pointcut und Ratschläge zusammen, um eine geschnittene Oberfläche zu bilden
Join Point: Eine Instanz von Pointcut während der Ausführung
Weaver: Ein Rahmen für die Implementierung von AOP, z. B. Aspektj oder Frühlings -AOP
2. Definitionspunktdefinition
Zu den häufig verwendeten Pointcut -Definitionen gehören Ausführung und @Annotation. Die Ausführung definiert einen methodfreien und wird verwendet, um einen relativ häufigen Abschnitt zu implementieren. @Annotation kann als Annotation zu bestimmten Methoden hinzugefügt werden, wie z. B. der Transaktionsannotation von Spring.
Die Ausführungs-Point-Schnitt-Definition sollte in eine öffentliche Klasse platziert werden, um die Point-Cut-Definition zentral zu verwalten.
Beispiel:
öffentliche Klasse CommonjoinpointConfig {@pointcut ("Ausführung (*cn.springcamp.springaop.service.Auf diese Weise können Sie in der spezifischen Aspektklasse auf den Tangentenpunkt über CommonjoInpointConfig.ServicelayRexexexexexcution () verweisen.
public class beeasspect {@before ("CommonjoinpointConfig.ServicelayRexexecution ()") public void vor (joinpoint joinpoint) {System.out.println ("---------------> vor Aspekt"); System.out.println ("------------------> Vor der Ausführung von" + joinpoint); }}Wenn der Tangentenpunkt geändert werden muss, müssen Sie nur die CommonJoInpointConfig -Klasse ändern, ohne jede Aspektklasse zu ändern.
3. häufig verwendetes Gesichtsschneiden
Vorher: Führen Sie Ratschläge aus, bevor die Methode ausgeführt wird, die häufig für die Signaturüberprüfung, Authentifizierung usw. verwendet wird.
Nach: Ausführen nach Abschluss der Methodeausführung, unabhängig davon, ob die Ausführung erfolgreich ist oder die Ausnahme ausgelöst wird.
AfterSreturning: Führen Sie erst nach erfolgreicher Methodenausführung aus.
Aftershrowing: Führen Sie erst nach einer Methode aus, nachdem eine Methode eine Ausnahme ausgelöst hat.
Ein einfacher Aspekt:
@Aspekt @componentpublic class beeasspect {@before ("CommonjoinpointConfig.servicelayerexexexexexcution ()") public void vor (joinpoint joinpoint) {system.out.println ("-------------------> vor Aspekt"); System.out.println ("----------------> Vor Ausführung von" + joinpoint); }}4. Sonderanmerkungen
Angenommen, wir möchten die Ausführungszeit einer bestimmten Methode sammeln. Eine vernünftigere Möglichkeit besteht darin, eine Annotation anzupassen und diese Annotation zu der Methode hinzuzufügen, die die Ausführungszeit sammeln muss.
Definieren Sie zuerst eine Annotation TrackTime:
@Target ({elementtype.method, elementtype.type}) @retention (retentionpolicy.runtime) public @Interface TrackTime {String param () Standard "";}Definieren Sie dann eine Aspektklasse, um das Verhalten der Annotation umzusetzen:
@Aspekt@componentpublic class TrackTimePect {@Around ("@Annotation (TrackTime)") öffentliches Objekt um (Proceedingjoinpoint Joinpoint, TrackTime TrackTime) löscht Throwable {Object result = null; Long start time = system.currenttimemillis (); result = joinpoint.procece (); Long TimETaKaNe = System.currentTimemillis () - StartTime; System.out.println ("--------------> Zeit von" + joinpoint + "mit param [" + trackTime.param () + "] is" + timetaken); Rückgabeergebnis; }}Durch die Verwendung dieser Annotation zu einer Methode können Sie die Ausführungszeit dieser Methode erfassen:
@TrackTime (param = "myService") public String runfoo () {System.out.println ("-------------------> foo"); zurück "foo";}Beachten Sie, dass die Annotation von @tracktime (param = "myService") übergeben werden kann.
Damit Annotationen Parameter übergeben können, müssen Sie beim Definieren von Anmerkungen einen Parameter String -Param () Standard "Standard" angeben.
Gleichzeitig werden in der Aspektklasse die entsprechenden Parameter zur Umgabemethode hinzugefügt. Der Variablenname des Parameters muss auch in der @Around -Annotation, jedoch nicht in der Klassennamen -TrackTime, auftreten.
@Around ("@Annotation (TrackTime)) öffentliches Objekt um (Proceedingjoinpoint Joinpoint, TrackTime TrackTime)5. Zusammenfassung
Beim Ausführen des Beispielprojekts gibt die Konsole Folgendes aus:
----------------> Vor Aspekt
--------------> Vor der Ausführung der Ausführung (String cn.springcamp.springaop.service.myService.runfoo ()))
---------------> Foo
---------------> Zeit durch Ausführung (String cn.springcamp.springaop.service.myService.runfoo ()) mit Param [MyService] ist 8
---------------> Nach Aspekt
--------------> Nach Ausführung der Ausführung (String cn.springcamp.springaop.service.myService.runfoo ()))
---------------> Aspekt des Nachgangs
------------------> Ausführung (String cn.springcamp.springaop.service.myService.runfoo ()) zurückgegeben mit Wert Foo
Es ist zu erkennen, dass die Ausführungsreihenfolge mehrerer Aspekte vor dem Nachrosturning (Daching) vorhanden ist.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.