Detaillierte Erklärung des Proxys: statischer Proxy, dynamischer Proxy, SpringAOP-Implementierung

Detaillierte Erklärung des Proxys: statischer Proxy, dynamischer Proxy, Spring AOP-Implementierung

2024-07-12

1. Vorstellung des Agenten

Proxy bezieht sich auf einen Modus, in dem ein Objekt A das gleiche Verhalten wie B zeigen kann, indem es ein anderes Objekt B hält. Um das Protokoll für die Außenwelt zu öffnen, implementiert B häufig eine Schnittstelle, und A implementiert auch die Schnittstelle. Aber B ist die „echte“ Implementierungsklasse, während A eher „virtuell“ ist. Es leiht sich die Methoden von B aus, um die Schnittstellenmethoden zu implementieren. Obwohl A eine „Pseudoarmee“ ist, kann sie B verbessern und vor und nach dem Aufruf der Methode von B andere Dinge tun. Spring AOP verwendet dynamische Proxys, um das dynamische „Weben“ des Codes abzuschließen.

Die Vorteile der Verwendung eines Proxys gehen darüber hinaus. Wenn ein Projekt auf die von einem anderen Projekt bereitgestellte Schnittstelle angewiesen ist, die Schnittstelle des anderen Projekts jedoch instabil ist und das Protokoll häufig geändert wird, können Sie einen Proxy verwenden Sie müssen nur den Proxy ändern, nicht einen nach dem anderen. In diesem Sinne können wir dies für alle Schnittstellen tun, die sich an die Außenwelt anpassen, um zu verhindern, dass externer Code in unseren Code eindringt. Dies wird als defensive Programmierung bezeichnet. Möglicherweise gibt es viele andere Anwendungen für das Proxying.

Im obigen Beispiel ist Klasse A fest codiert, um B zu enthalten, das den statischen Proxy von B darstellt. Wenn das Objekt eines Proxys unsicher ist, handelt es sich um einen dynamischen Proxy. Derzeit gibt es zwei gängige Implementierungen eines dynamischen Proxys: den dynamischen JDK-Proxy und den dynamischen Cglib-Proxy.

2. Statischer Proxy

Statischer Proxy ist ein Entwurfsmuster und eine Art Proxy-Muster. In einem statischen Proxy wurde die Proxy-Klasse definiert, bevor das Programm ausgeführt wird, und die Beziehung zwischen der Proxy-Klasse und der Proxy-Klasse wird zur Kompilierungszeit bestimmt. Dies bedeutet, dass sowohl die Proxy-Klasse als auch die Proxy-Klasse dieselbe Schnittstelle implementieren oder dieselbe übergeordnete Klasse erben. Die Proxy-Klasse enthält intern eine Instanz der Proxy-Klasse und ruft gleichzeitig die Methoden der Proxy-Klasse auf , es kann Fügen Sie vor und nach dem Anruf einige Ihrer eigenen Vorgänge hinzu, z. B. Protokollierung, Berechtigungsprüfung, Transaktionsverarbeitung usw.

Statischer Proxy besteht aus drei Komponenten: abstrakte Schnittstelle, Proxy-Klasse und Proxy-Klasse. Seine Implementierungsbeispiele sind wie folgt:

1) Definieren Sie eine abstrakte Schnittstelle


public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

2) Definieren Sie die Proxy-Klasse


public class TargetProxy implements TargetInteface {
 
    private Target target =new Target();
    @Override
    public void method1() {
        System.out.println("执行方法前...");
        target.method1();
        System.out.println("执行方法后...");
    }
 
    @Override
    public void method2() {
        System.out.println("执行方法前...");
        target.method2();
        System.out.println("执行方法后...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("执行方法前...");
        int method3 = target.method3(i);
        System.out.println("执行方法后...");
        return method3;
    }
}

3) Definieren Sie die Proxy-Klasse


public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println(" Target method1 running ...");
    }
 
    @Override
    public void method2() {
        System.out.println("Target method2 running ...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("Target  method3 running ...");
        return i;
    }
}

4) Definieren Sie den Client und sehen Sie sich die Ausführungsergebnisse an


public class TargetUser {
 
    public static void main(String[] args) {
        TargetInteface target = new TargetProxy();
        target.method1();
        System.out.println("-----------------------------");
        target.method2();
        System.out.println("-----------------------------");
        System.out.println(target.method3(3));
    }
}

Ergebnisausgabe:

Vor der Ausführung der Methode...
Zielmethode1 wird ausgeführt …
Nach Ausführung der Methode...
-----------------------------
Vor der Ausführung der Methode...
Zielmethode2 wird ausgeführt …
Nach Ausführung der Methode...
-----------------------------
Vor der Ausführung der Methode...
Zielmethode 3 wird ausgeführt ...
Nach Ausführung der Methode...
3

