Das Open-Source-Community-Team China machte seine erste Live-Übertragung und erzählte im Namen des Teilens die Geschichte hinter der Open-Source-Community China.“

Dieser Artikel wurde von der Huawei Cloud Community geteilt: „ Spring Master's Road 18 – Spring AOP aus der Perspektive der XML-Konfiguration verstehen “, Autor: Zhuan Yeyang__.

1. Spring AOP und dynamischer Proxy

1.1 Die Beziehung zwischen Spring AOP und dynamischem Proxy

Spring AOPImplementieren Sie aspektorientierte Programmierung mit dynamischen Proxys als primärem Mechanismus. Dieser Mechanismus ermöglicht Springdie dynamische Erstellung von Proxy-Objekten zur Laufzeit. Diese Proxy-Objekte umschließen das Zielobjekt (d. h. die Geschäftskomponente), um zusätzliche Verhaltensweisen (z. B. Sicherheitsprüfungen, Transaktionsverwaltung, Protokollierung usw.) vor und nach dem Aufruf der Methoden des Zielobjekts einzufügen . .

Dynamischer JDK-ProxySpring AOP : Der dynamische Proxy , der standardmäßig verwendet wird , wenn das Zielobjekt eine oder mehrere Schnittstellen implementiert JDK. JDKDer dynamische Proxy verwendet den Reflexionsmechanismus, um ein Proxy-Objekt für die Schnittstelle zu erstellen. Dieses Proxy-Objekt fängt alle Aufrufe der Zielschnittstellenmethode ab.
CGLIB-Proxy : Wenn das Zielobjekt keine Schnittstelle implementiert, Spring AOPgreift es auf die Verwendung CGLIBder Bibliothek zurück, um eine Unterklasse der Zielklasse zu generieren. CGLIB( Code Generation Library) ist eine leistungsstarke Hochleistungsbibliothek zur Codegenerierung, die JavaKlassen zur Laufzeit erweitert und Methoden in Unterklassen überschreibt, um das Abfangen von Methoden zu implementieren.

Unabhängig davon, welche Proxy-Methode verwendet wird, besteht der Zweck darin, durch durch Aspekte definierte Benachrichtigungen zusätzliche Verhaltensweisen in verschiedenen Phasen der Methodenausführung einzufügen, ohne den ursprünglichen Geschäftslogikcode zu ändern.

1.2 AOP-Grundterminologie

Aspekt : Aspekt ist der Kern der aspektorientierten Programmierung. Es handelt sich um ein Konstrukt, das Belange über mehrere Klassen hinweg modularisiert (z. B. Protokollierung, Transaktionsverwaltung usw.). Ein Aspekt kann mehrere Arten von Ratschlägen ( Advice) und einen oder mehrere Pointcuts ( Pointcut) enthalten, die definieren, wo und wann diese Ratschläge ausgeführt werden.

Verbindungspunkt : Ein Verbindungspunkt stellt eine bestimmte Stelle während der Programmausführung dar und Spring AOPbeschränkt diese Stellen auf Methodenaufrufe. Einfach ausgedrückt ist ein Verbindungspunkt ein Punkt, an dem Aspekthinweise eingefügt werden können.

Hinweis : Der Hinweis definiert die Aktion, die der Aspekt am Verbindungspunkt ausführen soll. Abhängig vom Benachrichtigungstyp können diese Aktionen vor, nach dem Aufruf der Methode, nach der Rückgabe eines Ergebnisses oder beim Auslösen einer Ausnahme ausgeführt werden. Zu den Benachrichtigungstypen gehören:

Vorabbenachrichtigung ( Before advice): wird ausgeführt, bevor die Methode ausgeführt wird.
Nachbenachrichtigung ( After advice): Wird nach der Ausführung der Methode ausgeführt, unabhängig von ihren Ergebnissen.
Post-Return-Benachrichtigung ( After-returning advice): Wird ausgeführt, nachdem die Methode erfolgreich ausgeführt wurde.
Benachrichtigung nach einer Ausnahme ( After-throwing advice): Wird ausgeführt, nachdem die Methode eine Ausnahme ausgelöst hat.
Surround-Hinweis ( Around advice): Wird vor und nach der Methodenausführung ausgeführt und bietet vollständige Kontrolle über Methodenaufrufe.

