Java 动态代理机制简单理解

　　Spring有两个核心的思想，一个是IOC，另一个就是AOP，而这个AOP就是建立在JAVA动态代理基础上的，下面先用一个简单的示例来说明动态代理的用法，然后简单叙述动态代理实现的原理。

一、示例

实现代理有四个步骤

1、创建一个接口

public interface Login {
    void validate();
    void login();
}

2、编写这个接口的实现类，这个类里面只包含业务方法

public class LoginImpl implements Login{

    @Override
    public void validate() {
        // TODO Auto-generated method stub
        System.out.println("validate");
    }

    @Override
    public void login() {
        // TODO Auto-generated method stub
        System.out.println("login");
    }

}

3、创建代理类，实现InvacationHandler，通过这个代理类可以动态创建代理对象，并且完成相关业务。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class LoginProxy implements InvocationHandler {
    private Object proxyObj;
    public  LoginProxy(Object obj)
    {
        this.proxyObj=obj;
    }
    
    public static Object bind(Object obj)
    {
        Class clz=obj.getClass();
        return Proxy.newProxyInstance(clz.getClassLoader(), clz.getInterfaces(), new LoginProxy(obj));
    }
    @Override
    public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {
        // TODO Auto-generated method stub
        login(arg1);
        Object res=arg1.invoke(proxyObj, arg2);
        logout(arg1);
        return res;
    }
    
    private void login(Method method)
    {
        System.out.println("before "+method.getName());
    }
    
    private void logout(Method method)
    {
        System.out.println("after "+method.getName());
    }
}

4、创建测试类。

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import sun.misc.ProxyGenerator;
public class Main {
    public static void main(String[] args) {
        //生成一个实现Login接口的类的字节码数组，测试用
        byte[] clazzFile = ProxyGenerator.generateProxyClass("$Proxy11", LoginImpl.class.getInterfaces());  
        OutputStream os=null;
        try {
            //生成的class文件放在bin文件夹里面
            os=new FileOutputStream(Main.class.getClassLoader().getResource("").getPath()+"/$Proxy11.class");
            os.write(clazzFile);
            os.flush();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                os.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //测试动态代理，生成一个代理对象，这个代理对象实现了LoginImpl实现的接口
        Login login=(Login)LoginProxy.bind(new LoginImpl());
        //代理类调用方法
        login.validate();
        login.login();
    }
}

输出

before validate
validate
after validate
before login
login
after login

二、原理简述

　　代理对象怎么获得的呢？这得从Proxy类的newProxyInstance开始，

    public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)　　throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }
        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, interfaces); // stack walk magic: do not refactor

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            SecurityManager sm = System.getSecurityManager();
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return newInstance(cons, ih);
                    }
                });
            } else {
                return newInstance(cons, ih);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

　　具体的细节可以不去看他，这里只要看红色的部分，显示获取了一个代理类，这个代理类里面有个参数是接口，正是需要代理的对象的所实现的接口，最后返回一个这个类的实例，这个类怎么得到的呢？    //弱引用hashmap key是classloader,value是Map，缓存对应类加载器的接口数组 object存放的是生成的类的弱引用

     private static Map<ClassLoader, Map<List<String>, Object>> loaderToCache= new WeakHashMap<>();
//存放生成的代理类
    private static Map<Class<?>, Void> proxyClasses = Collections.synchronizedMap(new WeakHashMap<Class<?>, Void>());


    private static Class<?> getProxyClass0(ClassLoader loader , Class<?>... interfaces) {
                        ....................此处省略一对判断
                        ....................此处省略得到接口名数组
   　　　　　　　　　　　　//对象的接口数组 
    　　　　　　　　　　List<String> key = Arrays.asList(interfaceNames);
                        ....................又是一堆验证
    　　　　　　　　　　//通过上面的接口数组生成一个类
                    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
                　　try {
                   　　 proxyClass = defineClass0(loader, proxyName,
                        proxyClassFile, 0, proxyClassFile.length);
                　　　　} catch (ClassFormatError e) {
                   　　 throw new IllegalArgumentException(e.toString());
               　　 　　}
           　　　　　 }
            　　　　// add to set of all generated proxy classes, for isProxyClass
            　　　　proxyClasses.put(proxyClass, null);
 　　　　　　　　　　} 
　　　　　　　　　　finally {
            　　　　　　synchronized (cache) {
    　　　　　　　　　　//这里的cache是Map<List<String>,Object>的对象，最上面的那个
                　　　if (proxyClass != null) {
                    　　 cache.put(key, new WeakReference<Class<?>>(proxyClass));
                　　} else {
                    　　cache.remove(key);
                　　}
                　　　　cache.notifyAll();
           　　　　 }
        　　　　}
    　　　　//返回类
       　　　　 return proxyClass;

　　在这函数里面，先获取这个对象的接口数组，再在缓存中去搜索看看有没有这个类，具体过程就是先通过classLoader来找Map，根据这个接口链表来找存放类的弱引用，假如没有的话就重新生成，至于怎么生成这个类的字节码，太复杂了，这里就省略了。

　　那么为什么这个实现了接口的代理对象调用的是login方法，而结果确实invoke被调用了呢？我们看一下生成的$Proxy1这个类，把它反编译一下就能够看到。

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

public final class $Proxy11 extends Proxy  implements Login
{
  private static Method m1;
  private static Method m4;
  private static Method m3;
  private static Method m0;
  private static Method m2;
  
  public $Proxy11(InvocationHandler paramInvocationHandler)
  {
    super(paramInvocationHandler);
  }
  
  public final boolean equals(Object paramObject)
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final void validate()
  {
    try
    {
      this.h.invoke(this, m4, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final void login()
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final int hashCode()
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final String toString()
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m4 = Class.forName("Login").getMethod("validate", new Class[0]);
      m3 = Class.forName("Login").getMethod("login", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

而Proxy类里面

    protected InvocationHandler h;

    protected Proxy(InvocationHandler h) {
        doNewInstanceCheck();
        this.h = h;
    }

　　到此真正的幕后已经出来了，就是生成了一个类，然后实例化一个对象，并把InvocationHandler接口的实现类的对象作为参数传进去，那么这个对象在调用login或者validate方法时，就会调用这个InvocationHandler接口的实现类的对象的invoke方法。