Aus der Implementierung statischer Agenten ist nicht schwer zu erkennen, dass die Vorteile statischer Agenten in der einfachen Implementierung und dem einfachen Verständnis liegen. Die Mängel liegen jedoch auch auf der Hand: Wenn Sie einer neuen Klasse Proxy-Funktionen hinzufügen müssen, müssen Sie manuell eine neue Proxy-Klasse erstellen, was zu einem starken Anstieg der Anzahl der Klassen und einem Anstieg der Wartungskosten führt . Gleichzeitig ist der Kopplungsgrad zwischen der Proxy-Klasse und der Proxy-Klasse zu hoch. Wenn Methoden in der Proxy-Klasse hinzugefügt, gelöscht oder geändert werden, müssen auch entsprechende Methoden in der Proxy-Klasse hinzugefügt, gelöscht oder geändert werden , was die Kosten für die Codewartung senkt. Ein weiteres Problem besteht darin, dass, wenn das Proxy-Objekt die Implementierungsklassen mehrerer Zielschnittstellen repräsentiert, unterschiedliche Methoden in den mehreren Implementierungsklassen vorhanden sein müssen. Da das Proxy-Objekt dieselbe Schnittstelle wie das Zielobjekt implementieren muss (eigentlich eine Einschlussbeziehung). Zahlreiche Methoden können leicht zu aufgeblähtem und schwer zu wartendem Code führen.

3. Dynamischer Proxy

Die Kernidee des dynamischen Proxys besteht darin, über das Proxy-Objekt indirekt auf das Originalobjekt zuzugreifen, ohne den Originalobjektcode zu ändern, und vor und nach dem Zugriff zusätzliche Vorgänge auszuführen.

Das Implementierungsprinzip des dynamischen Proxys basiert hauptsächlich auf dem Reflexionsmechanismus von Java. Wenn Sie dynamische Proxys verwenden, müssen Sie eine Schnittstelle oder eine Reihe von Schnittstellen definieren, die das Verhalten der Proxy-Klasse (Proxy-Objekt) definieren.Anschließend müssen Sie eine Implementierung schreibenInvocationHandler Schnittstellenklasse. Diese Klasse enthält Logik, die vor und nach Methodenaufrufen für das Proxy-Objekt ausgeführt wird.beim AnrufenProxy.newProxyInstance()Methode, übergeben Sie den Klassenlader der Schnittstelle, das Schnittstellenarray undInvocationHandlerObject: Java generiert dynamisch eine Proxy-Klasse, die zur Laufzeit die angegebene Schnittstelle implementiert, und delegiert Methodenaufrufe an dieseInvocationHandler zu verarbeitende Objekte.Wenn eine Methode eines Proxy-Objekts aufgerufen wird, ruft sie tatsächlich aufInvocationHandlerSchnittstelleinvoke()Methode, mit der Sie eine Vorverarbeitungslogik basierend auf dem Methodennamen, den Parametern und anderen Informationen ausführen und dann die entsprechende Methode des Proxy-Objekts durch Reflektion aufrufen können.

Als nächstes stellen wir zwei dynamische Proxys vor: JDK Proxy und CGLib

1) JDK-Proxy

① Interner Mechanismus des JDK-Proxys

JDK Proxy verwendet den Reflexionsmechanismus von Java, um Proxy-Klassen dynamisch zu generieren. Speziell,ProxyKlasse wird verwendetProxyGenerator Klasse (obwohl diese Klasse keine öffentliche API ist, ist sie der Schlüssel zur Implementierung dynamischen Proxys innerhalb des JDK), um den Bytecode der Proxy-Klasse zu generieren und ihn in die JVM zu laden.Die generierte Proxy-Klasse erbt vonjava.lang.reflect.Proxy Klasse und implementieren Sie die angegebene Schnittstelle.In der Methode der Proxy-Klasse wird es aufgerufenInvocationHandlervoninvokeMethode: Leiten Sie den Methodenaufruf zur Verarbeitung an den Prozessor weiter.

Um die Leistung zu verbessern, bietet JDK Proxy außerdem einen Caching-Mechanismus zum Zwischenspeichern des Klassenobjekts der generierten Proxy-Klasse. Wenn Sie ein Proxy-Objekt desselben Typs erstellen müssen, können Sie auf diese Weise das Klassenobjekt der Proxy-Klasse direkt aus dem Cache abrufen, ohne es neu generieren zu müssen.Das Caching erfolgt überWeakCacheEs wird von der Klasse implementiert und verwendet schwache Referenzen auf Cache-Objekte, sodass nicht mehr verwendete Cache-Elemente automatisch bereinigt werden können, wenn die JVM eine Speicherbereinigung durchführt.

② Implementierungsschritte des JDK-Proxys

Definieren Sie Schnittstellen und Proxy-Klassen: Definieren Sie zunächst eine oder mehrere Schnittstellen, die von der Proxy-Klasse implementiert werden.


public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}


public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }
 
    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