Pointcut (Pointcut) : Pointcut ist ein Ausdruck, der den Abgleich von Verbindungspunkten über Methodennamen, Zugriffsmodifikatoren und andere Bedingungen ermöglicht und bestimmt, welche Methoden bei der Ausführung von Benachrichtigungen ausgelöst werden sollen.

Zielobjekt : Ein Objekt, das durch einen oder mehrere Aspekte benachrichtigt wird. Wird auch als Proxy-Objekt bezeichnet.

AOP-Proxy : AOPEin vom Framework erstelltes Objekt zur Implementierung von Aspektverträgen (definiert durch Ratschläge und Pointcuts). In kann ein Proxy Spring AOPein dynamischer Proxy oder ein Proxy sein.AOPJDKCGLIB

Einführung : Mit der Einführung können Sie einer vorhandenen Klasse neue Methoden oder Eigenschaften hinzufügen. Dies wird Introduction interfacesdurch die Definition einer oder mehrerer zusätzlicher Schnittstellen () erreicht und AOPdas Framework erstellt einen Proxy für das Zielobjekt, der diese Schnittstellen implementiert.

Wenn es sich immer noch abstrakt anfühlt, nennen wir als Analogie ein weiteres Beispiel der Filmproduktion.

Aspekt

Stellen Sie sich vor, jemand dreht einen Film und die Spezialeffekte im Film (wie Explosionen und spezielle Lichteffekte) sind wie Querschnittsthemen, die in der Anwendung behandelt werden müssen (wie Protokollierung oder Transaktionsverwaltung). Diese Spezialeffekte erscheinen in vielen verschiedenen Szenen des Films, nicht nur in einer bestimmten Szene. In AOPPython sind diese „Effekte“ Aspekte und können auf mehrere Teile des Programms angewendet werden, ohne die eigentliche Szene (oder den Code) zu ändern.

Verbindungspunkt

Um mit der Filmmetapher fortzufahren: Ein bestimmter Moment in jeder Szene, beispielsweise der Moment, in dem es zu einer Explosion kommt, kann als Verbindungspunkt angesehen werden. In der Programmierung entspricht dies meist einem Methodenaufruf.

Beratung

Benachrichtigungen sind wie spezifische Anweisungen des Regisseurs an das Spezialeffektteam, wie zum Beispiel „Fügen Sie einen Explosionseffekt hinzu, bevor diese Szene beginnt“ oder „Zeigen Sie den Rauchzerstreuungseffekt, nachdem die Szene endet.“ Diese Anweisungen teilen dem Team für Spezialeffekte mit, welche spezifischen Effekte an bestimmten Stellen im Film hinzugefügt werden sollen. Bei AOPdiesen „Anweisungen“ handelt es sich um Benachrichtigungen, die angeben, dass Aspekte (Spezialeffekte) vor, nach oder um Verbindungspunkte (bestimmte Momente der Codeausführung) ausgeführt werden sollen.

Pointcut

Wenn es sich bei der Mitteilung um eine Anweisung des Regisseurs an das Spezialeffektteam handelt, sind die in der Anweisung enthaltenen spezifischen Bedingungen, wie zum Beispiel „alle nächtlichen Drehorte“, der entscheidende Punkt. Pointcuts definieren, welche Verbindungspunkte (z. B. welche spezifischen Methodenaufrufe) Benachrichtigungen (Effektanweisungen) erhalten sollen.

Zielobjekt

Die Zielobjekte sind die Szenen, denen Spezialeffekte hinzugefügt werden müssen. In unserer Programmiermetapher handelt es sich dabei um Objekte, die von der Aspektlogik betroffen sind (z. B. Klassen, die eine Protokollierung erfordern).

AOP-Proxy

AOPEin Proxy ist wie eine virtuelle, kontrollierbare Kopie einer Szene, die vom Spezialeffektteam bereitgestellt wird. Für das Publikum scheint diese Kopie mit der Originalszene identisch zu sein, tatsächlich fügt sie jedoch automatisch Spezialeffekte hinzu, wenn der Regisseur sie benötigt. In der Programmierung ist ein Proxy ein AOPvom Framework automatisch erstelltes Objekt. Es umhüllt das Zielobjekt und stellt sicher, dass Benachrichtigungen (Spezialeffektanweisungen) zum richtigen Zeitpunkt ausgeführt werden.

Einführung

