Tutorial zur Implementierung eines dynamischen Proxys in Java

Der folgende Inhalt basiert teilweise auf Inhalten im Internet. Ich möchte dem ursprünglichen Autor meinen Dank aussprechen!

Der Schlüssel zur Implementierung eines dynamischen Proxys in Java sind diese beiden Dinge: Proxy und InvocationHandler. Beginnen wir mit der Aufrufmethode in der InvocationHandler-Schnittstelle und erklären kurz, wie Java einen dynamischen Proxy implementiert.
Zunächst lautet die vollständige Form der Aufrufmethode wie folgt:

Java Code

1. public Object invoke(Object Proxy, Method method, Object[] args) throws Throwable

2. 🎜>

                                                                  >
6. Die Methode ist die aufgerufene Methode, also die Methode, die ausgeführt werden muss. Argumente sind die Parameter der Methode. Was ist dieser Parameter? Die obige Implementierung der invoke()-Methode ist eine relativ Standardform. Wir sehen, dass der Proxy-Parameter hier nicht verwendet wird. Sehen Sie sich die Beschreibung von Proxy in der JDK-Dokumentation wie folgt an:

Java-Code

Ein Methodenaufruf auf einer Proxy-Instanz über eine ihrer Proxy-Schnittstellen wird an die Aufrufmethode des Aufruf-Handlers der Instanz weitergeleitet und übergibt die Proxy-Instanz, ein java.lang.reflect.Method-Objekt, das die aufgerufene Methode identifiziert, und ein Array vom Typ Object, das die Argumente enthält
Daraus können wir erkennen, dass die obige Vermutung richtig ist, und wir wissen auch, dass der Proxy-Parameter an eine Instanz der Proxy-Klasse übergeben wird. Der Einfachheit halber finden Sie hier ein einfaches Beispiel für die Implementierung eines dynamischen Proxys.

Java-Code

//Abstrakte Rolle (dynamischer Proxy kann nur Proxy-Schnittstellen)



public interface Subject {

public void request();

1. } 

Java-Code

1. //Echte Rolle: Implementierte die request()-Methode des Subjekts