CreateInvocationHandler:erreichenInvocationHandlerSchnittstelle und neu schreibeninvoke Methode.existiereninvokeIn der Methode können Sie benutzerdefinierte Logik wie Protokollierung, Berechtigungsprüfung usw. hinzufügen und die ursprüngliche Klassenmethode durch Reflektion aufrufen.
Proxy-Objekt generieren:überweisenProxy.newProxyInstanceMethode, Übergabe des Klassenladers, des Schnittstellenarrays undInvocationHandler Instanz zum dynamischen Generieren von Proxy-Objekten. Diese Methode gibt eine Proxy-Klasseninstanz zurück, die die angegebene Schnittstelle implementiert.


public class TargetProxy {
    public static  <T> Object getTarget(T t) {
        //新构建了一个 新的 代理类的对象
        return Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // proxy就是目标对象t，method就是调用目标对象中方法，args就是调用目标对象中方法的参数。
                        //比如说：代理对象.method1(),这时proxy就是目标类，method1就是method,args就是method1方法参数。
                        System.out.println("执行方法前...");
                        Object invoke = method.invoke(t, args);
                        System.out.println("执行方法后...");
                        return invoke;
            }
        });
    }
}

Verwenden Sie Proxy-Objekte: Wenn eine Methode über ein Proxy-Objekt aufgerufen wird, wird sie tatsächlich aufgerufenInvocationHandlervoninvokeMethode, in der die benutzerdefinierte Logik ausgeführt wird und anschließend die Methode der Originalklasse aufgerufen wird.


public class TargetUser {
 
    public static void main(String[] args) {
        TargetInteface target = (TargetInteface) TargetProxy.getTarget(new Target());
        target.method1();
        System.out.println("-----------------------------");
        target.method2();
        System.out.println("-----------------------------");
        System.out.println(target.method3(3));
    }
}

Ergebnisausgabe:
Vor der Ausführung der Methode...
Methode1 wird ausgeführt ...
Nach Ausführung der Methode...
-----------------------------
Vor der Ausführung der Methode...
Methode 2 wird ausgeführt ...
Nach Ausführung der Methode...
-----------------------------
Vor der Ausführung der Methode...
Methode 3 wird ausgeführt ...
Nach Ausführung der Methode...
3

③ Funktionen des JDK-Proxys

Schnittstellen-Proxy: Der JDK-Proxy kann nur Klassen vertreten, die Schnittstellen implementieren, und keine gewöhnlichen Klassen, die keine Schnittstellen implementieren.
Dynamisch generiert: Die Proxy-Klasse wird zur Laufzeit dynamisch generiert, und Entwickler müssen den Code für die Proxy-Klasse nicht manuell schreiben.
Hohe Flexibilität: Der ursprünglichen Klasse können zusätzliche Funktionen oder Logik hinzugefügt werden, ohne den ursprünglichen Klassencode zu ändern.
Leistungsüberlegungen: Aufgrund der Einbeziehung von Reflexion und dynamischer Klassengenerierung kann die Leistung des JDK-Proxys geringfügig geringer sein als die von statischen Proxys oder direkten Aufrufen von Methoden der ursprünglichen Klasse.

2) CGLib

① Das Kernprinzip des dynamischen CGLib-Proxys

Bytecode-Operationen : CGLib verwendet unter der Haube ASM (ein kleines und schnelles Bytecode-Manipulations-Framework), um dynamisch neue Java-Klassen (normalerweise Unterklassen der Zielklasse) zu generieren. Diese neu generierten Klassen erben von der Zielklasse und fügen beim Aufruf der Methode Proxy-Logik ein.
Methode zum Abfangen : Die Kernfunktion von CGLib besteht darin, das Abfangen auf Methodenebene zu implementieren.Entwickler implementierenMethodInterceptorSchnittstelle zum Definieren eines Methoden-Interceptors, der vor und nach dem Methodenaufruf des Proxy-Objekts benutzerdefinierte Logik ausführt, z. B. Vorverarbeitung, Nachverarbeitung, Ausnahmebehandlung usw.
FastClass-Mechanismus : Um die Leistung zu verbessern, übernimmt CGLib den FastClass-Mechanismus. FastClass indiziert die Methoden der Zielklasse und greift beim Aufruf direkt über den Index auf die Zielmethode zu. Diese Methode ist viel schneller als die Java-Reflexion.

② Implementierungsschritte des dynamischen CGLib-Proxys

Einführung in CGLib-Abhängigkeiten:Führen Sie die Maven- oder Gradle-Abhängigkeit von CGLib in das Projekt ein.


import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

Zielklasse definieren: Definieren Sie die Zielklasse, die als Proxy verwendet werden muss.