Eine Einführung ist wie das Hinzufügen einer brandneuen Figur oder Szene zu einem Film, die im ursprünglichen Drehbuch nicht existiert. Mit AOPder Einführung können wir einer vorhandenen Klasse neue Methoden oder Eigenschaften hinzufügen, was so ist, als würde man den Inhalt eines Films erweitern, ohne das ursprüngliche Skript zu ändern.

2. Implementieren Sie Spring AOP über die XML-Konfiguration

SpringBietet umfangreiche AOPUnterstützung und kann über die Konfiguration XMLAspekte, Benachrichtigungen ( advice) und Pointcuts ( pointcuts) definieren. Dadurch können Sie zusätzliche Verhaltensweisen (z. B. Protokollierung, Transaktionsverwaltung usw.) hinzufügen, ohne den Quellcode zu ändern.

Umsetzungsschritte:

Spring-Abhängigkeiten hinzufügenpom.xml : Fügen Sie dem Projekt SpringFramework und AOPzugehörige Abhängigkeiten hinzu.
Definieren Sie Geschäftsschnittstellen und Implementierungsklassen : Erstellen Sie Geschäftslogikschnittstellen und ihre Implementierungen, z. B. eine einfache Serviceklasse.
Aspektklassen definieren : Erstellen Sie eine Aspektklasse, um Vor-, Nach- und Umlaufbenachrichtigungen zu definieren.
Konfigurations-XML : applicationContext.xmlKonfigurieren Sie Aspekte, Geschäfte beanund AOPzugehörige Tags in XML.

2.1 Spring-Abhängigkeit hinzufügen

Fügen Sie in pom.xmlder Datei die folgenden Abhängigkeiten hinzu

<Abhängigkeiten>
    <Abhängigkeit>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </Abhängigkeit>
    <Abhängigkeit>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.10</version>
    </Abhängigkeit>
    <Abhängigkeit>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </Abhängigkeit>
</Abhängigkeiten>

2.2 Definieren Sie Geschäftsschnittstellen und Implementierungsklassen

Zunächst definieren wir eine Geschäftslogikschnittstelle MyServiceund deren Implementierung MyServiceImpl.

MyService.java:

Paket com.example.demo.aop;
öffentliche Schnittstelle MyService {
    String performAction(String input) löst eine Ausnahme aus;
}

MyServiceImpl.java:

Paket com.example.demo.aop;
Die öffentliche Klasse MyServiceImpl implementiert MyService {
    @Override
    public String performAction(String action) löst eine Ausnahme aus {
        System.out.println("Aktion in MyService ausführen: " + action);
        if ("throw".equals(action)) {
            throw new Exception("Exception from MyService");
        }
        return „Ausgeführte Aktion:“ + action;
    }
}

2.3 Aspektklassen definieren

Als Nächstes definieren wir eine Aspektklasse , die eine Pre-Advice ( ) MyAspectenthält, die vor der Ausführung der Methode ausgeführt wird.adviceMyServiceperformAction

MyAspect.java:

Paket com.example.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;

öffentliche Klasse MyAspect {

    // Voranmeldung
    public void beforeAdvice() {
        System.out.println("Bevor der Hinweis ausgeführt wird!");
    }

    // Benachrichtigung posten
    public void afterAdvice() {
        System.out.println("Nachmeldung läuft!");
    }

    // Nach Rückkehr benachrichtigen
    public void afterReturningAdvice(Object retVal) {
        System.out.println("Nach der Rückgabe läuft der Hinweis! Rückgabewert: " + retVal);
    }

    // Benachrichtigung nach Ausnahme
    public void afterThrowingAdvice(Throwable ex) {
        System.out.println("Nach dem Auslösen wird der Hinweis ausgeführt! Ausnahme: " + ex.getMessage());
    }

    //Surround-Benachrichtigung
    öffentliches Objekt aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Um Rat: Vor der Methodenausführung");
        Objektergebnis = null;
        versuchen {
            Ergebnis = joinPoint.proceed();
        } Endlich {
            System.out.println("Um Rat: Nach der Methodenausführung");
        }
        Ergebnis zurückgeben;
    }
}

2.4 Konfigurations-XML

Schließlich müssen wir den oben genannten und zugehörigen Inhalt in Springder Konfigurationsdatei konfigurieren.applicationContext.xmlbeanAOP

applicationContext.xml:

