CGLIB动态代理实现原理

爱被打了一巴掌 2023-06-13 14:28 35阅读 0赞

# 前言 #

Spring代码实例：[https://github.com/yihonglei/Spring-Study][https_github.com_yihonglei_Spring-Study]

# 一 CGLIB介绍 #

CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，

它可以在运行期扩展Java类与实现Java接口。Hibernate用它来实现PO(Persistent Object 持久化对象)字节码的动态生成。

CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用，例如Spring AOP为他们提供

方法的interception（拦截）。CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。

除了CGLIB包，脚本语言例如Groovy和BeanShell，也是使用ASM来生成java的字节码。当然不鼓励直接使用ASM，

因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

# 二 CGLIB动态代理实例 #

实现一个业务类，注意，这个业务类并没有实现任何接口：

package com.lanhuigu.spring.proxy.cglib; 
       
       public class HelloService { 
       
       public HelloService() { 
       System.out.println( "HelloService构造"); 
       } 
       
       /** 
       * 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的 
       */ 
       final public String sayOthers(String name) { 
       System.out.println( "HelloService:sayOthers>>"+name); 
       return null; 
       } 
       
       public void sayHello() { 
       System.out.println( "HelloService:sayHello"); 
       } 
       }

自定义MethodInterceptor：

package com.lanhuigu.spring.proxy.cglib; 
       
       import net.sf.cglib.proxy.MethodInterceptor; 
       import net.sf.cglib.proxy.MethodProxy; 
       
       import java.lang.reflect.Method; 
       
       /** 
       * 自定义MethodInterceptor 
       */ 
       public class MyMethodInterceptor implements MethodInterceptor{ 
       
       /** 
       * sub：cglib生成的代理对象 
       * method：被代理对象方法 
       * objects：方法入参 
       * methodProxy: 代理方法 
       */ 
       @Override 
       public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
       System.out.println( "======插入前置通知======"); 
       Object object = methodProxy.invokeSuper(sub, objects); 
       System.out.println( "======插入后者通知======"); 
       return object; 
       } 
       }

生成CGLIB代理对象调用目标方法：

package com.lanhuigu.spring.proxy.cglib; 
       
       import net.sf.cglib.core.DebuggingClassWriter; 
       import net.sf.cglib.proxy.Enhancer; 
       
       public class Client { 
       public static void main(String[] args) { 
       // 代理类class文件存入本地磁盘方便我们反编译查看源码 
       System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code"); 
       // 通过CGLIB动态代理获取代理对象的过程 
       Enhancer enhancer = new Enhancer(); 
       // 设置enhancer对象的父类 
       enhancer.setSuperclass(HelloService.class); 
       // 设置enhancer的回调对象 
       enhancer.setCallback( new MyMethodInterceptor()); 
       // 创建代理对象 
       HelloService proxy= (HelloService)enhancer.create(); 
       // 通过代理对象调用目标方法 
       proxy.sayHello(); 
       } 
       }

运行结果:

![20180609155146518][]

# 三 CGLIB动态代理源码分析 #

实现CGLIB动态代理必须实现MethodInterceptor(方法拦截器)接口，源码如下:

/* 
       * Copyright 2002,2003 The Apache Software Foundation 
       * 
       * Licensed under the Apache License, Version 2.0 (the "License"); 
       * you may not use this file except in compliance with the License. 
       * You may obtain a copy of the License at 
       * 
       * http://www.apache.org/licenses/LICENSE-2.0 
       * 
       * Unless required by applicable law or agreed to in writing, software 
       * distributed under the License is distributed on an "AS IS" BASIS, 
       * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
       * See the License for the specific language governing permissions and 
       * limitations under the License. 
       */ 
       package net.sf.cglib.proxy; 
       
       /** 
       * General-purpose { @link Enhancer} callback which provides for "around advice". 
       * @author Juozas Baliuka <a href="mailto:baliuka@mwm.lt">baliuka@mwm.lt</a> 
       * @version $Id: MethodInterceptor.java,v 1.8 2004/06/24 21:15:20 herbyderby Exp $ 
       */ 
       public interface MethodInterceptor 
       extends Callback 
       { 
       /** 
       * All generated proxied methods call this method instead of the original method. 
       * The original method may either be invoked by normal reflection using the Method object, 
       * or by using the MethodProxy (faster). 
       * @param obj "this", the enhanced object 
       * @param method intercepted Method 
       * @param args argument array; primitive types are wrapped 
       * @param proxy used to invoke super (non-intercepted method); may be called 
       * as many times as needed 
       * @throws Throwable any exception may be thrown; if so, super method will not be invoked 
       * @return any value compatible with the signature of the proxied method. Method returning void will ignore this value. 
       * @see MethodProxy 
       */ 
       public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args, 
       MethodProxy proxy) throws Throwable; 
       
       }

这个接口只有一个intercept()方法，这个方法有4个参数：

1）obj表示增强的对象，即实现这个接口类的一个对象；