public class Target {
    public void method1() {
        System.out.println("method1 running ...");
}
 
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

Implementieren Sie die MethodInterceptor-Schnittstelle:Eine Implementierung erstellenMethodInterceptorSchnittstellenklasse und Overrideintercept Methode. Schreiben Sie die Proxy-Logik in diese Methode.
Proxy-Objekt erstellen: Verwenden Sie die von CGLib bereitgestellteEnhancer Klasse zum Erstellen von Proxy-Objekten.Sie müssen die Proxy-Klasse festlegen (viasetSuperclassMethode) und Rückrufe (viasetCallbackDie Methode legt die MethodInterceptor-Implementierungsklasse fest.


public class TargetProxy {
    public static <T> Object getProxy(T t) {
        Enhancer en = new Enhancer(); //帮我们生成代理对象
        en.setSuperclass(t.getClass());//设置要代理的目标类
        en.setCallback(new MethodInterceptor() {//代理要做什么
            @Override
            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行方法前。。。");
                //调用原有方法  
                Object invoke = methodProxy.invokeSuper(object, args);
                // Object invoke = method.invoke(t, args);// 作用等同与上面。
                System.out.println("执行方法后。。。");
                return invoke;
            }
        });
        return en.create();
    }
}

Verwenden Sie Proxy-Objekte: Wird ausgelöst, wenn die Methode der Zielklasse über das Proxy-Objekt aufgerufen wirdinterceptProxy-Logik in Methoden.


public class TargetUser {
 
    public static void main(String[] args) {
        Target target = (Target) TargetProxy.getProxy(new Target());
        System.out.println(target.getClass().getName());
        target.method1();
    }
 
}

Ergebnisausgabe:

com.heaboy.aopdemo.cglibproxy.Ziel $EnhancerByCGLIB$ f9f41fb8
bevor die Methode ausgeführt wird. . .
Methode1 wird ausgeführt ...
Nach Ausführung der Methode. . .

③ Anwendbare Szenarien des dynamischen CGLib-Proxys

Es müssen Proxy-Klassen eingesetzt werden, die keine Schnittstellen implementieren: Wenn die Zielklasse keine Schnittstelle implementiert, kann CGLib als Proxy verwendet werden.
Hohe Leistungsanforderungen: In Szenarien mit hohen Leistungsanforderungen können Sie die Verwendung von CGLib in Betracht ziehen, wenn der dynamische JDK-Proxy die Anforderungen nicht erfüllen kann.
Implementierung des AOP-Frameworks: Wenn in aspektorientierten Programmierframeworks wie Spring AOP eine Klasse, die keine Schnittstelle implementiert, als Proxy verwendet werden muss, wird CGLib normalerweise als zugrunde liegende Implementierung verwendet.

④ Vor- und Nachteile des dynamischen CGLib-Proxys

Vorteil:

Hohe Flexibilität: Kann Klassen, die keine Schnittstellen implementieren, als Proxy verwenden, wodurch der Anwendungsbereich des Proxys erweitert wird.
Bessere Leistung: Durch den FastClass-Mechanismus ist die Aufrufeffizienz höher als durch den Reflexionsmechanismus des dynamischen JDK-Proxys.
Kraftvoll: Unterstützt das dynamische Hinzufügen zusätzlicher Funktionalität oder Logik zu Zielklassen zur Laufzeit, ohne den ursprünglichen Klassencode zu ändern.

Mangel:

Overhead der Bytecode-Operation: Das dynamische Generieren von Bytecode und das Laden in die JVM führt zu einem gewissen Leistungsaufwand.
Endgültige Klassen und Methoden können nicht als Proxy verwendet werden: Da CGLib den Proxy durch Erben der Zielklasse implementiert, kann es keine endgültig geänderten Klassen und Methoden vertreten.
Komplexer in der Anwendung: Im Vergleich zum dynamischen JDK-Proxy ist die Verwendung von CGLib komplexer und es müssen zusätzliche Abhängigkeiten eingeführt und Probleme bei der Bytecode-Generierung behoben werden.

3) JDK-Proxy VS CGLib

Proxy-Objekttyp:Der JDK-Proxy kann nur Klassen vertreten, die Schnittstellen implementieren, während CGLib gewöhnliche Klassen direkt vertreten kann.

Leistung: CGLib generiert zur Laufzeit Unterklassen von Proxy-Klassen und gilt im Allgemeinen als etwas leistungsstärker als JDK Proxy. In den meisten Szenarien ist dieser Leistungsunterschied jedoch nicht signifikant.

Zu verwendende Szenen: Wenn das Zielobjekt die Schnittstelle bereits implementiert, ist die Verwendung des JDK-Proxys eine einfache und unkomplizierte Wahl. Wenn Sie eine Klasse als Proxy verwenden müssen, die keine Schnittstelle implementiert, müssen Sie CGLib verwenden.

verlassen:Der JDK-Proxy erfordert keine zusätzlichen Abhängigkeiten, da er Teil der Java-Kernbibliothek ist, während CGLib das Hinzufügen der CGLib-Bibliothek als Projektabhängigkeit erfordert.

JDK Proxy ist eine Funktion, die in der Java-Sprache enthalten ist und nicht durch Laden von Klassen von Drittanbietern implementiert werden muss;

Java bietet stabile Unterstützung für JDK Proxy und wird JDK Proxy weiterhin aktualisieren und aktualisieren. Beispielsweise wurde die Leistung von JDK Proxy in der Java 8-Version im Vergleich zu früheren Versionen erheblich verbessert.

