java 代理的理解

    之前看过很多相关文章，也都理解了，但是长时间不思考的话再去回忆很多细节会混乱。这个时候再去看别人的文章，由于不是自己的语言描述，看起来又会花一定时间，所以自己记录总结一下相关理解，以后看起来顺当点。

   代理，代理，也就是代为处理。在java中的体现就是，本来一个A类有do方法，一般常规就是A.do()。但是在有些场景下需要在A.do()的前后做些其它的事情，比如记录do方法执行时间，那就要在开始和结束的时候记录时间算差值。你可以在do方法内部加时间，但是这个就是自理了，并且这样做do内部耦合性太高；那么自然可以在do()的外部加时间，比如封装一个方法doExtra，在这个方法里调用do方法，并且在调用前后加上时间，这么看来就是doExtra帮助do进行了一层处理，算是有点代理的味道了。当然这只是最简单的一个解释，实际上代理并不是这么简单，一般代理的是整个对象，并且还有一些其它约束。

    根据代理表现形式分为静态代理与动态代理。静态代理的代理关系在编译时就确定，而动态代理的代理关系是在运行时确定。静态代理实现简单，要手动为目标类生成代理类，适合于代理类较少且确定的情况，而动态代理则更简单灵活。

    下面是一个静态代理的demo，首先是一个通用接口

   

 然后是目标类，也就是需要被代理的类

可以看到目标类实现了通用接口，并进行了吃饭的动作，这个时候如果需要一个代理类去代理目标类，那么可以这么写

    代理类也继承了通用接口并且要求传入目标类，在重写方法时先进行代理的一些动作，比如买菜，然后再调用目标类的正式动作吃饭。为什么目标类代理类都要实现同一个接口(或者继承父类)呢，随便建一个代理类内部调用目标类方法不就行了。因为一般使用场景是，比如spring中，你声明需要注入一个目标类实例Target a，去调用a.do()，并且需要做些额外的操作，这时如果你随意建一个代理类B去实现额外动作并调用目标类Target的do方法，那么这个时候代理类的实例就是B类型，而你声明需要注入的实例是Target类型，类型不一致无法注入，所以如果都实现一个接口那么就可以注入了；当然你也可以让代理类直接继承目标类Target来创建代理类Proxy( extends Target)，代理类由于继承了目标类，代理类的实例Proxy p直接可以注入给父类目标类Target a。事实上CGLIB动态代理就是这么做的。回到上面这个例子，看下调用方式

以及对比下代理前后

静态代理就是上面这样，要求自己写代理类，如果目标类多，代理类也要自己相应实现，并且如果通用接口增加方法，那么目标类代理类也得跟着维护，不是很方便，所以就出现了动态代理，动态代理不需要我们自己编写代理类，只需要调用相关API，指定需要代理的类(必须)，代理类实现的接口(非必须)，具体你对被代理的类的方法需要进行的操作(必须)，然后运行时由API动态创建代理对象。Java中两种常见的动态代理方式是JDK原生动态代理和CGLIB动态代理。

先说下JDK动态代理，看看如何使用，代码如下

这是个代理工厂类其中核心的就是JDK提供的Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler)。

三个参数含义：

1. loader，指定代理对象的类加载器；
2. interfaces，代理对象实现的接口，可以同时指定多个接口；
3. handler，方法调用处理者，说白了就是它提供给你一个接口InvocationHandler让你实现invoke(Object proxy, Method method, Object[] args)方法，动态代理对象方法在执行时，会调用invoke方法。方法参数含义如下
   proxy 生成的代理对象, method代理对象的方法，args代理对象方法参数
   
   在这个方法里你针对某些目标方法(method.getName判断)处理你需要附加的操作，比如记录开始时间结束时间，日志等等，然后调用目标方法method.invoke(target, args);注意这边方法调用主体对象是target，而不是代理对象proxy，不然代理对象会无限调用自己的method方法，原因跟这个动态代理的实现原理有关，主要技术就是反射。

其实最主要的逻辑就是它内部根据newProxyInstance的参数，也就是你给定的类加载器loader还有接口interfaces，运用相关技术在运行时给你生成一个实现了接口方法的代理类，并且代理类构造函数参数就是newProxyInstance传入的第三个参数InvocationHandler对象handler，然后在每个接口方法的具体实现就是内部调用handler.invoke(Object proxy, Method method, Object[] args)，invoke方法内执行method.invoke(target, args)，这样就直接执行了目标对象的方法，最后利用反射创建一个代理类的对象返回。实际上代理类就是实现了接口，套了一层壳子，内部的方法啥的还是目标对象的调用，并且在调用时进行额外操作。下面结合反编译源码讲解一下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 = getProxyClass(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            Constructor cons = cl.getConstructor(constructorParams);
            return cons.newInstance(new Object[] { h });
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        } catch (IllegalAccessException e) {
            throw new InternalError(e.toString());
        } catch (InstantiationException e) {
            throw new InternalError(e.toString());
        } catch (InvocationTargetException e) {
            throw new InternalError(e.toString());
        }
    }