2）method表示要被拦截的方法；

3）args表示要被拦截方法的参数；

4）proxy表示要触发父类的方法对象；

在上面的Client代码中，通过Enhancer.create()方法创建代理对象，create()方法的源码：

/** 
       * Generate a new class if necessary and uses the specified 
       * callbacks (if any) to create a new object instance. 
       * Uses the no-arg constructor of the superclass. 
       * @return a new instance 
       */ 
       public Object create() { 
       classOnly = false; 
       argumentTypes = null; 
       return createHelper(); 
       }

该方法含义就是如果有必要就创建一个新类，并且用指定的回调对象创建一个新的对象实例，

使用的父类的参数的构造方法来实例化父类的部分。核心内容在createHelper()中，源码如下:

private Object createHelper() { 
       preValidate(); 
       Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null, 
       ReflectUtils.getNames(interfaces), 
       filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter), 
       callbackTypes, 
       useFactory, 
       interceptDuringConstruction, 
       serialVersionUID); 
       this.currentKey = key; 
       Object result = super.create(key); 
       return result; 
       }

preValidate()方法校验callbackTypes、filter是否为空，以及为空时的处理。

通过newInstance()方法创建EnhancerKey对象，作为Enhancer父类AbstractClassGenerator.create()方法

创建代理对象的参数。

protected Object create(Object key) { 
       try { 
       ClassLoader loader = getClassLoader(); 
       Map<ClassLoader, ClassLoaderData> cache = CACHE; 
       ClassLoaderData data = cache.get(loader); 
       if (data == null) { 
       synchronized (AbstractClassGenerator.class) { 
       cache = CACHE; 
       data = cache.get(loader); 
       if (data == null) { 
       Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache); 
       data = new ClassLoaderData(loader); 
       newCache.put(loader, data); 
       CACHE = newCache; 
       } 
       } 
       } 
       this.key = key; 
       Object obj = data.get( this, getUseCache()); 
       if (obj instanceof Class) { 
       return firstInstance((Class) obj); 
       } 
       return nextInstance(obj); 
       } catch (RuntimeException e) { 
       throw e; 
       } catch (Error e) { 
       throw e; 
       } catch (Exception e) { 
       throw new CodeGenerationException(e); 
       } 
       }

真正创建代理对象方法在nextInstance()方法中，该方法为抽象类AbstractClassGenerator的一个方法，签名如下：

**abstract protected Object nextInstance(Object instance) throws Exception;**

在子类Enhancer中实现，实现源码如下：

protected Object nextInstance(Object instance) { 
       EnhancerFactoryData data = (EnhancerFactoryData) instance; 
       
       if (classOnly) { 
       return data.generatedClass; 
       } 
       
       Class[] argumentTypes = this.argumentTypes; 
       Object[] arguments = this.arguments; 
       if (argumentTypes == null) { 
       argumentTypes = Constants.EMPTY_CLASS_ARRAY; 
       arguments = null; 
       } 
       return data.newInstance(argumentTypes, arguments, callbacks); 
       }

看看data.newInstance(argumentTypes, arguments, callbacks)方法，

第一个参数为代理对象的构成器类型，第二个为代理对象构造方法参数，第三个为对应回调对象。

最后根据这些参数，通过反射生成代理对象，源码如下：

/** 
       * Creates proxy instance for given argument types, and assigns the callbacks. 
       * Ideally, for each proxy class, just one set of argument types should be used, 
       * otherwise it would have to spend time on constructor lookup. 
       * Technically, it is a re-implementation of { @link Enhancer#createUsingReflection(Class)}, 
       * with "cache { @link #setThreadCallbacks} and { @link #primaryConstructor}" 
       * 
       * @see #createUsingReflection(Class) 
       * @param argumentTypes constructor argument types 
       * @param arguments constructor arguments 
       * @param callbacks callbacks to set for the new instance 
       * @return newly created proxy 
       */ 
       public Object newInstance(Class[] argumentTypes, Object[] arguments, Callback[] callbacks) { 
       setThreadCallbacks(callbacks); 
       try { 
       // Explicit reference equality is added here just in case Arrays.equals does not have one 
       if (primaryConstructorArgTypes == argumentTypes || 
       Arrays.equals(primaryConstructorArgTypes, argumentTypes)) { 
       // If we have relevant Constructor instance at hand, just call it 
       // This skips "get constructors" machinery 
       return ReflectUtils.newInstance(primaryConstructor, arguments); 
       } 
       // Take a slow path if observing unexpected argument types 
       return ReflectUtils.newInstance(generatedClass, argumentTypes, arguments); 
       } finally { 
       // clear thread callbacks to allow them to be gc'd 
       setThreadCallbacks( null); 
       } 
       
       }

最后生成代理对象：

![20180609171446315][]

将其反编译后代码如下：