Der JDK-Proxy wird durch Interceptoren und Reflection implementiert.

Der JDK-Proxy kann nur Klassen vertreten, die Schnittstellen erben.

Der JDK-Proxy ist relativ einfach zu implementieren und aufzurufen.

CGLib ist ein von einem Drittanbieter bereitgestelltes Tool, das auf ASM basiert und eine relativ hohe Leistung aufweist.

CGLib muss nicht über eine Schnittstelle implementiert werden, sondern wird durch Implementierung einer Unterklasse aufgerufen.

4. Statischer Proxy vs. dynamischer Proxy

der Unterschied

Statischer Proxy: Statische Proxys werden während der Kompilierung bestimmt. Für jede Proxy-Klasse muss eine Proxy-Klasse geschrieben werden. Die Proxy-Klasse und die Proxy-Klasse implementieren dieselbe Schnittstelle oder erben dieselbe übergeordnete Klasse.

Die Proxy-Klasse eines statischen Proxys existiert zur Kompilierungszeit, sodass sie nur bestimmte Klassen vertreten kann, wenn das Programm ausgeführt wird, und nicht dynamisch entscheiden kann, welche Klassen vertreten werden sollen.

Der statische Proxy umschließt den Methodenaufruf des ursprünglichen Objekts und kann vor und nach dem Aufruf zusätzliche Logik hinzufügen. Die Proxy-Klasse muss jedoch im Voraus geschrieben werden, was die Codemenge erhöht.

Der statische Proxy gibt das Proxy-Objekt im Code explizit an und ist relativ intuitiv zu verwenden. Das Hinzufügen neuer Proxy-Klassen erfordert jedoch eine Neukompilierung.

Dynamischer Proxy: Der dynamische Proxy erstellt zur Laufzeit Proxy-Objekte, ohne vorher Proxy-Klassen zu schreiben. Verwenden Sie den Reflexionsmechanismus von Java, um Proxy-Klassen und Proxy-Objekte dynamisch zu generieren.

Dynamische Proxys basieren auf Schnittstellen und werden über die Klasse java.lang.reflect.Proxy und die Schnittstelle java.lang.reflect.InvocationHandler implementiert.

Dynamische Proxys können Klassen mehrerer Schnittstellen vertreten und dynamisch entscheiden, welche Klassen vertreten werden sollen. Zur Laufzeit können bei Bedarf Proxys für verschiedene Objekte generiert werden, was eine größere Flexibilität bietet.

Der dynamische Proxy muss nicht für jede Proxy-Klasse eine bestimmte Proxy-Klasse schreiben, was flexibler ist und Code spart.

Dynamische Agenten können vor und nach Methodenaufrufen für das Proxy-Objekt benutzerdefinierte Logik hinzufügen, z. B. Protokollierung, Transaktionsverwaltung usw. Der Nachteil des dynamischen Proxys besteht darin, dass das Generieren eines Proxy-Objekts zur Laufzeit im Vergleich zum statischen Proxy einen gewissen Leistungsaufwand erfordert.

Anwendbare Szene

Statische Proxys eignen sich für folgende Szenarien:

Wenn die Anzahl der Zielobjekte (Proxy-Objekte) begrenzt und bestimmt ist, kann ein statischer Proxy durch manuelles Schreiben von Proxy-Klassen implementiert werden. Statische Proxys erstellen zur Kompilierungszeit Proxy-Klassen, sodass sie zur Laufzeit eine bessere Leistung erzielen.

Statische Proxys kapseln das Zielobjekt und fügen zusätzliche Funktionen hinzu, ohne den Originalcode zu ändern. Daher werden statische Proxys häufig für übergreifende Anliegen wie Protokollierung und Transaktionsverwaltung verwendet.

Der dynamische Proxy eignet sich für die folgenden Szenarien:

Wenn die Anzahl der Zielobjekte unsicher ist oder nicht im Voraus bestimmt werden kann, können dynamische Proxys Proxy-Objekte bequemer generieren. Es generiert zur Laufzeit Proxy-Klassen und Proxy-Objekte und vermeidet so die mühsame Arbeit, mehrere Proxy-Klassen manuell zu schreiben.

Dynamische Proxys bieten die Flexibilität, das Proxy-Verhalten für Zielobjekte zur Laufzeit hinzuzufügen, zu entfernen oder zu ändern. Daher werden dynamische Proxys häufig in Anwendungsszenarien wie AOP (Aspektorientierte Programmierung) und RPC (Remote Procedure Call) eingesetzt.

Es ist zu beachten, dass die Leistung dynamischer Proxys möglicherweise etwas geringer ist als die statischer Proxys, da sie zur Laufzeit Proxy-Klassen und Proxy-Objekte über den Reflexionsmechanismus erstellen. Darüber hinaus können dynamische Proxys nur Zielobjekte vertreten, die die Schnittstelle implementieren, während für statische Proxys diese Einschränkung nicht gilt.

