深入理解 Java 动态代理机制 java的动态代理机制详解

public interface Person {
    void setName(String name);
}

class Student implements Person {
    
    private String mName;

    public Student(String name) {
        mName = name;
    }

     setName(String name) {
        mName = name;
    }
}

class PersonHandler<T>  InvocationHandler {
    // 代理的目标对象
     T mTarget;

     PersonHandler(T target) {
        mTarget = target;
    }

    @Override
    public Object invoke(Object o,Method method,Object[] objects) throws Throwable {
         调用开始前的操作
        ProxyUtil.start();
         调用方法,通过反射的形式来调用 mTarget 的 method 
        Object result = method.invoke(mTarget,objects);
         打印改名前的名字
        ProxyUtil.log(objects[0].toString());
         调用结束后的操作
        ProxyUtil.finish();
        return result;
    }
}

class ProxyUtil {
    private static final String TAG = "ProxyUtil";

     start() {
        Log.d(TAG,"start: " + System.currentTimeMillis());
    }

     finish() {
        Log.d(TAG,"finish: " + log(String name) {
        Log.d(TAG,"log: " + name);
    }
}

class MainActivity extends AppCompatActivity {
    @Override
    protected  onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        创建一个实例对象，这个对象是被代理的对象
        Person zhangsan = new Student("张三");

        创建一个与代理对象相关联的 InvocationHandler
        PersonHandler stuHandler = new PersonHandler<>(zhangsan);

        创建一个代理对象 stuProxy 来代理 zhangsan，代理对象的每个执行方法都会替换执行 Invocation 中的 invoke 方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(),new Class<?>[]{Person.},stuHandler);

        代理执行 setName 的方法，代理实例内部又会调用 stuHandler 的 invoke方法，在通过反射调用了调用了被代理对象的方法
        stuProxy.setName("王五");
}

Log.d(TAG,"onCreate: " + stuProxy.getClass().getCanonicalName());

/**
     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation
     * handler.
     *
     * <p>{@code Proxy.newProxyInstance} throws
     * { IllegalArgumentException} for the same reasons that
     * { Proxy.getProxyClass} does.
     *
     * @param   loader the class loader to define the proxy class
     *    interfaces the list of interfaces for the proxy class
     *          to implement
     *    h the invocation handler to dispatch method invocations to
     * @return  a proxy instance with the specified invocation handler of a
     *          proxy class that is defined by the specified class loader
     *          and that implements the specified interfaces
     * @throws  IllegalArgumentException if any of the restrictions on the
     *          parameters that may be passed to { getProxyClass}
     *          are violated
     *   SecurityException if a security manager,<em>s</em>,is present
     *          and any of the following conditions is met:
     *          <ul>
     *          <li> the given { loader} is { null} and
     *               the caller's class loader is not { null} and the
     *               invocation of {@link SecurityManager#checkPermission
     *               s.checkPermission} with
     *               { RuntimePermission("getClassLoader")} permission
     *               denies access;</li>
     *          <li> for each proxy interface,{ intf},*               the caller's class loader is not the same as or an
     *               ancestor of the class loader for { intf} and
     *               invocation of { SecurityManager#checkPackageAccess
     *               s.checkPackageAccess()} denies access to { intf};</li>
     *          <li> any of the given proxy interfaces is non-public and the
     *               caller class is not in the same {@linkplain Package runtime package}
     *               as the non-public interface and the invocation of
     *               { SecurityManager#checkPermission s.checkPermission} with
     *               { ReflectPermission("newProxyInPackage.{package name}")}
     *               permission denies access.</li>
     *          </ul>
     *   NullPointerException if the { interfaces} array
     *          argument or any of its elements are { null},or
     *          if the invocation handler,1)"> h},is
     *          { null}
     */
    @CallerSensitive
    static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
         IllegalArgumentException
    {
　　　　　// 判空，判断 h 对象是否为空，为空就抛出 NullPointerException
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
　　　　　　　// 进行包访问权限、类加载器等权限检查
            checkProxyAccess(Reflection.getCallerClass(),loader,intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         
        Class<?> cl = getProxyClass0(loader,intfs);

        
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            ) {
                checkNewProxyPermission(Reflection.getCallerClass(),cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                     Void run() {
                        cons.setAccessible(true);
                        return ;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw  InternalError(e.toString(),e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                 InternalError(t.toString(),t);
            }
        }  (NoSuchMethodException e) {
            

     * Generate a proxy class.  Must call the checkProxyAccess method
     * to perform permission checks before calling this.
     */
    static Class<?> getProxyClass0(ClassLoader loader,1)">... interfaces) {
　　　　 // 数量超过 65535 就抛出异常，665535 这个就不用说了吧
        if (interfaces.length > 65535) {
            new IllegalArgumentException("interface limit exceeded");
        }

         If the proxy class defined by the given loader implementing
         the given interfaces exists,this will simply return the cached copy;
         otherwise,it will create the proxy class via the ProxyClassFactory
         proxyClassCache.get(loader,interfaces);
    }

proxyClassCache = new WeakCache<>(new KeyFactory(),1)">new ProxyClassFactory());

     * A factory function that generates,defines and returns the proxy class given
     * the ClassLoader and array of interfaces.
     final  ProxyClassFactory
        implements BiFunction<ClassLoader,Class<?>[],Class<?>>
    {
         prefix for all proxy class names 定义前缀
        final String proxyClassNamePrefix = "$Proxy";

         next number to use for generation of unique proxy class names  原子操作，适用于多线程
        final AtomicLong nextUniqueNumber =  AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader,Class<?>[] interfaces) {

            Map<Class<?>,Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 
                Class<?> interfaceClass = ;
                 {
　　　　　　　　　　　　// 通过反射获取到接口类
                    interfaceClass = Class.forName(intf.getName(),1)">false,loader);
                }  (ClassNotFoundException e) {
                }
　　　　　　　　　// 所得到的接口类与传进来的不相等，说明不是同一个类
                if (interfaceClass != intf) {
                     IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                interfaceClass.isInterface()) {
                     IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface"
                 * Verify that this interface is not a duplicate. 
if (interfaceSet.put(interfaceClass,Boolean.TRUE) != ) {
                     IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;      package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            int flags = intf.getModifiers();
                Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0,n + 1));
                    if (proxyPkg == ) {
                        proxyPkg = pkg;
                    } else pkg.equals(proxyPkg)) {
                         IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            ) {
                 if no non-public proxy interfaces,use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            
             * Choose a name for the proxy class to generate.
             long num = nextUniqueNumber.getAndIncrement();
　　　　　　　// 生产代理类的名字
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            
             * Generate the specified proxy class.
             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName,interfaces,accessFlags);
             defineClass0(loader,proxyName,proxyClassFile,0 (ClassFormatError e) {
                
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                  IllegalArgumentException(e.toString());
            }
        }
    }

byte[] generateProxyClass(final String name,Class[] interfaces)  
   {  
       ProxyGenerator gen =  ProxyGenerator(name,interfaces);  
     这里动态生成代理类的字节码，由于比较复杂就不进去看了  
       byte[] classFile = gen.generateClassFile();  
  
     如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上  
       if (saveGeneratedFiles) {  
           java.security.AccessController.doPrivileged(  
           new java.security.PrivilegedAction<Void>() {  
                Void run() {  
                    {  
                       FileOutputStream file =  
                           new FileOutputStream(dotToSlash(name) + ".class");  
                       file.write(classFile);  
                       file.close();  
                       ;  
                   }  (IOException e) {  
                        InternalError(  
                           "I/O exception saving generated file: " + e);  
                   }  
               }  
           });  
       }  
  
     返回代理类的字节码  
        classFile;  
   }  

 ProxyGeneratorUtils {
    
     * 把代理类的字节码写到硬盘上 
     *  path 保存路径 
      writeProxyClassToHardDisk(String path) {
 获取代理类的字节码  
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy11",Student..getInterfaces());
 
        FileOutputStream out = ;
 
         {
            out =  FileOutputStream(path);
            out.write(classFile);
            out.flush();
        }  (Exception e) {
            e.printStackTrace();
        } finally {
                out.close();
            }  (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 Main {
     main(String[] args) {
        ProxyGeneratorUtils.writeProxyClassToHardDisk("$Proxy0.class");
    }
}

import java.lang.reflect.InvocationHandler;
 java.lang.reflect.Method;
 java.lang.reflect.Proxy;
 java.lang.reflect.UndeclaredThrowableException;
 proxy.Person;

class $Proxy0 extends Proxy  Person
{
   Method m1;
   Method m2;
   Method m3;
   Method m0;
  
  
  *注意这里是生成代理类的构造方法，方法参数为InvocationHandler类型，看到这，是不是就有点明白
  *为何代理对象调用方法都是执行InvocationHandler中的invoke方法，而InvocationHandler又持有一个
  *被代理对象的实例，不禁会想难道是....？ 没错，就是你想的那样。
  *
  *super(paramInvocationHandler)，是调用父类Proxy的构造方法。
  *父类持有：protected InvocationHandler h;
  *Proxy构造方法：
  *    protected Proxy(InvocationHandler h) {
  *         Objects.requireNonNull(h);
  *         this.h = h;
  *     }
  *
  */
   $Proxy0(InvocationHandler paramInvocationHandler)
     
  {
    (paramInvocationHandler);
  }
  
  这个静态块本来是在最后的，我把它拿到前面来，方便描述
   
  {
    
    {
      看看这儿静态块儿里面有什么，是不是找到了giveMoney方法。请记住giveMoney通过反射得到的名字m3，其他的先不管
      m1 = Class.forName("java.lang.Object").getMethod("equals",1)">new Class[] { Class.forName("java.lang.Object") });
      m2 = Class.forName("java.lang.Object").getMethod("toString",1)">new Class[0]);
      m3 = Class.forName("proxy.Person").getMethod("giveMoney",1)">]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode",1)">]);
      ;
    }
     (NoSuchMethodException localNoSuchMethodException)
    {
       NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
     (ClassNotFoundException localClassNotFoundException)
    {
       NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
 
  
  * 
  *这里调用代理对象的giveMoney方法，直接就调用了InvocationHandler中的invoke方法，并把m3传了进去。
  *this.h.invoke(this,m3,null);这里简单，明了。
  *来，再想想，代理对象持有一个InvocationHandler对象，InvocationHandler对象持有一个被代理的对象，
  *再联系到InvacationHandler中的invoke方法。嗯，就是这样。
   giveMoney()
    this.h.invoke(this,1)">);
      catch (Error|RuntimeException localError)
    {
       localError;
    }
     (Throwable localThrowable)
    {
       UndeclaredThrowableException(localThrowable);
    }
  }

  注意，这里为了节省篇幅，省去了toString，hashCode、equals方法的内容。原理和giveMoney方法一毛一样。

}