<?xml version="1.0"kodierung="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
Das Obige ist die Header-Deklaration der XML-Datei, die die Version und den Codierungstyp der Datei definiert und den Namespace von Spring Beans und AOP einführt.
Über diese Namespaces können wir <bean>- und <aop:*>-Tags in XML verwenden.
->
    <!-- Bean-Definitionen -->
    <bean id="myService" class="com.example.demo.aop.MyServiceImpl"/>
    <bean id="myAspect" class="com.example.demo.aop.MyAspect"/>
	<!-- AOP-Konfiguration-->
    <aop:config>
        <!-- Definieren Sie Aspekte und ihre Benachrichtigungen -->
        <aop:aspect id="myAspectRef" ref="myAspect">
            <!-- Definieren Sie Pointcuts und geben Sie Benachrichtigungen an, die ausgelöst werden sollen, wenn Methoden ausgeführt werden -->
            <aop:pointcut id="serviceOperation" expression="execution(* com.example.demo.aop.MyService.performAction(..))"/>
            <!-- Vorabbenachrichtigung anwenden, Vorgänge vor Methodenausführung angeben -->
            <aop:before method="beforeAdvice" pointcut-ref="serviceOperation"/>
            <!-- Post-Benachrichtigung anwenden, den Vorgang nach der Ausführung der Methode angeben, ob die Methode erfolgreich ausgeführt wird oder eine Ausnahme ausgelöst wird -->
            <aop:after method="afterAdvice" pointcut-ref="serviceOperation"/>
            <!-- Benachrichtigung nach der Rückkehr der Anwendung, Vorgänge nach erfolgreicher Ausführung und Rückgabe der angegebenen Methode -->
            <aop:after-returning method="afterReturningAdvice" pointcut-ref="serviceOperation" return="retVal"/>
            <!-- Benachrichtigung nach Anwendungsausnahme, Aktion, nachdem die angegebene Methode eine Ausnahme auslöst -->
            <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="serviceOperation" throwing="ex"/>
            <!-- Umgebende Benachrichtigungen anwenden, um vollständige Kontrolle vor und nach der Methodenausführung zu gewährleisten -->
            <aop:around method="aroundAdvice" pointcut-ref="serviceOperation"/>
        </aop:aspect>
    </aop:config>
</beans>

myService : Dies ist Geschäftslogik beanund verweist auf MyServiceImpleine Instanz der Klasse.

myAspect : Dies ist ein Aspekt , der auf eine Instanz der Klasse beanverweist .MyAspect

<aop:config>: Dies ist AOPdas Stammelement der Konfiguration AOP, einschließlich Aspektdefinitionen, Pointcuts und Benachrichtigungsmethoden, müssen innerhalb dieses Elements definiert werden.

Aspekt : Durch Elemente definiert <aop:aspect>, enthält es eine Reihe von Hinweisen ( advice) und einen oder mehrere Punktschnitte ( pointcut). Dieses Element verknüpft Aspektklassen (Klassen, die Benachrichtigungslogik enthalten) mit bestimmten Vorgängen (wie und wann das Zielobjekt erweitert werden soll).

Pointcut : Durch <aop:pointcut>die Elementdefinition wird Pointcut durch Ausdruck angegeben. Wenn Sie genau steuern müssen, welche Methoden bei der Ausführung Benachrichtigungen auslösen, müssen Sie Pointcut definieren. Pointcut-Ausdrücke können Methoden sehr genau spezifizieren, beispielsweise nach Methodennamen, Parametertypen, Anmerkungen usw. expressionEs definiert den Ausdruck des Pointcuts und gibt die passenden Regeln des Pointcuts an. Der Ausdruck hier execution(* com.example.demo.aop.MyService.performAction(..))bedeutet, dass der Pointcut mit der Ausführung der Methode MyServicein der Schnittstelle übereinstimmt performActionund der Pointcut verwendet wird, um anzugeben, an welchen Verbindungspunkten ( Join Pointz. B. Methodenaufrufen) die Benachrichtigung angewendet wird.

Informationen zum Parsen von Ausdrückenexecution(* com.example.demo.aop.MyService.performAction(..))

Ausführung : ist die am häufigsten verwendete Pointcut-Funktion, mit der die Verbindungspunkte der Methodenausführung abgeglichen werden.

*: Zeigt an, dass der Rückgabetyp der Methode beliebig ist.

com.example.demo.aop.MyService.performAction : Gibt den vollständigen Pfad des Schnittstellennamens und Methodennamens an.

(…) : Zeigt an, dass die Methodenparameter willkürlich sind und übereinstimmen, unabhängig davon, wie viele Parameter die Methode hat.