Zusammenfassend lässt sich sagen, dass statische Proxys für Szenarien geeignet sind, in denen die Anzahl der Zielobjekte begrenzt und sicher ist und eine Kapselung und zusätzliche Funktionen erfordern, während dynamische Proxys für Szenarien geeignet sind, in denen die Anzahl der Zielobjekte unsicher ist oder nicht im Voraus bestimmt werden kann. und das Proxy-Verhalten muss flexibel hinzugefügt, gelöscht oder geändert werden. Wählen Sie die geeignete Agenturmethode basierend auf den spezifischen Bedürfnissen und Umständen.

5. Proxy-Implementierung in SpringAOP

1) Einführung in SpringAOP

Sprechen Sie über das Verständnis von AOP

Spring AOP ist ein wichtiges Modul im Spring-Framework, das zur Implementierung aspektorientierter Programmierung verwendet wird.

Persönliche Programmierung Dies ist ein Programmiermodell, das es Programmierern ermöglicht, durch benutzerdefinierte Schnittpunkte zu modularisieren und Verhaltensweisen, die sich auf mehrere Klassen auswirken, in wiederverwendbaren Modulen zu kapseln. Beispiel: Wenn Sie beispielsweise für die Protokollausgabe kein AOP verwenden, müssen Sie die Protokollausgabeanweisungen in alle Klassen und Methoden einfügen. Mit AOP können Sie die Protokollausgabeanweisungen jedoch in ein wiederverwendbares Modul kapseln und in einem platzieren In einer Klasse wird die Protokollausgabe bei jeder Verwendung der Klasse automatisch abgeschlossen.

In der Idee der aspektorientierten Programmierung werden Funktionen in zwei Typen unterteilt

Kerngeschäft: Anmelden, Registrieren, Hinzufügen, Löschen, Ändern und Abfragen werden alle als Kerngeschäft bezeichnet
Peripheriefunktionen: Protokolle und Transaktionsverwaltung sind sekundäre Peripheriedienste.

Bei der aspektorientierten Programmierung werden Kerngeschäftsfunktionen und Peripheriefunktionen unabhängig voneinander entwickelt und sind nicht gekoppelt. Anschließend werden die Aspektfunktionen und Kerngeschäftsfunktionen miteinander „verwoben“, was als AOP bezeichnet wird.

AOP kann diejenigen umwandeln, die nicht mit dem Geschäft zusammenhängen,Es ist jedoch für die Logik oder Verantwortlichkeiten (wie Transaktionsverarbeitung, Protokollverwaltung, Berechtigungskontrolle usw.) gekapselt, die üblicherweise von Geschäftsmodulen aufgerufen werden.,einfach zuReduzieren Sie doppelten Code im System，Reduzieren Sie die Kopplung zwischen Modulen,UndFörderlich für zukünftige Skalierbarkeit und Wartbarkeit。

In AOP gibt es die folgenden Konzepte:

AspektJ: Aspect ist nur ein Konzept. Es gibt keine entsprechende Schnittstelle oder Klasse. Es handelt sich um einen Sammelnamen für Join Point, Advice und Pointcut.
Verbindungspunkt : Verbindungspunkt bezieht sich auf einen Punkt während der Programmausführung, z. B. Methodenaufruf, Ausnahmebehandlung usw. In Spring AOP werden nur Verbindungspunkte auf Methodenebene unterstützt.
Beratung : Benachrichtigung, also die übergreifende Logik in einem von uns definierten Aspekt, hat drei Arten: „um“, „vorher“ und „nachher“. In vielen AOP-Implementierungsframeworks fungiert Advice normalerweise als Interceptor und kann auch viele Interceptoren als Link enthalten, der um den Verbindungspunkt herum verarbeitet werden soll.
Punktschnitt: Pointcut, wird zum Abgleichen der in einem AspectJ enthaltenen Verbindungspunkte verwendet, die von Pointcut gefiltert werden müssen.
Einführung : Einführung, die es einem Aspekt ermöglicht, zu deklarieren, dass empfohlene Objekte alle zusätzlichen Schnittstellen implementieren, die sie tatsächlich nicht implementieren. Beispielsweise kann ein Proxy-Objekt als Proxy für zwei Zielklassen verwendet werden.
Weberei : Weben, jetzt, wo wir Verbindungspunkte, Schnittpunkte, Benachrichtigungen und Aspekte haben, wie können wir sie auf das Programm anwenden? Richtig, es ist Weben. Unter der Anleitung von Pointcuts wird die Benachrichtigungslogik in die Zielmethode eingefügt, sodass unsere Benachrichtigungslogik ausgeführt werden kann, wenn die Methode aufgerufen wird.
AOP-Proxy : AOP-Proxy bezieht sich auf das Objekt, das das Aspektprotokoll im AOP-Implementierungsframework implementiert. In Spring AOP gibt es zwei Arten von Proxys, nämlich den dynamischen JDK-Proxy und den dynamischen CGLIB-Proxy.
Zielobjekt: Das Zielobjekt ist das Objekt, das als Proxy fungiert.