getProxyClass(loader, interfaces)这个方法内部创建代理类，并且返回了代理类的Class对象，然后调用getConstructor实例化代理对象，上面说了代理类的构造方法包含InvocationHandler，所以constructorParams的定义是这样的private final static Class[] constructorParams =  { InvocationHandler.class }; 下面看看getProxyClass是怎么创建代理类的

public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
        throws IllegalArgumentException
    {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        Class<?> proxyClass = null;

        String[] interfaceNames = new String[interfaces.length];

        // for detecting duplicates
        Set<Class<?>> interfaceSet = new HashSet<>();

        for (int i = 0; i < interfaces.length; i++) {
            
            String interfaceName = interfaces[i].getName();
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(interfaceName, false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != interfaces[i]) {
                throw new IllegalArgumentException(
                    interfaces[i] + " is not visible from class loader");
            }

            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }

            if (interfaceSet.contains(interfaceClass)) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
            interfaceSet.add(interfaceClass);

            interfaceNames[i] = interfaceName;
        }

        List<String> key = Arrays.asList(interfaceNames);

        Map<List<String>, Object> cache;
        synchronized (loaderToCache) {
            cache = loaderToCache.get(loader);
            if (cache == null) {
                cache = new HashMap<>();
                loaderToCache.put(loader, cache);
            }
        
        }

        synchronized (cache) {
          
            do {
                Object value = cache.get(key);
                if (value instanceof Reference) {
                    proxyClass = (Class<?>) ((Reference) value).get();
                }
                if (proxyClass != null) {
                    // proxy class already generated: return it
                    return proxyClass;
                } else if (value == pendingGenerationMarker) {
                    // proxy class being generated: wait for it
                    try {
                        cache.wait();
                    } catch (InterruptedException e) {
                        /*
                         * The class generation that we are waiting for should
                         * take a small, bounded time, so we can safely ignore
                         * thread interrupts here.
                         */
                    }
                    continue;
                } else {
                    /*
                     * No proxy class for this list of interfaces has been
                     * generated or is being generated, so we will go and
                     * generate it now.  Mark it as pending generation.
                     */
                    cache.put(key, pendingGenerationMarker);
                    break;
                }
            } while (true);
        }

        try {
            String proxyPkg = null;     // package to define proxy class in

            for (int i = 0; i < interfaces.length; i++) {
                int flags = interfaces[i].getModifiers();
                if (!Modifier.isPublic(flags)) {
                    String name = interfaces[i].getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {     // if no non-public proxy interfaces,
                proxyPkg = "";          // use the unnamed package
            }

            {
                
                long num;
                synchronized (nextUniqueNumberLock) {
                    num = nextUniqueNumber++;
                }
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
                
                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) {
                if (proxyClass != null) {
                    cache.put(key, new WeakReference<Class<?>>(proxyClass));
                } else {
                    cache.remove(key);
                }
                cache.notifyAll();
            }
        }
        return proxyClass;
    }

 

 

可以看到String proxyName = proxyPkg + proxyClassNamePrefix + num; 这个就是在拼接代理类的类名

ProxyGenerator.generateProxyClass(
                    proxyName, interfaces);

proxyClass = defineClass0(loader, proxyName,
                        proxyClassFile, 0, proxyClassFile.length);这两个是关键方法，进入ProxyGenerator可以看到详细的生成代理类的步骤，包括参数是InvocationHandler的构造方法的创建逻辑

最后用一个代理类的示例看一下生成的Proxy类

下面代码中某些符号的说明 XXX => 实现的接口, YYY => 接口定义的某个方法
public final class $Proxy0 extends Proxy implements XXX
{
  private static Method m1;
  private static Method m2;
  private static Method m3;
  private static Method m0;
  
  /**
  *    super具体代码
  *    protected Proxy(InvocationHandler h) {
  *         Objects.requireNonNull(h);
  *         this.h = h;
  *     }
  *
  */
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  
   static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m3 = Class.forName("XXX全限定名").getMethod("YYY", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
 
  public final void YYY()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  //其它toString，hashCode、equals方法的内容 原理和实现的接口方法方法一样

}

      以上就是JDK动态代理的大致逻辑， 当然源码肯定涉及的更多，更具体。但是JDK动态代理目标类实现接口，使用CGLIB出现了，它不要求目标类实现接口，CGLIB基于ASM的字节码生成库，通过继承方式实现代理，因此代理的类不能为final,否则报错，并且目标对象的方法如果为final/static,那么就不会被拦截,即无法实现执行目标对象额外的操作.它的实现可以根据JDK动态代理的实现原理推导出来。有了这层逻辑，AOP，拦截器使用配置的原理差不多就可以理解了。