Verbindungspunkt : Ein Verbindungspunkt bezieht sich auf einen bestimmten Punkt während der Programmausführung, beispielsweise einen Methodenaufruf. Verbindungspunkte werden durch Pointcut( )-Ausdrücke Pointcutidentifiziert und abgeglichen , execution(* com.example.demo.aop.MyService.performAction(..))die einen Pointcut definieren, der einen expliziten Satz von Verbindungspunkten angibt – also alle Aufrufe von Methoden MyServiceder Schnittstelle performAction. In diesem Beispiel sind die MyServiceSchnittstellenmethodenaufrufe performActionpotenzielle Verbindungspunkte. Bei jedem performActionAufruf einer Methode wird ein Join-Punkt erreicht . An diesem Verbindungspunkt wird die Anwendung über ihren Zeitpunkt benachrichtigt.
Hinweis : Dies ist eine AOPAktion, die die Ausführung einer Methode verbessert, indem Aktionen zu bestimmten Zeiten ausgeführt werden. methodDas Attribut gibt den Methodennamen des Aspekts an, der ausgeführt werden soll, wenn der Pointcut übereinstimmt, und pointcut-refverweist auf den oben definierten Pointcut. Hier ist beispielsweise die Methode, die aufgerufen wird, bevor beforeAdvicedie Zielmethode ausgeführt wird. performActionDies bedeutet, dass bei jedem MyService.performAction(..)Aufruf einer Methode beforeAdvicedie Methode zuerst ausgeführt wird.

Um es in einem Satz zusammenzufassen: Spring AOPDurch die Definition von Regeln (Schnittpunkten) in Aspekten, um festzulegen, wann (Verbindungspunkte) und wie (Benachrichtigungen) bestimmte Methoden verbessert werden sollen, werden die Modularisierung des Codes und die Trennung von Belangen erreicht, ohne die ursprüngliche Geschäftslogik zu ändern .

Auf diese Weise Spring AOP können Sie benutzerdefinierte Logik definieren, die vor, nach oder um die Ausführung einer bestimmten Methode eingefügt wird, ohne den ursprünglichen Geschäftslogikcode zu ändern. Dies ist ein leistungsstarker Mechanismus zur Erzielung einer Trennung von Belangen, insbesondere bei übergreifenden Belangen, die mehrere Teile der Anwendung umfassen (z. B. Protokollierung, Transaktionsverwaltung usw.).

Beachten Sie, dass bei <aop:config>Einstellung auf

<aop:config Proxy-target-class="true">
    <!--Andere Konfiguration bleibt unverändert-->
</aop:config>

Wenn Sie dies festlegen, proxy-target-class="true"wird der Proxy Spring AOPbevorzugt verwendet, CGLIBauch wenn das Zielobjekt die Schnittstelle implementiert. Standardmäßig proxy-target-classmuss die Eigenschaft nicht festgelegt werden. Wenn sie festgelegt ist false, wird ein dynamischer Proxy verwendet JDK.

Hauptprogramm:

DemoApplication.java:

Paket com.example.demo;

import com.example.demo.aop.MyService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

öffentliche Klasse DemoApplication {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyService myService = (MyService) context.getBean("myService");

        versuchen {
            System.out.println(myService.performAction("normal"));
        } Catch (Ausnahme e) {
            e.printStackTrace();
        }

        System.out.println("=======================");

        versuchen {
            System.out.println(myService.performAction("throw"));
        } Catch (Ausnahme e) {
            System.out.println("Ausnahme in main abgefangen: " + e.getMessage());
        }

        context.close();
    }
}

Operationsergebnis:

Durch die Kombination der dynamischen Proxy-Technologie mit diesen AOPKonzepten Spring AOPkönnen Anwendungen auf nicht-intrusive Weise Unterstützung für übergreifende Anliegen erhalten, sodass Entwickler diese Anliegen modularisieren und die Geschäftslogikkomponenten fokussiert und einfach halten können.

Wenn Sie an dem dynamischen Proxy interessiert sind, können Sie ihn erneut debuggen, JDKda public class MyServiceImpl implements MyService die Schnittstelle wie folgt implementiert ist:

Lassen Sie uns kurz über die wichtigsten Klassen und Schnittstellen sprechen, die hier zu sehen sind.

ProxyFactory : Dies ist Spring AOPeine Factory-Klasse, die zum Erstellen von Proxy-Objekten verwendet wird. Es kann entscheiden, ob JDKein dynamischer Proxy oder ein Proxy verwendet wird , je nachdem, ob das Zielobjekt die Schnittstelle implementiert CGLIB.