Spring AOP wird basierend auf dem dynamischen JDK-Proxy und der Cglib-Förderung implementiert. Beide Proxy-Methoden sind Laufzeitmethoden und verfügen daher nicht über eine Verarbeitung zur Kompilierungszeit. Daher wird Spring über Java-Code implementiert.

Welches Problem löst AOP?

Einige allgemeine Verhaltensweisen sind auf mehrere Klassen oder Objekte verteilt (z. B. Protokollierung, Transaktionsverwaltung, Berechtigungskontrolle, Begrenzung des Schnittstellenstroms, Schnittstellenleistung usw.). Diese Verhaltensweisen werden normalerweise aufgerufen Querschnittsthemen . Wenn wir diese Verhaltensweisen wiederholt in jeder Klasse oder jedem Objekt implementieren, führt dies zu redundantem, komplexem und schwer zu wartendem Code.

AOP kann übergreifende Anliegen (wie Protokollierung, Transaktionsverwaltung, Berechtigungskontrolle, Schnittstellenstrombegrenzung, Schnittstellenleistung usw.) umwandeln Kerngeschäftslogik (Kernanliegen, Kernanliegen) Trennen Sie sich vom Fokus, um eine Trennung der Anliegen zu erreichen.

AOP-Anwendungsszenarien

Protokollierung: Passen Sie Protokollierungsanmerkungen an und verwenden Sie AOP, um die Protokollierung mit einer Codezeile zu erreichen.
Leistungsstatistik: Verwenden Sie AOP, um die Ausführungszeit der Methode vor und nach der Ausführung der Zielmethode zu zählen, um die Optimierung und Analyse zu erleichtern.
Transaktionsmanagement:@Transactional Mithilfe von Anmerkungen kann Spring die Transaktionsverwaltung für uns durchführen, z. B. das Zurücksetzen von Ausnahmevorgängen, wodurch wiederholte Transaktionsverwaltungslogik eliminiert wird.@TransactionalAnmerkungen werden basierend auf AOP implementiert.
Berechtigungskontrolle: Verwenden Sie AOP, um festzustellen, ob der Benutzer über die erforderlichen Berechtigungen verfügt, bevor die Zielmethode ausgeführt wird. Wenn ja, führen Sie die Zielmethode aus, andernfalls wird sie nicht ausgeführt.Beispielsweise verwendet SpringSecurity@PreAuthorize Sie können die Berechtigungsüberprüfung anpassen, indem Sie eine Codezeile kommentieren.
Schnittstellenstrombegrenzung: Verwenden Sie AOP, um die Anforderung durch bestimmte Strombegrenzungsalgorithmen und -implementierungen zu begrenzen, bevor die Zielmethode ausgeführt wird.
Cache-Verwaltung: Verwenden Sie AOP, um den Cache vor und nach der Ausführung der Zielmethode zu lesen und zu aktualisieren.

Wie AOP implementiert wird

Zu den gängigen Implementierungsmethoden von AOP gehören dynamische Proxys, Bytecode-Operationen usw.

Spring AOP basiert auf einem dynamischen Proxy. Wenn das zu vertretende Objekt eine bestimmte Schnittstelle implementiert, wird Spring AOP verwendet JDK-Proxy, um ein Proxy-Objekt zu erstellen, das die Schnittstelle nicht implementiert, kann Spring AOP derzeit nicht als Proxy verwendet werden Cglib Generieren Sie eine Unterklasse des Proxy-Objekts, die als Proxy dient

2) Implementieren Sie SpringAOP basierend auf dem dynamischen JDK-Proxy-Proxy

① Konfigurieren Sie SpringAOP

existierenspring-aop.xmlKonfigurieren Sie verwandte Beans und Aspekte in der Konfigurationsdatei


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
    <bean id="target" class="com.xxhh.aopdemo.aop.Target"/>
 
    <bean id="targetAdvice" class="com.xxhh.aopdemo.aop.TargetAdvice"/>
 
    <bean id="targetProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="target"/> <!--被代理的类-->
        <property name="interceptorNames" value="targetAdvice"/>  <!--如果用多种增强方式,value的值使用逗号(,)分割-->
        <property name="proxyTargetClass" value="false"/> <!--如果设置为true，则创建基于类的代理（使用CGLIB）；如果设置为false，则创建基于接口的代理（使用JDK动态代理）。-->
        <property name="interfaces" value="com.xxhh.aopdemo.aop.TargetInteface"/>  <!--target实现的接口-->
    </bean>
</beans>

② Definieren Sie eine abstrakte Schnittstelle


public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

③ Definieren Sie die Proxy-Klasse


public class Target implements TargetInteface{
 
    /*
    * 需要增强的方法，连接点JoinPoint
    **/
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }
 
    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

④ Proxy-Klasse definieren (Erweiterungsmethode)


public class TargetAdvice implements MethodInterceptor, MethodBeforeAdvice, AfterReturningAdvice {
 
