基于jdk动态代理的实现与源码解析

Java有动态代理本质就是借助Java的字节码操作工具来实现在Java程序运行的时候动态生成相关的新的字节码，即新的类，并用新生成的类的对象实现相关额外操作动态代理在spring框架中被广泛地使用，主要有两种动态代理，一种是基于JDK本身的，别一种是基于cglib的,在spring中，如果一个类实现了某个接口，就用Jdk动态代理来实现，如果没有实现任何相关的接口，就用cglib来实现，下面就这两种实现动态代理的方法进行说明：

   基于的jdk的动态代理，在被代理的类一定要实现一个接口：

   假设某个类实现了BusinessInterface这个接口，接口中只有一个方法，定义如下：

package com.tds.jdk;    public interface BusinessInterface {        public void doSomething();  }  

接口的实现类定义如下：

package com.tds.jdk;    public class BusinessObject implements BusinessInterface {        @Override      public void doSomething() {          // TODO Auto-generated method stub          System.out.println("方法正在执行...");      }    }  

然后我们再写一个类LogHandler，这个类一定要实现InvocationHandler这个接口，InvocationHandler这个接口是jdk反射包中一个接口，这个接口中只有一个方法，接口定义如下:

package java.lang.reflect;/** * {@code InvocationHandler} is the interface implemented by * the <i>invocation handler</i> of a proxy instance. * * <p>Each proxy instance has an associated invocation handler. * When a method is invoked on a proxy instance, the method * invocation is encoded and dispatched to the {@code invoke} * method of its invocation handler. * * @author      Peter Jones * @see         Proxy * @since       1.3 */public interface InvocationHandler {    /**     * Processes a method invocation on a proxy instance and returns     * the result.  This method will be invoked on an invocation handler     * when a method is invoked on a proxy instance that it is     * associated with.     *     * @param   proxy the proxy instance that the method was invoked on     *     * @param   method the {@code Method} instance corresponding to     * the interface method invoked on the proxy instance.  The declaring     * class of the {@code Method} object will be the interface that     * the method was declared in, which may be a superinterface of the     * proxy interface that the proxy class inherits the method through.     *     * @param   args an array of objects containing the values of the     * arguments passed in the method invocation on the proxy instance,     * or {@code null} if interface method takes no arguments.     * Arguments of primitive types are wrapped in instances of the     * appropriate primitive wrapper class, such as     * {@code java.lang.Integer} or {@code java.lang.Boolean}.     *     * @return  the value to return from the method invocation on the     * proxy instance.  If the declared return type of the interface     * method is a primitive type, then the value returned by     * this method must be an instance of the corresponding primitive     * wrapper class; otherwise, it must be a type assignable to the     * declared return type.  If the value returned by this method is     * {@code null} and the interface method's return type is     * primitive, then a {@code NullPointerException} will be     * thrown by the method invocation on the proxy instance.  If the     * value returned by this method is otherwise not compatible with     * the interface method's declared return type as described above,     * a {@code ClassCastException} will be thrown by the method     * invocation on the proxy instance.     *     * @throws  Throwable the exception to throw from the method     * invocation on the proxy instance.  The exception's type must be     * assignable either to any of the exception types declared in the     * {@code throws} clause of the interface method or to the     * unchecked exception types {@code java.lang.RuntimeException}     * or {@code java.lang.Error}.  If a checked exception is     * thrown by this method that is not assignable to any of the     * exception types declared in the {@code throws} clause of     * the interface method, then an     * {@link UndeclaredThrowableException} containing the     * exception that was thrown by this method will be thrown by the     * method invocation on the proxy instance.     *     * @see     UndeclaredThrowableException     */    public Object invoke(Object proxy, Method method, Object[] args)        throws Throwable;}

我们重点关注invoke这个方法，这个方法有三个参数，第一个参数是指要被代理的对象，第二个参数是要指要被代理实例的方法，第三个参数是被代理方法的实参

LogHandler类的定义如下：

package com.tds.jdk;    import java.lang.reflect.InvocationHandler;  import java.lang.reflect.Method;    public class LogHandler implements InvocationHandler {        private Object delegate;            public LogHandler(Object delegate) {          this.delegate = delegate;      }            @Override      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {            Object o = null;          System.out.println("方法开始..." + method.getName());          o = method.invoke(this.delegate, args);          System.out.println("方法结束..." + method.getName());          return o;      }  }  

测试类代码如下：

package com.tds.jdk;    import java.lang.reflect.InvocationHandler;  import java.lang.reflect.Proxy;    public class TestProxy {        public static void main(String[] args) {                    BusinessInterface businessObject = new BusinessObject();                    InvocationHandler logHandler = new LogHandler(businessObject);                    BusinessInterface proxy = (BusinessInterface)Proxy.newProxyInstance(                  businessObject.getClass().getClassLoader(),                   businessObject.getClass().getInterfaces(),                   logHandler);                    proxy.doSomething();  //      System.out.println(businessObject.getClass().getClassLoader().getClass().getName());  //      System.out.println(businessObject.getClass().getInterfaces()[0].getCanonicalName());          System.out.println(proxy.getClass().getName());          System.out.println(proxy instanceof Proxy);  //      System.out.println(BusinessObject.class.getName());      }  }  

运行结果如下：

方法开始...doSomething
方法正在执行...
方法结束...doSomething
com.sun.proxy.$Proxy0
true

从输出的接口，我们可以看出，代理对象输出的结果确实是我们所预期的，代理的对象的类型是com.sun.proxy.$Proxy0，实际中所有通过Jdk实现的动态代理类的类型都是com.sun.proxy.$Proxy0, 并且这个类是java.lang.reflect.Proxy类的子类，我们跟踪一下整个运行过程：

首先进入到Proxy类的 newProxyInstance这个方法，方法的源码如下：

@CallerSensitive      public static Object newProxyInstance(ClassLoader loader,                                            Class<?>[] interfaces,                                            InvocationHandler h)          throws IllegalArgumentException      {          if (h == null) {              throw new NullPointerException();          }            final SecurityManager sm = System.getSecurityManager();          if (sm != null) {              checkProxyAccess(Reflection.getCallerClass(), loader, interfaces);          }            /*          * Look up or generate the designated proxy class.          */          Class<?> cl = getProxyClass0(loader, interfaces);            /*          * Invoke its constructor with the designated invocation handler.          */          try {              final Constructor<?> cons = cl.getConstructor(constructorParams);              final InvocationHandler ih = h;              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());          }      }  

这个方法的主要流程如下：

1.首先判断传进来的InvocationHandle接口实例对象是否为空，如果为空，则抛出异常结束；

2.然后判断系统的安全，这个是基于JVM，大多数情况都为空，如果不为空，还要进行访问权限检查；

3.根据 loader和interfaces参数，形成新的字节码类c1，在这里用到Java字节码操作框架；

4.根据得到的类c1和参数constructorParams，获得这个新类的构造器cons，其中constructorParams在Proxy中的定义为：

   private static final Class<?>[] constructorParams =  { InvocationHandler.class }; 

5.根据得到的构造器cons和传进来的参数h，由反射获得要被代码的对象；

第3步中的getProxyClasso这个方法的定义如下：

private static Class<?> getProxyClass0(ClassLoader loader,                                            Class<?>... interfaces) {         if (interfaces.length > 65535) {             throw 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         return proxyClassCache.get(loader, interfaces);  }  

这个方法主要就是调用了proxyClassCache字段的get方法，proxyClassCache的定义如下：

private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());  

从定义上可以看出，这个是一个WeakCache类的一个实例，WeakCache这个类的get方法定义如下：

public V get(K key, P parameter) {          Objects.requireNonNull(parameter);            expungeStaleEntries();            Object cacheKey = CacheKey.valueOf(key, refQueue);            // lazily install the 2nd level valuesMap for the particular cacheKey          ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);          if (valuesMap == null) {              ConcurrentMap<Object, Supplier<V>> oldValuesMap                  = map.putIfAbsent(cacheKey,                                    valuesMap = new ConcurrentHashMap<>());              if (oldValuesMap != null) {                  valuesMap = oldValuesMap;              }          }            // create subKey and retrieve the possible Supplier<V> stored by that          // subKey from valuesMap          Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));          Supplier<V> supplier = valuesMap.get(subKey);          Factory factory = null;            while (true) {              if (supplier != null) {                  // supplier might be a Factory or a CacheValue<V> instance                  V value = supplier.get();                  if (value != null) {                      return value;                  }              }              // else no supplier in cache              // or a supplier that returned null (could be a cleared CacheValue              // or a Factory that wasn't successful in installing the CacheValue)                // lazily construct a Factory              if (factory == null) {                  factory = new Factory(key, parameter, subKey, valuesMap);              }                if (supplier == null) {                  supplier = valuesMap.putIfAbsent(subKey, factory);                  if (supplier == null) {                      // successfully installed Factory                      supplier = factory;                  }                  // else retry with winning supplier              } else {                  if (valuesMap.replace(subKey, supplier, factory)) {                      // successfully replaced                      // cleared CacheEntry / unsuccessful Factory                      // with our Factory                      supplier = factory;                  } else {                      // retry with current supplier                      supplier = valuesMap.get(subKey);                  }              }          }      }  

这段代码主要的意思就是如果缓存中没有相关的代理类的字段码，就生成一份，并添加缓存中，并从缓存中取出；如果缓存中原来就有代理类的字节码，就直接从缓存中取出即可，根据java内存管理可知，管理类字节码的部分是存放在永久代的。