2. öffentliche Klasse RealSubject implementiert Subject{

4. public void request(){

5. System.out.println("Aus echtem Betreff."

6. }

7. }

Java-Code

//Implementiert InvocationHandler

public

class DynamicSubject

implements InvocationHandler

{

2. private Object obj ;//Dies ist ein dynamischer Proxy. Vorteile: Das gekapselte Objekt ist vom Typ Objekt und akzeptiert jeden Objekttyp

4. public DynamicSubject () 

                                            🎜>
5.  

   public DynamicSubject(Object. obj ) 

6.  { 

7.                                   ; 

8.                                                                  Explizite Aufforderung

public Object invoke(Object Proxy, Method method, Object[] args)
10. throws Throwable

11. {

12. System.out.println(

    "vor dem Aufruf " + method); 🎜>

13. method.invoke(obj, args); //-----> Bitte lesen Sie den nächsten Artikel für Details zu diesem Schritt. Java ruft eine bestimmte Funktion über den Reflexionsmechanismus auf. Nachdem Sie sie gelesen haben, werden Sie die Methoden jeder Klasse verstehen.

15. System.out.println(

    "nach Aufruf " + Methode);

16.                                                                                       🎜 >

} 

22. Java-Code

23. 1. //Client: hat eine Proxy-Instanz generiert und die request()-Methode

    2. public class aufgerufen Client {

    4. public static void main(String[] args ) wirft Throwable{

    5. 🎜>

    6. Subject rs=

       new RealSubject();
    //Geben Sie hier die Proxy-Klasse an

    7. InvocationHandler ds=

       new DynamicSubject(rs );

    8. Klasse> cls=rs.getClass(); >

                                                                  🎜>> );

    10.                                                                               🎜>
    11. . out.println( Betreff

        Instanceof Proxy); ist $Proxy0. Diese $Proxy0-Klasse erbt Proxy und implementiert die Subject-Schnittstelle

    12. System.out(

        "Subject's Class-Klasse ist: "+subject.getClass ().toString());

    14. System.out.print(
    "Die Attribute im Betreff sind : ");

    16. Field[ ] field=subject.getClass().getDeclaredFields();

    17. > System.out.print(f.getName()+", "

    18. }
    20. System.out.print(

        "n"+"Die Methoden im Betreff sind: ");

    22. Method[] method=subject.getClass().getDeclaredMethods();

    24.                                                               ) ; >"n"+

    25. System.out.print(
    "n"+
    26. "Die vom Betreff implementierte Schnittstelle ist: " ); ;

    27.  
    for(Class> i:interfaces){
    29.   System.out.print(i.getName()+

        ", "

    30. }

    32. System.out.println("nn"+ „Das Operationsergebnis ist:“);

Xml-Code
Die laufenden Ergebnisse sind wie folgt: Der Paketname wird hier weggelassen, *** wird ersetzt durch true

Subject's Class class Es ist: class $Proxy0

The Attribute im Betreff sind: m1, m3, m0, m2,

Die Methoden im Betreff sind: request , hashCode, equal, toString,

1. Die übergeordnete Klasse des Subjekts ist: Klasse java.lang.reflect.Proxy

2. Die von Subjekt implementierte Schnittstelle ist:cn.edu.ustc.dynamicproxy.Subject,  

4. Das laufende Ergebnis ist:  

5. vor dem Aufruf von public abstract void ***.Subject.request()

6. Aus echtem Betreff

7. nach Aufruf von public abstract void ** *.Subject.request()
11. PS: Die Informationen in diesem Ergebnis sind sehr wichtig, zumindest für mich. Denn die Hauptursache für meine Verwirrung über den dynamischen Proxy ist, dass ich die obige subject.request() missverstanden habe. Zumindest war ich von der Oberfläche verwirrt, die ich beim letzten Aufruf festgestellt habe von request( ) ist mit invoke() verbunden und woher weiß invoke, dass eine Anfrage existiert? Tatsächlich können die oben genannten true- und $Proxy0-Klassen zusammen mit dem unten erwähnten Quellcode von $Proxy0 die Zweifel an dynamischen Proxys vollständig lösen.

Wie Sie dem obigen Code und den Ergebnissen entnehmen können, haben wir die invoke()-Methode nicht explizit aufgerufen, diese Methode wurde jedoch tatsächlich ausgeführt. Lassen Sie uns den gesamten Prozess analysieren:

12. Aus dem Code im Client können wir die newProxyInstance-Methode als Durchbruch verwenden. Schauen wir uns zunächst den Quellcode der newProxyInstance-Methode in der Proxy-Klasse an:

Java-Code

1. öffentliches statisches Objekt newProxyInstance(ClassLoader Loader,  

2.         Class>[] Schnittstellen,

3.         InvocationHandler h)  

4. throws IllegalArgumentException  

5. {  

6.     if (h == null) {  

7.         throw neu NullPointerException();  

8.     }  

10.     /* 

11.      * Suchen Sie die ausgewiesene Proxyklasse oder generieren Sie. 

12.      */  

13.     Class cl = getProxyClass(loader, interfaces);  

15.     /* 

16.      * Invoke its Konstruktor mit dem designierten Aufruf-Handler. 

17.      */  

18.     versuchen {  

19.            /* 

20.             * Proxy源码开始有这样的定义: 

21.             * private final static Class[] constructorParams = { InvocationHandler.class }; 

22.             * Nachteile           */

23.         Constructor cons = cl.getConstructor(constructorParams);  

        
24. return (Object) cons.newInstance(

    new Object[] { h });  

25.     } catch (NoSuchMethodException e) {  

26.         throw  new InternalError(e.toString());  

27.     } catch (IllegalAccessException e) {  

28.         throw  new InternalError(e.toString());  

29.     } catch (InstantiationException e) {  

30.         throw  new InternalError(e.toString());  

31.     } catch (InvocationTargetException e) {  

32.         throw  new InternalError(e.toString());  

33.     }  

}  



Proxy.newProxyInstance(ClassLoader Loader, Class> ; [] Interfaces, Invacationhandler H) Führen Sie Folgendes aus:
(1) Rufen Sie die Methode getProxyClass (Loader, Interfaces) entsprechend dem Parameter Loader und Interfaces auf und erben Sie die Proxy-Klasse (2) Instanziieren Sie $Proxy0 und übergeben Sie DynamicSubject im Konstruktor. Dann ruft $Proxy0 den Konstruktor der übergeordneten Klasse Proxy auf und weist h wie folgt einen Wert zu:
class Proxy{ InvocationHandler h=null;

                                          = h;

}

1. ...

4. Nehmen wir mal ein Schauen Sie sich den Quellcode von $Proxy0 an, der Proxy erbt:

Java-Code

1. öffentliche finale Klasse $Proxy0 erweitert Proxy implementiert Subject {  

2.     private statische Methode m1;  

3.     private statische Methode m0;  

4.     privat statische Methode m3;  

5.     privat statische Methode m2;  

7.     statisch {  

8. versuchen Sie {  

9.             m1 = Class.forName("java.lang.Object").getMethod("equals",  

10.                      new Class[] { Class.forName("java.lang.Object") });  

12.             m0 = Class.forName("java.lang.Object").getMethod( "hashCode",  

13.                     new Class[0]);  

15.             m3 = Class.forName("***.RealSubject").getMethod( "Anfrage",  

16.                     neue Klasse[0]);  

18.             m2 = Class.forName("java.lang.Object").getMethod( "toString",  

19.                     new Class[0]);  

21.         } catch (NoSuchMethodException nosuchmethodeception) {  

22.             throw new NoSuchMethodError(nosuchmethodeception.getMessage());  

23.         } catch (ClassNotFoundException classnotfoundException) {  

24.             throw  new NoClassDefFoundError(classnotfoundException.getMessage());  

25.         }  

26.     } //statisch  

28.     public $Proxy0(InvocationHandler invocationhandler) {  

29.         super(invocationhandler);  

30.     }  

32.     @Override  

33.     public final boolean equals(Object obj) {  

34.         Versuchen Sie es {  

35.                       } 

    fangen (Wurfbar) {  

36.             

    throw 
new UndeclaredThrowableException(throwable);  

37.         }  

38.     }  

40.     

    @Override  

41.     

    public 
final 
42. int hashCode() {  

            

    versuchen {  

43.             

    return ((Integer) 
super.h.invoke(
44. this, m0, 

    null)).intValue();          } 

    fangen (Wurfbar) {  

45.             

    throw 
new UndeclaredThrowableException(throwable);  

46.         }  

47.     }  

49.     

    öffentliche 
endgültige 
50. void request() {  

            

    versuchen {  

51.             

    super.h.invoke(
this, m3, 
52. null);  

                

    zurück;  

53.         } 

    catch (Error e) {  

54.         } 

    catch (Throwable throwable) {

55.             

    throw 
new UndeclaredThrowableException(throwable);  

56.         }  

57.     }  

59.     

    @Override  

60.     

    public 
final String toString() {  

61.         

    try{  

62.             

    return (String) 
super.h.invoke(
63. this, m2,

    null);          } 

    fangen (Wurfbar) {  

64.             

    throw 
new UndeclaredThrowableException(throwable);  

65.         }  

66.     }  

67. }  

68. 
    
    Dann nimm den $, den du hast got Die Proxy0-Instanz wird in Subject umgewandelt und die Referenz wird dem Subject zugewiesen. Wenn die Methode subject.request() ausgeführt wird, wird die Methode request() in der Klasse $Proxy0 und dann die Methode invoke() von h in der übergeordneten Klasse Proxy aufgerufen. Das heißt, InvocationHandler.invoke().
    
    PS: 1. Eine Sache, die erklärt werden muss, ist, dass die getProxyClass-Methode in der Proxy-Klasse die Proxy-Klasse-Klasse zurückgibt. Der Grund, warum ich das erkläre, ist, dass ich zu Beginn einen Fehler auf niedriger Ebene gemacht habe und dachte, dass das, was zurückgegeben wurde, die „Klasse der Proxy-Klasse“ war – –! Es wird empfohlen, einen Blick auf den Quellcode von getProxyClass zu werfen. Er ist sehr lang =. =
    2. Aus dem Quellcode von $Proxy0 ist ersichtlich, dass die dynamische Proxy-Klasse nicht nur die Methoden in der explizit definierten Schnittstelle, sondern auch die geerbten equal() im Java-Root-Klassenobjekt weiterleitet , hashcode(), toString() und nur diese drei Methoden.
    
    F: Bis jetzt gibt es noch eine Frage: Der erste Parameter in der Aufrufmethode ist eine Instanz von Proxy (genauer gesagt wird letztendlich die Instanz von $Proxy0 verwendet), aber was? Was verwenden? Mit anderen Worten: Wie zeigt das Programm seine Wirkung?
    A: Auf meiner aktuellen Ebene hat dieser Proxy-Parameter keine Auswirkung. Im gesamten dynamischen Proxy-Mechanismus wird der Proxy-Parameter der Aufrufmethode in InvocationHandler nicht verwendet. Der übergebene Parameter ist tatsächlich eine Instanz der Proxy-Klasse. Ich denke, es könnte sein, dass Programmierer die Reflektion in der Aufrufmethode verwenden können, um einige Informationen über die Proxy-Klasse zu erhalten.

Das obige ist der detaillierte Inhalt vonTutorial zur Implementierung eines dynamischen Proxys in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!