    /*
    * 通知/增强
    **/
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("前置环绕通知");
        Object proceed = methodInvocation.proceed();
        System.out.println("后置环绕通知");
        return proceed;
    }
 
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("后置返回通知");
    }
 
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置通知");
    }
}

⑤ Test


public class AopTest {
    public static void main(String[] args) {
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring-aop.xml");
        TargetInteface targetProxy = (TargetInteface) appCtx.getBean("targetProxy");
        targetProxy.method1();
    }
}

Ausgabeergebnis:

Surround-Front-Benachrichtigung
Voranmeldung
Methode1 wird ausgeführt ...
Rücksendebenachrichtigung posten
Surround-Back-Benachrichtigung

3) Implementieren Sie SpringAOP basierend auf dem dynamischen CGLib-Proxy

① Konfigurieren Sie SpringAOP

existierenspring-confaop.xmlKonfigurieren Sie verwandte Beans und Aspekte in der Konfigurationsdatei


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--先开启cglib代理,开启 exposeProxy = true,暴露代理对象-->
    <aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true"/>
    <!--扫包-->
    <context:component-scan base-package="com.xxhh.aopdemo.annotationaop"/>
 
</beans>

② Definieren Sie die Proxy-Klasse


/*
* 目标类
**/
public class Target {
 
    public void method1() {
        System.out.println("method1 running ...");
    }
 
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    /*
    * 连接点JoinPoint
    **/
    public int method3(Integer i) {
        System.out.println("method3 running ...");
//        int i1 = 1 / i;
        return i;
    }
}

③ Definieren Sie die Proxy-Klasse (Aspektklasse)


import org.aspectj.lang.ProceedingJoinPoint;
/*
* 切面类
**/
public class TargetAspect {
 
    /*
    * 前置通知
    **/
    public void before() {
        System.out.println("conf前置通知");
    }
 
    public void after() {
        System.out.println("conf后置通知");
    }
 
    public void afterReturning() {
        System.out.println("conf后置返回通知");
    }
 
    public void afterThrowing(Exception ex) throws Exception {
//        System.out.println("conf异常通知");
//        System.out.println(ex.getMessage());
    }
 
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object proceed = null;
        if (!"".equals("admin")) {
            System.out.println("conf环绕前置");
            proceed = pjp.proceed(pjp.getArgs());
            System.out.println("conf环绕后置");
        }
        return proceed;
    }
}

④ Testen


public class AopTest {
    public static void main(String[] args) {
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring-confaop.xml");
        Target targetProxy = (Target) appCtx.getBean("target");
        System.out.println(targetProxy.method3(0));
    }
}

Ausgabeergebnis:

conf-Vorabbenachrichtigung
conf-Surround-Präfix
Methode 3 wird ausgeführt ...
conf-Benachrichtigung nach der Rückgabe
conf-Surround-Beitrag
conf-Beitragsbenachrichtigung
0

4) Implementieren Sie SpringAOP basierend auf dem dynamischen Annotations-Proxy

① Konfigurieren Sie SpringAOP


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--先开启cglib代理,开启 exposeProxy = true,暴露代理对象-->
    <aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true"/>
    <!--扫包-->
    <context:component-scan base-package="com.xxhh.aopdemo.annotationaop"/>
 
</beans>

② Anmerkungen definieren


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TestAnnotation{
}

③ Definieren Sie Aspektklassen


/*
* 切面类
**/
@Aspect
@Component
public class AnnotationAspect {
 
    // 定义一个切点：所有被RequestMapping注解修饰的方法会织入advice
    @Pointcut("@annotation(TestAnnotation)")
    private void advicePointcut() {}
 
    /*
    * 前置通知
    **/
    @Before("advicePointcut()")
    public void before() {
        System.out.println("annotation前置通知");
    }
 
    @After("advicePointcut()")
    public void after() {
        System.out.println("annotation后置通知");
    }
 
    @AfterReturning(pointcut = "advicePointcut()")
    public void afterReturning() {
        System.out.println("annotation后置返回通知");
    }
 
    @AfterThrowing(pointcut = "advicePointcut()", throwing = "ex")
    public void afterThrowing(Exception ex) throws Exception {
        System.out.println("annotation异常通知");
        System.out.println(ex.getMessage());
    }
 
    @Around("advicePointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object proceed = null;
        if (!"".equals("admin")) {
            System.out.println("annotation环绕前置");
            proceed = pjp.proceed(pjp.getArgs());
            System.out.println("annotation环绕后置");
        }
        return proceed;
    }
}

④ Controller fügt Anmerkungen hinzu


@Controller
public class TestController {
 
    @RequestMapping("/test.do")
    @ResponseBody
    public String testController() {
        TestController o = (TestController) AopContext.currentProxy();
        o.test();
//        System.out.println("tewt");
        return "ok";
    }
 
    @TestAnnotation
    public void test() {
        System.out.println("test running");
    }
 
}

Technologieaustausch