AopProxy : Diese Schnittstelle definiert Methoden zum Abrufen von Proxy-Objekten. Es gibt zwei Hauptimplementierungen: JdkDynamicAopProxy(für JDKdynamische Proxys) und CglibAopProxy(für CGLIBProxys).

JdkDynamicAopProxy : Implementiert AopProxydie Schnittstelle und verwendet JDKdynamische Proxy-Technologie, um einen Proxy zu erstellen. Es implementiert InvocationHandlerdie Schnittstelle und fängt alle Methodenaufrufe an das Proxy-Objekt ab.

CglibAopProxy : Implementiert ebenfalls AopProxydie Schnittstelle, verwendet jedoch CGLIBeine Bibliothek zum Erstellen von Proxy-Objekten. Für Klassen, die die Schnittstelle nicht implementieren, Springwird diese Methode zum Erstellen des Proxys ausgewählt.

Spring AOPWenn Sie den Quellcode genauer verstehen möchten , können Sie sich JdkDynamicAopProxydie CglibAopProxyImplementierung dieser beiden Klassen direkt ansehen. Dies ist nicht der Schwerpunkt dieses Artikels, es wird nur kurz erwähnt:

Sehen Sie sich beispielsweise JdkDynamicAopProxydie Implementierung eines dynamischen Proxys an in:

JdkDynamicAopProxyKlassen implementieren InvocationHandlerSchnittstellen, die JDKden Kern des dynamischen Proxyings bilden. In seiner invokeMethode wird es eine Logik geben, um zu bestimmen, ob der Anruf abgefangen werden muss, und entsprechende Benachrichtigungen werden vor und nach dem Anruf angewendet.
Der Prozess zum Erstellen eines Proxys erfolgt hauptsächlich ProxyFactorydurch den Aufruf createAopProxy()einer Methode, die eine Instanz von JdkDynamicAopProxyoder entsprechend der Konfiguration zurückgibt CglibAopProxy.
Verwendung eines Proxys: Der Clientcode ProxyFactoryruft das Proxy-Objekt ab und ruft die Zielmethode über dieses Proxy-Objekt auf. Das Proxy-Objekt verwendet JdkDynamicAopProxyoder intern, CglibAopProxyum diese Aufrufe abzufangen und AOPje nach Konfiguration Benachrichtigungen durchzuführen. Der Prozess zum Abrufen ProxyFactoryeines Proxy-Objekts Springerfolgt normalerweise implizit in der Konfiguration und Verwendung, insbesondere bei Verwendung Springder Containerverwaltung AOP. Für diesen Prozess ist es nicht erforderlich, dass der Entwickler die Klasse direkt aufruft ProxyFactory. Wenn Springeiner in der Konfiguration definiert beanund ein Aspekt darauf angewendet wird, Springübernimmt der Container automatisch den Prozess der Erstellung des Agenten und der Anwendung von Benachrichtigungen. Dies wird durch SpringPostprozessor- und AOPNamespace-Unterstützung erreicht, und Entwickler müssen Aspekte und Ratschläge normalerweise nur deklarativ konfigurieren.

Wenn Sie den Agenten sehen möchten CGLIB, 2finden Sie eine Möglichkeit

Die dritte Methode besteht darin, die implementierte Schnittstelle 1zu entfernen und dann die entsprechende Stelle zwischen dem Hauptprogramm und dem Ausdruck zu ändern . Die dritte Möglichkeit besteht darin, die Eigenschaften des Labels explizit in der Konfigurationsdatei festzulegen, um dies zu erreichen. wie folgt:MyServiceImplMyServiceexpressionMyServiceImpl
2Spring<aop:config>proxy-target-class="true"

<aop:config Proxy-target-class="true">
    <!--Andere Konfiguration bleibt unverändert-->
</aop:config>

Das Debuggen läuft wie folgt ab:

Willkommen bei der Ein-Klick-Dreifachverbindung~

Wenn Sie Fragen haben, hinterlassen Sie bitte eine Nachricht und lassen Sie uns gemeinsam diskutieren und lernen.

Klicken Sie hier, um zu folgen und so schnell wie möglich mehr über die neuen Technologien von Huawei Cloud zu erfahren~

Spring AOP aus einer XML-Konfigurationsperspektive verstehen