package com.lanhuigu.spring.proxy.cglib; 
       
       import java.lang.reflect.Method; 
       import net.sf.cglib.core.ReflectUtils; 
       import net.sf.cglib.core.Signature; 
       import net.sf.cglib.proxy.*; 
       
       public class HelloService$$EnhancerByCGLIB$$4da4ebaf extends HelloService 
       implements Factory 
       { 
       
       private boolean CGLIB$BOUND; 
       public static Object CGLIB$FACTORY_DATA; 
       private static final ThreadLocal CGLIB$THREAD_CALLBACKS; 
       private static final Callback CGLIB$STATIC_CALLBACKS[]; 
       private MethodInterceptor CGLIB$CALLBACK_0; // 拦截器 
       private static Object CGLIB$CALLBACK_FILTER; 
       private static final Method CGLIB$sayHello$ 0$Method; // 被代理方法 
       private static final MethodProxy CGLIB$sayHello$ 0$Proxy; // 代理方法 
       private static final Object CGLIB$emptyArgs[]; 
       private static final Method CGLIB$equals$ 1$Method; 
       private static final MethodProxy CGLIB$equals$ 1$Proxy; 
       private static final Method CGLIB$toString$ 2$Method; 
       private static final MethodProxy CGLIB$toString$ 2$Proxy; 
       private static final Method CGLIB$hashCode$ 3$Method; 
       private static final MethodProxy CGLIB$hashCode$ 3$Proxy; 
       private static final Method CGLIB$clone$ 4$Method; 
       private static final MethodProxy CGLIB$clone$ 4$Proxy; 
       
       static void CGLIB$STATICHOOK1() 
       { 
       Method amethod[]; 
       Method amethod1[]; 
       CGLIB$THREAD_CALLBACKS = new ThreadLocal(); 
       CGLIB$emptyArgs = new Object[ 0]; 
       // 代理类 
       Class class1 = Class.forName( "com.lanhuigu.spring.proxy.cglib.HelloService$$EnhancerByCGLIB$$4da4ebaf"); 
       // 被代理类 
       Class class2; 
       amethod = ReflectUtils.findMethods( new String[] { 
       "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;" 
       }, (class2 = Class.forName( "java.lang.Object")).getDeclaredMethods()); 
       Method[] = amethod; 
       CGLIB$equals$ 1$Method = amethod[ 0]; 
       CGLIB$equals$ 1$Proxy = MethodProxy.create(class2, class1, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1"); 
       CGLIB$toString$ 2$Method = amethod[ 1]; 
       CGLIB$toString$ 2$Proxy = MethodProxy.create(class2, class1, "()Ljava/lang/String;", "toString", "CGLIB$toString$2"); 
       CGLIB$hashCode$ 3$Method = amethod[ 2]; 
       CGLIB$hashCode$ 3$Proxy = MethodProxy.create(class2, class1, "()I", "hashCode", "CGLIB$hashCode$3"); 
       CGLIB$clone$ 4$Method = amethod[ 3]; 
       CGLIB$clone$ 4$Proxy = MethodProxy.create(class2, class1, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4"); 
       amethod1 = ReflectUtils.findMethods( new String[] { 
       "sayHello", "()V" 
       }, (class2 = Class.forName( "com.lanhuigu.spring.proxy.cglib.HelloService")).getDeclaredMethods()); 
       Method[] 1 = amethod1; 
       CGLIB$sayHello$ 0$Method = amethod1[ 0]; 
       CGLIB$sayHello$ 0$Proxy = MethodProxy.create(class2, class1, "()V", "sayHello", "CGLIB$sayHello$0"); 
       } 
       
       final void CGLIB$sayHello$ 0() 
       { 
       super.sayHello(); 
       } 
       
       public final void sayHello() 
       { 
       MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; 
       if( this.CGLIB$CALLBACK_0 == null) { 
       CGLIB$BIND_CALLBACKS( this); 
       var10000 = this.CGLIB$CALLBACK_0; 
       } 
       
       if(var10000 != null) { 
       // 调用拦截器 
       var10000.intercept( this, CGLIB$setPerson$ 0$Method, CGLIB$emptyArgs, CGLIB$setPerson$ 0$Proxy); 
       } else { 
       super.sayHello(); 
       } 
       } 
       ...... 
       ...... 
       }

从代理对象反编译源码可以知道，代理对象继承于HelloService，拦截器调用intercept()方法，

intercept()方法由自定义MyMethodInterceptor实现，所以，最后调用MyMethodInterceptor中

的intercept()方法，从而完成了由代理对象访问到目标对象的动态代理实现。

[JDK动态代理实现原理(jdk8)][JDK_jdk8]

[https_github.com_yihonglei_Spring-Study]: https://github.com/yihonglei/Spring-Study
[20180609155146518]: https://img-blog.csdn.net/20180609155146518
[20180609171446315]: https://img-blog.csdn.net/20180609171446315
[JDK_jdk8]: https://blog.csdn.net/yhl_jxy/article/details/80586785