How the invoke method in java Dynamic proxy is automatically called

I. Differences between dynamic proxy and static proxy. (1) The Proxy class code is fixed and won't be huge because of the increasing size of the business; (2) AOP programming can be implemented, which cannot be implemented by the static Proxy; (3) decoupling, for web services, you can separate the data layer from the business layer. (4) the advantage of dynamic proxy is non-intrusive code extension. The static proxy mode itself has a big problem. If the number of class methods is increasing, the amount of code for the proxy class is very large. Therefore, dynamic proxies are introduced to solve such problems.

Ii. Dynamic proxy

The key to implementing dynamic Proxy in Java is Proxy and InvocationHandler. The following describes how to implement dynamic Proxy in Java by starting with the invoke method in the InvocationHandler interface.
First, the complete form of the invoke method is as follows:

Java code

1. Public Object invoke (Object proxy, Method method, Object [] args) throws Throwable
2. {
4. Method. invoke (obj, args );
6. Return null;
7. }
   First, let's guess that method is the method called, that is, the method to be executed; args is the method parameter; proxy, what is this parameter? The above implementation of the invoke () method is a standard form. We can see that the proxy parameter is not used here. View the Proxy instructions in the JDK documentation as follows:
   Java code
   1. A method invocation on a proxy instance through one of its proxy interfaces will be dispatched to the invoke method of the instance's invocation handler, passing the proxy instance, a java. lang. reflect. method object identifying the method that was invoked, and an array of type Object containing the arguments.
      From this we can know that the above Guesses are correct, and we also know that the proxy parameter is passed to the proxy class instance.
      
      For convenience, here is a simple example to implement dynamic proxy.
      
      Java code
      1. // Abstract role (Dynamic proxy can only be a proxy Interface)
      2. Public interface Subject {
      4. Public void request ();
      5. }
         Java code
         1. // Real role: implements the Subject request () method.
         2. Public class RealSubject implements Subject {
         4. Public void request (){
         5. System. out. println ("From real subject .");
         6. }
         7. }
            Java code
            1. // Implements InvocationHandler
            2. Public class DynamicSubject implements InvocationHandler
            3. {
            4. Private Object obj; // This is the benefit of dynamic proxy. The encapsulated Object is of the Object type and can be any type of Object.
            6. Public DynamicSubject ()
            7. {
            8. }
            10. Public DynamicSubject (Object obj)
            11. {
            12. This. obj = obj;
            13. }
            15. // This method is not displayed for calling
            16. Public Object invoke (Object proxy, Method method, Object [] args) throws Throwable
            17. {
            18. System. out. println ("before calling" + method );
            20. Method. invoke (obj, args );
            22. System. out. println ("after calling" + method );
            24. Return null;
            25. }
            27. }
                Java code
                1. // Client: generates a proxy instance and calls the request () method.
                2. Public class Client {
                4. Public static void main (String [] args) throws Throwable {
                5. // TODO Auto-generated method stub
                7. Subject rs = new RealSubject (); // The proxy class is specified here.
                8. InvocationHandler ds = new DynamicSubject (rs );
                9. Class Cls = rs. getClass ();
                11. // The following is a one-time generation Proxy:
                13. Subject subject = (Subject) Proxy. newProxyInstance (
                14. Cls. getClassLoader (), cls. getInterfaces (), ds );
                16. // The running result shows that the subject is an instance of the Proxy. This instance implements the Subject interface.
                17. System. out. println (subject instanceof Proxy );
                19. // Here we can see that the Class of subject is $ Proxy0. This $ Proxy0 Class inherits the Proxy and implements the Subject interface.
                20. System. out. println ("the Class of subject is:" + subject. getClass (). toString ());
                22. System. out. print ("attributes in subject are :");
                24. Field [] field = subject. getClass (). getDeclaredFields ();
                25. For (Field f: field ){
                26. System. out. print (f. getName () + ",");
                27. }
                29. System. out. print ("\ n" + "methods in subject include :");
                31. Method [] method = subject. getClass (). getDeclaredMethods ();
                33. For (Method m: method ){
                34. System. out. print (m. getName () + ",");
                35. }
                37. System. out. println ("\ n" + "subject's parent class is:" + subject. getClass (). getSuperclass ());
                39. System. out. print ("\ n" + "subject :");
                41. Class [] Interfaces = subject. getClass (). getInterfaces ();
                43. For (Class I: interfaces ){
                44. System. out. print (I. getName () + ",");
                45. }
                47. System. out. println ("\ n" + "running result :");
                48. Subject. request ();
                49. }
                50. }
                    Xml Code
                    1. The running result is as follows: the package name is omitted here, which is replaced ***.
                    2. True
                    3. The subject Class is: class $ Proxy0
                    4. Attributes in subject include m1, m3, m0, m2,
                    5. Methods In subject include: request, hashCode, equals, toString,
                    6. Subject's parent class is: class java. lang. reflect. Proxy
                    7. The subject implementation interface is: cn.edu. ustc. dynamicproxy. Subject,
                    9. The running result is:
                    10. Before calling public abstract void ***. Subject. request ()
                    11. From real subject.
                    12. After calling public abstract void ***. Subject. request ()
                        
                        PS: The result information is very important, at least for me. Because the root cause of my dizzy behavior on the dynamic proxy is to apply the above subject. the request () is wrong. At least it is confused by the surface. No connection is found between this subject and the Proxy. At one time, It is entangled in how the request () is called and invoke () contact, and how does invoke know that the request exists. In fact, the above true and class $ Proxy0 can solve a lot of questions, coupled with the $ Proxy0 source code to be discussed below, can completely solve the problem of dynamic proxy.
                        
                        From the above Code and results, we can see that the invoke () method is not displayed, but this method is indeed executed. The entire process is analyzed as follows:
                        
                        From the code in the Client, we can take the newProxyInstance method as a breakthrough. Let's take a look at the source code of the newProxyInstance method in the Proxy class:
                        Java code
                        1. Public static Object newProxyInstance (ClassLoader loader,
                        2. Class [] Interfaces,
                        3. InvocationHandler h)
                        4. Throws IllegalArgumentException
                        5. {
                        6. If (h = null ){
                        7. Throw new NullPointerException ();
                        8. }
                        10. /*
                        11. * Look up or generate the designated proxy class.
                        12. */
                        13. Class cl = getProxyClass (loader, interfaces );
                        15. /*
                        16. * Invoke its constructor with the designated invocation handler.
                        17. */
                        18. Try {
                        19. /*
                        20. * The Proxy source code is defined as follows:
                        21. * Private final static Class [] constructorParams = {InvocationHandler. class };
                        22. * Cons is the constructor of the InvocationHandler type.
                        23. */
                        24. Constructor cons = cl. getConstructor (constructorParams );
                        25. Return (Object) cons. newInstance (new Object [] {h });
                        26. } Catch (NoSuchMethodException e ){
                        27. Throw new InternalError (e. toString ());
                        28. } Catch (IllegalAccessException e ){
                        29. Throw new InternalError (e. toString ());
                        30. } Catch (InstantiationException e ){
                        31. Throw new InternalError (e. toString ());
                        32. } Catch (InvocationTargetException e ){
                        33. Throw new InternalError (e. toString ());
                        34. }
                        35. }
                            
                            Proxy. newProxyInstance (ClassLoader loader, Class [] Interfaces, InvocationHandler h) Does the following.
                            (1) create a Proxy class $ Proxy0. $ Proxy0 Class Based on the getProxyClass (loader, interfaces) Call methods of the loader and interfaces parameters to implement the interfaces interface and inherit the Proxy class.
                            (2) instantiate $ Proxy0 and pass DynamicSubject to the constructor In the constructor method. Then $ Proxy0 calls the constructor of the parent class Proxy and assigns a value to h, as shown below:
                            Java code
                            1. Class Proxy {
                            2. InvocationHandler h = null;
                            3. Protected Proxy (InvocationHandler h ){
                            4. This. h = h;
                            5. }
                            6. ...
                            7. }
                               
                               Let's take a look at the source code that inherits the $ Proxy0 of Proxy:
                               Java code
                               1. Public final class $ Proxy0 extends Proxy implements Subject {
                               2. Private static Method m1;
                               3. Private static Method m0;
                               4. Private static Method m3;
                               5. Private static Method m2;
                               7. Static {
                               8. Try {
                               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 ("request ",
                               16. New Class [0]);
                               18. M2 = Class. forName ("java. lang. Object"). getMethod ("toString ",
                               19. New Class [0]);
                               21. } Catch (NoSuchMethodException nosuchmethodexception ){
                               22. Throw new NoSuchMethodError (nosuchmethodexception. getMessage ());
                               23. } Catch (ClassNotFoundException classnotfoundexception ){
                               24. Throw new NoClassDefFoundError (classnotfoundexception. getMessage ());
                               25. }
                               26. } // Static
                               28. Public $ Proxy0 (InvocationHandler invocationhandler ){
                               29. Super (invocationhandler );
                               30. }
                               32. @ Override
                               33. Public final boolean equals (Object obj ){
                               34. Try {
                               35. Return (Boolean) super. h. invoke (this, m1, new Object [] {obj}). booleanValue ();
                               36. } Catch (Throwable throwable ){
                               37. Throw new UndeclaredThrowableException (throwable );
                               38. }
                               39. }
                               41. @ Override
                               42. Public final int hashCode (){
                               43. Try {
                               44. Return (Integer) super. h. invoke (this, m0, null). intValue ();
                               45. } Catch (Throwable throwable ){
                               46. Throw new UndeclaredThrowableException (throwable );
                               47. }
                               48. }
                               50. Public final void request (){
                               51. Try {
                               52. Super. h. invoke (this, m3, null );
                               53. Return;
                               54. } Catch (Error e ){
                               55. } Catch (Throwable throwable ){
                               56. Throw new UndeclaredThrowableException (throwable );
                               57. }
                               58. }
                               60. @ Override
                               61. Public final String toString (){
                               62. Try {
                               63. Return (String) super. h. invoke (this, m2, null );
                               64. } Catch (Throwable throwable ){
                               65. Throw new UndeclaredThrowableException (throwable );
                               66. }
                               67. }
                               68. }
                                   
                                   Then, convert the obtained $ Proxy0 instance to Subject and assign the reference to subject. When subject. the request () method in the $ Proxy0 class is called, and the invoke () method of h in the parent class Proxy is called. that is, InvocationHandler. invoke ().
                                   
                                   PS: 1. Note that the getProxyClass method in the Proxy Class returns the Proxy Class. The reason for this is that I first made a low-level error and thought that the returned Class was "Class under the proxy Class "--! It is recommended that you take a look at the source code of getProxyClass, which is very long =. =
                                   2. From the source code of $ Proxy0, we can see that the dynamic proxy class not only proxy the methods in the display defined interface, but also proxies the inherited equals () in the java root class Object (), hashcode (), toString (), and only the three methods.
                                   
                                   Q: so far, I have another question: the first parameter in the invoke method is the Proxy instance (to be precise, the $ Proxy0 instance is used in the end). But what is the purpose? In other words, how does one display the function in the program?
                                   A: As far as my current level is concerned, this proxy parameter does not play A role. In the entire dynamic proxy mechanism, the proxy parameter of the InvocationHandler method is not used. The input parameter is actually an instance of the proxy class. I think it may be to allow programmers to use reflection in the invoke method to obtain some information about the proxy class.