` À´´´½¨´úÀí¶ÔÏóÁË¡£
+
+### 2\. ´´½¨´úÀí¶ÔÏó
+
+ÎÒÃÇÀ´¿´¿´ spring ´´½¨´úÀí¶ÔÏóµÄÁ÷³Ì¡£
+
+> `AbstractAutoProxyCreator#wrapIfNecessary`£º
+
+```
+protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
+ ...
+ if (specificInterceptors != DO_NOT_PROXY) {
+ this.advisedBeans.put(cacheKey, Boolean.TRUE);
+ // ´úÀí¶ÔÏó¾ÍÊÇÔÚÕâÀï´´½¨µÄ
+ // - specificInterceptors£º¿ÉÒÔÓ¦Óõ½¸Ã¶ÔÏóµÄ Advisor£¬
+ // specificInterceptorsµÄ»ñÈ¡¹ý³Ì£¬ÉÏÒ»²¿·ÖÒѾÏêϸ·ÖÎö¹ýÁË£¬²»ÔÙ׸ÊöÁË
+ // - SingletonTargetSource£º¶ÔÔʼ¶ÔÏóµÄÒ»¸ö°ü×°
+ Object proxy = createProxy(
+ bean.getClass(), beanName, specificInterceptors,
+ new SingletonTargetSource(bean));
+ this.proxyTypes.put(cacheKey, proxy.getClass());
+ return proxy;
+ }
+ this.advisedBeans.put(cacheKey, Boolean.FALSE);
+ return bean;
+}
+
+```
+
+ÎÒÃÇÏÈÀ´¿´¿´ `SingletonTargetSource`£º
+
+```
+public class SingletonTargetSource implements TargetSource, Serializable {
+
+ private static final long serialVersionUID = 9031246629662423738L;
+
+ private final Object target;
+
+ public SingletonTargetSource(Object target) {
+ Assert.notNull(target, "Target object must not be null");
+ this.target = target;
+ }
+
+ @Override
+ public Class> getTargetClass() {
+ return this.target.getClass();
+ }
+
+ @Override
+ public Object getTarget() {
+ return this.target;
+ }
+
+ ...
+}
+
+```
+
+Õâ¸öÀà´úÂëºÜ¼òµ¥£¬¾ÍÊǶÔÔʼ¶ÔÏó×öÁËÒ»²ã°ü×°¡£¼ÌÐøÍùÏ¿´£º
+
+> AbstractAutoProxyCreator#createProxy
+
+```
+protected Object createProxy(Class> beanClass, @Nullable String beanName,
+ @Nullable Object[] specificInterceptors, TargetSource targetSource) {
+
+ if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
+ AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory)
+ this.beanFactory, beanName, beanClass);
+ }
+
+ ProxyFactory proxyFactory = new ProxyFactory();
+ //ʹÓÃproxyFactory¶ÔÏócopyµ±Ç°ÀàÖеÄÏà¹ØÊôÐÔ
+ proxyFactory.copyFrom(this);
+
+ // ÅжÏÊÇ·ñʹÓÃCglib¶¯Ì¬´úÀí£¬¿ÉÒÔÔÚ×¢½âÖÐÖ¸¶¨£º
+ // @EnableAspectJAutoProxy(proxyTargetClass = true)
+ if (!proxyFactory.isProxyTargetClass()) {
+ // Èç¹û beanFactory ÊÇ ConfigurableListableBeanFactory£¬
+ // Ôò¿ÉÔÚ BeanDefinition ÉèÖÃÊôÐÔ£¬µ¥¶À¿ØÖÆÄ³Ò»¸öÀàʹÓà cglib ´úÀí
+ if (shouldProxyTargetClass(beanClass, beanName)) {
+ proxyFactory.setProxyTargetClass(true);
+ }
+ else {
+ // Èç¹ûûÓÐÅäÖÿªÆô, ÔòÅжÏbeanÊÇ·ñÓкÏÊʵĽӿÚʹÓÃJDKµÄ¶¯Ì¬´úÀí
+ // ×¢Ò⣺JDK¶¯Ì¬´úÀí±ØÐëÊÇ´øÓнӿڵÄÀà
+ // Èç¹ûÀàûÓÐʵÏÖÈκνӿÚÔòÖ»ÄÜʹÓÃCglib¶¯Ì¬´úÀí£©
+ evaluateProxyInterfaces(beanClass, proxyFactory);
+ }
+ }
+
+ // ¹¹½¨Advisor£¬ÕâÀï°üº¬Á½¸ö²Ù×÷£º
+ // 1\. Ìí¼Ó¹«¹²µÄ Interceptor
+ // 2\. ¶ÔÓÚ¸ø¶¨µÄadvisor£¬ÅÐ¶ÏÆäÀàÐÍ£¬È»ºóת»»ÎªÆä¾ßÌåÀàÐÍ
+ Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
+ //Ìí¼ÓËùÓÐÔöÇ¿
+ proxyFactory.addAdvisors(advisors);
+ //ÉèÖÃÒª´úÀíµÄÀà
+ proxyFactory.setTargetSource(targetSource);
+ //SpringµÄÒ»¸öÀ©Õ¹µã£¬Ä¬ÈÏʵÏÖΪ¿Õ¡£Áô¸øÎÒÃÇÔÚÐèÒª¶Ô´úÀí½øÐÐÌØÊâ²Ù×÷µÄʱºòʵÏÖ
+ customizeProxyFactory(proxyFactory);
+
+ proxyFactory.setFrozen(this.freezeProxy);
+ if (advisorsPreFiltered()) {
+ proxyFactory.setPreFiltered(true);
+ }
+ //ʹÓôúÀí¹¤³§»ñÈ¡´úÀí¶ÔÏó
+ return proxyFactory.getProxy(getProxyClassLoader());
+}
+
+```
+
+ÔÚ `@EnableAspectJAutoProxy` ×¢½âÖУ¬¿ÉÒÔʹÓà `proxyTargetClass = true` À´ÉèÖÃÏîĿʹÓà `cglib` ´úÀí£¬ÕâÔÚ´úÂëÖÐÒ²ÓÐÌåÏÖ£º
+
+```
+// Ö»ÓÐÔÚproxyFactory.isProxyTargetClass()Ϊfalseʱ£¬²Å»á½øÐÐÏÂÃæµÄÅжÏ
+// »»ÑÔÖ®£¬µ± @EnableAspectJAutoProxy(proxyTargetClass = true) ʱ
+// ÏÂÃæµÄ´úÂëÊDz»»áÔËÐеģ¬Ä¬ÈÏʹÓþÍÊÇcglib´úÀí
+if (!proxyFactory.isProxyTargetClass()) {
+ // ÅжÏÓÐûÔÚ BeanDefinition ÖÐÉèÖÃʹÓà cglib´úÀí
+ if (shouldProxyTargetClass(beanClass, beanName)) {
+ proxyFactory.setProxyTargetClass(true);
+ }
+ else {
+ // ÊÇ·ñÂú×ã´úÀí½Ó¿ÚµÄÌõ¼þ£¬¼´ÊÇ·ñÂú×ãjdk¶¯Ì¬´úÀíµÄÌõ¼þ
+ evaluateProxyInterfaces(beanClass, proxyFactory);
+ }
+}
+
+```
+
+spring ÊÇÈçºÎÅжÏÒ»¸öÀàÊÇ·ñÂú×ã jdk ¶¯Ì¬´úÀíµÄÌõ¼þµÄÄØ£¿´ÓÎÒÃÇÀ´ÈÏÖªÉÏÀ´Ëµ£¬ÊµÏÖÁ˽ӿڣ¬¾Í¿ÉÒÔʹÓö¯Ì¬´úÀí£¬·ñÔò¾ÍÖ»ÄÜʹÓà cglib ´úÀí£¬ÎÒÃÇÀ´¿´¿´ spring ÊÇÈçºÎÅжϵģº
+
+> ProxyProcessorSupport#evaluateProxyInterfaces
+
+```
+/**
+ * ÅжÏÊÇ·ñÄÜʹÓÃjdk¶¯Ì¬´úÀí
+ */
+protected void evaluateProxyInterfaces(Class> beanClass, ProxyFactory proxyFactory) {
+ // »ñÈ¡ÀàµÄËùÓнӿÚ
+ Class>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
+ boolean hasReasonableProxyInterface = false;
+ for (Class> ifc : targetInterfaces) {
+ // 1.isConfigurationCallbackInterface: ÅжÏifcÊÇ·ñΪInitializingBean£¬DisposableBean£¬
+ // Closeable£¬AutoCloseable£¬ÒÔ¼°°üº¬ Aware
+ // 2.isInternalLanguageInterface: ÊÇ·ñΪÄÚ²¿ÓïÑÔ½Ó¿Ú£¬Èçgroovy£¬mockµÈ
+ // 3.ifc.getMethods().length > 0£º½Ó¿ÚµÄ·½·¨Êý±ØÐë´óÓÚ1
+ if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
+ ifc.getMethods().length > 0) {
+ hasReasonableProxyInterface = true;
+ break;
+ }
+ }
+ if (hasReasonableProxyInterface) {
+ // ÐèÒª½«ËùÓеĽӿڶ¼ÉèÖõ½proxyFactory
+ // ÊÔÏëһϣ¬Èç¹ûÒ»¸öÀàA ʵÏÖÁË½Ó¿Ú I1 Óë I2£¬
+ // Èç¹ûÀàAµÄ¶ÔÏóa Íйܵ½ÁËspringÈÝÆ÷£¬ÄÇôÎÞÂÛÊÇʹÓà beanFactory.get(I1.class)£¬
+ // »¹ÊÇ beanFactory.get(I1.class)£¬¶¼Ó¦¸ÃÄÜ»ñÈ¡µ½a.
+ for (Class> ifc : targetInterfaces) {
+ proxyFactory.addInterface(ifc);
+ }
+ }
+ else {
+ proxyFactory.setProxyTargetClass(true);
+ }
+}
+
+```
+
+´ÓÔ´ÂëÉÏÀ´¿´£¬spring ÅжÏÊÇ·ñÄÜʹÓà jdk ¶¯Ì¬´úÀíµÄ¹ý³ÌÓëÎÒÃÇÈÏÖªÉϵIJ¶à£¬²»¹ý²¢²»ÊÇʵÏÖÁËÈÎÒâ½Ó¿Ú¾ÍÄÜʹÓà jdk ¶¯Ì¬´úÀí£¬spring »áÅųý `InitializingBean`£¬`DisposableBean`£¬`Closeable`£¬`AutoCloseable` µÈ½Ó¿Ú£¬Í¬Ê±Ò²»áÅųýÎÞÈκη½·¨µÄ½Ó¿Ú¡£
+
+·ÖÎöÍê spring ÈçºÎÅжÏÊÇ·ñʹÓà jdk ¶¯Ì¬´úÀíºó£¬½Ó¿ÚÎÒÃÇÀ´¿´¿´ spring ÊÇÈçºÎ´´½¨´úÀí¶ÔÏóµÄ¡£ÎªÁË˵Ã÷ÎÊÌ⣬Ê×Ïȼò»¯Ï `AbstractAutoProxyCreator#createProxy`£º
+
+```
+protected Object createProxy(Class> beanClass, @Nullable String beanName,
+ @Nullable Object[] specificInterceptors, TargetSource targetSource) {
+ // Ê¡ÂÔһЩ´úÂë
+ ...
+ ProxyFactory proxyFactory = new ProxyFactory();
+ //ʹÓÃproxyFactory¶ÔÏócopyµ±Ç°ÀàÖеÄÏà¹ØÊôÐÔ
+ proxyFactory.copyFrom(this);
+ // ÕâÀïÊ¡ÂÔÁ˺öàµÄÅжÏ
+ proxyFactory.setProxyTargetClass(true);
+ //Ìí¼ÓËùÓÐÔöÇ¿
+ proxyFactory.addAdvisors(advisors);
+ //ÉèÖÃÒª´úÀíµÄÀà
+ proxyFactory.setTargetSource(targetSource);
+ ...
+ //ʹÓôúÀí¹¤³§»ñÈ¡´úÀí¶ÔÏó
+ return proxyFactory.getProxy(getProxyClassLoader());
+}
+
+```
+
+´ÓÕâÀï¿ÉÒÔ¿´³ö£¬Õâ¸ö·½·¨´´½¨ÁËÒ»¸ö `ProxyFactory` ¶ÔÏó£¬È»ºóÍù¸Ã¶ÔÏóµÄÊôÐÔÀïÉèÖÃÁËһЩֵ¡£¼ÌÐøÍùÏ¿´£º
+
+> ProxyFactory#getProxy(java.lang.ClassLoader)
+
+```
+public Object getProxy(@Nullable ClassLoader classLoader) {
+ return createAopProxy().getProxy(classLoader);
+}
+
+```
+
+ÕâÀïÓÐÁ½¸ö·½·¨£º`createAopProxy()` Óë `getProxy(classLoader)`£¬ÎÒÃÇÏÈÀ´¿´ `createAopProxy()`¡£
+
+> ProxyCreatorSupport#createAopProxy
+
+```
+protected final synchronized AopProxy createAopProxy() {
+ if (!this.active) {
+ activate();
+ }
+ return getAopProxyFactory().createAopProxy(this);
+}
+
+```
+
+¼ÌÐø£¬
+
+> DefaultAopProxyFactory#createAopProxy
+
+```
+/**
+ * ÅжϴúÀíÀàÐÍ
+ * Èç¹ûÄÜʹÓÃjdk¶¯Ì¬´úÀí£¬¾Í·µ»Ø JdkDynamicAopProxy
+ * ·ñÔò¾Í·µ»Ø ObjenesisCglibAopProxy
+ */
+public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
+ if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
+ Class> targetClass = config.getTargetClass();
+ if (targetClass == null) {
+ throw new AopConfigException(...);
+ }
+ if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
+ return new JdkDynamicAopProxy(config);
+ }
+ return new ObjenesisCglibAopProxy(config);
+ }
+ else {
+ return new JdkDynamicAopProxy(config);
+ }
+}
+
+```
+
+µ½ÕâÀÎÒÃǾÍÄÜÃ÷°×£¬`JdkDynamicAopProxy` ÊÇÓÃÀ´´¦Àí jdk ¶¯Ì¬´úÀíµÄ£¬`ObjenesisCglibAopProxy` ÊÇÓÃÀ´´¦Àí cglib ´úÀíµÄ¡£½ÓÏÂÀ´£¬ÎÒÃÇÀ´¿´¿´ `getProxy(classLoader)` ·½·¨¡£
+
+> JdkDynamicAopProxy#getProxy(java.lang.ClassLoader)
+
+```
+@Override
+public Object getProxy(@Nullable ClassLoader classLoader) {
+ Class>[] proxiedInterfaces = AopProxyUtils
+ .completeProxiedInterfaces(this.advised, true);
+ // ÊÇ·ñÓÐequals()ÓëhashCode()·½·¨
+ findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
+ // µ÷Óà jdk ·½·¨ ´´½¨¶ÔÏó
+ return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
+}
+
+```
+
+×îºóÎÒÃÇÀ´¿´¿´µÃµ½µÄ´úÀí¶ÔÏóÊÇʲôÑùµÄ£º
+
+
+
+¿ÉÒÔ¿´µ½£¬´úÀí¶ÔÏóµÄ `h` ÊôÐÔ±£´æµÄ¾ÍÊÇ `JdkDynamicAopProxy` ¶ÔÏó£¬`JdkDynamicAopProxy` ¶ÔÏóµÄ `advised` ÊôÐÔ±£´æÁË´úÀíµÄ´úÀíµÄÏà¹ØÐÅÏ¢¡£
+
+> CglibAopProxy#getProxy(java.lang.ClassLoader)
+
+```
+public Object getProxy(@Nullable ClassLoader classLoader) {
+ try {
+ Class> rootClass = this.advised.getTargetClass();
+ Assert.state(rootClass != null, "xxx");
+
+ Class> proxySuperClass = rootClass;
+ if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
+ proxySuperClass = rootClass.getSuperclass();
+ Class>[] additionalInterfaces = rootClass.getInterfaces();
+ for (Class> additionalInterface : additionalInterfaces) {
+ this.advised.addInterface(additionalInterface);
+ }
+ }
+
+ validateClassIfNecessary(proxySuperClass, classLoader);
+
+ // ´´½¨ Enhancer ¶ÔÏ󣬲¢setһЩÊôÐÔ
+ Enhancer enhancer = createEnhancer();
+ if (classLoader != null) {
+ enhancer.setClassLoader(classLoader);
+ if (classLoader instanceof SmartClassLoader &&
+ ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
+ enhancer.setUseCache(false);
+ }
+ }
+ // Superclass¾ÍÊÇÒª´úÀíµÄÀà
+ enhancer.setSuperclass(proxySuperClass);
+ // ÉèÖýӿڣ¬Èç SpringProxy£¬Advised
+ enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
+ enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
+ enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
+
+ Callback[] callbacks = getCallbacks(rootClass);
+ Class>[] types = new Class>[callbacks.length];
+ for (int x = 0; x < types.length; x++) {
+ types[x] = callbacks[x].getClass();
+ }
+ enhancer.setCallbackFilter(new ProxyCallbackFilter(
+ this.advised.getConfigurationOnlyCopy(),
+ this.fixedInterceptorMap, this.fixedInterceptorOffset));
+ enhancer.setCallbackTypes(types);
+
+ return createProxyClassAndInstance(enhancer, callbacks);
+ }
+ catch (CodeGenerationException | IllegalArgumentException ex) {
+ throw new AopConfigException(...);
+ }
+ catch (Throwable ex) {
+ throw new AopConfigException("Unexpected AOP exception", ex);
+ }
+}
+
+```
+
+spring ʹÓà cglib ´´½¨¶ÔÏó£¬Ö÷ÒªÓõ½ÁË `Enhancer` À࣬¹ØÓÚÕâÒ»¿éºóÃæ»áÔÙ·ÖÎö¡£
+
+×îºóÎÒÃÇÒ²À´¿´¿´´´½¨ºóµÃµ½µÄ¶ÔÏó£º
+
+
+
+### 3\. ×ܽá
+
+±¾ÎÄÖ÷Òª·ÖÎöÁË `AbstractAutoProxyCreator#postProcessAfterInitialization`£¬¸Ã·½·¨Ö÷Òª×öÁËÈý¼þÊ£º
+
+1. »ñÈ¡ÏîÄ¿ÖÐËùÓÐÇÐÃæÀ࣬½«Çе㷽·¨°üװΪ `List`£ºÊµ¼ÊÉÏ£¬ÕâÒ»²½µÄ²Ù×÷Ò²»áÔÚ `AbstractAutoProxyCreator#postProcessBeforeInitialization` ÖÐÖ´ÐУ¬È»ºó½«½á¹û»º´æÁËÆðÀ´£¬ÕâÒ»²½ÆäʵÊÇÖ±½ÓÔÚ»º´æÖÐÄýá¹û£»
+2. »ñÈ¡µ±Ç°¶ÔÏóµÄËùÓÐÔöÇ¿£ºÕâÒ»²½¾ÍÊÇÅжÏÄÄЩÔöÇ¿¿ÉÒÔÓÃÓÚµ±Ç°¶ÔÏó£¬ÅжÏʱÏÈ»ñÈ¡µ±Ç°ÀàµÄËùÓнӿÚÓë²»°üÀ¨ Object µÄ¸¸À࣬ȻºóÖðÒ»ÅжÏÕâЩ½Ó¿ÚÓëÀàÖеķ½·¨ÊÇ·ñÂú×ãÔöÇ¿Ìõ¼þ£¬Ö»ÒªÓÐÒ»¸ö·½·¨Âú×㣬¾Í±íʾµ±Ç°¶ÔÏóÐèÒª±»´úÀí£»
+3. ´´½¨´úÀí¶ÔÏ󣺴´½¨´úÀí¶ÔÏóʱ£¬Ä¬ÈÏÇé¿öÏ£¬»á¸ù¾ÝÊÇ·ñʵÏÖÁ˽ӿÚÀ´Ñ¡ÔñʹÓà jdk ¶¯Ì¬´úÀí»¹ÊÇ cglib£¬¿ÉÓ¦ÓÃÓÚµ±Ç° bean µÄ `List` Ò²»á·â×°½ø´úÀí¶ÔÏóÖС£
+
+* * *
+
+_±¾ÎÄÔÎÄÁ´½Ó£º[https://my.oschina.net/funcy/blog/4687961](https://my.oschina.net/funcy/blog/4687961) £¬ÏÞÓÚ×÷Õ߸öÈËˮƽ£¬ÎÄÖÐÄÑÃâÓдíÎóÖ®´¦£¬»¶ÓÖ¸Õý£¡Ô´´²»Ò×£¬ÉÌÒµ×ªÔØÇëÁªÏµ×÷Õß»ñµÃÊÚȨ£¬·ÇÉÌÒµ×ªÔØÇë×¢Ã÷³ö´¦¡£_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/spring aop\357\274\210\344\272\224\357\274\211\357\274\232cglib \344\273\243\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/spring aop\357\274\210\344\272\224\357\274\211\357\274\232cglib \344\273\243\347\220\206.md"
new file mode 100644
index 0000000..412483a
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/spring aop\357\274\210\344\272\224\357\274\211\357\274\232cglib \344\273\243\347\220\206.md"
@@ -0,0 +1,449 @@
+
+
+[ÉÏһƪÎÄÕÂ](https://my.oschina.net/funcy/blog/4696654 "ÉÏһƪÎÄÕÂ")½éÉÜÁË spring µÄ jdK ¶¯Ì¬´úÀí£¬±¾ÎÄÀ´½éÉÜ spring µÄ cglib ´úÀí¡£
+
+### 1\. cglib ´úÀí¼ò½é
+
+jdk ËäÈ»ÌṩÁ˶¯Ì¬´úÀí£¬µ«ÊǶ¯Ì¬´úÀíÓÐÒ»¸ö²»×㣺**Èç¹ûÀàûÓÐʵÏÖ½Ó¿Ú£¬¾ÍÎÞ·¨ jdk ¶¯Ì¬´úÀí**¡£ÎªÁ˽â¾öÕâ¸ö²»×㣬spring ÓÖÒýÈëÁË cglib ´úÀí¡£
+
+cglib µ×²ãÊÇ»ùÓÚ asm µÄ£¬Ò²¾ÍÊÇÖ±½Ó²Ù×÷×Ö½ÚÂ룬Ï൱ÓÚ¶Ô asm ½øÐÐÁËÒ»²ã·â×°¡£Ö±½Ó²Ù×÷×ÖÂ룬ÐèÒª¶Ô java Ö¸Áî¡¢×Ö½ÚÂëÎļþÓÐÉîÈëÀí½â²ÅÄܽøÐУ¬µ«×Ö½ÚÂë»ÞɬÄѶ®£¬Ò»°ã²»½¨ÒéÖ±½Ó²Ù×÷¡£¾ cglib ·â×°ºó£¬×Ö½ÚÂëµÄ²Ù×÷¾Í±äµÃ¼òµ¥¶àÁË£¬Òò´Ë**¾ø´ó¶àÊýÇé¿ö϶¼½¨ÒéʹÓà cglib ·â×°ºÃµÄ·½·¨À´½øÐÐ×Ö½ÚÂë²Ù×÷**¡£
+
+spring cglib ²Ù×÷λÓÚ `spring-core` Ä£¿é£º
+
+
+
+ÔÙÀ´¿´¿´ asm Óë cglib °ü˵Ã÷£º
+
+```
+/**
+ * Spring's repackaging of
+ * ASM 7.0
+ * (with Spring-specific patches; for internal use only).
+ *
+ * This repackaging technique avoids any potential conflicts with
+ * dependencies on ASM at the application level or from third-party
+ * libraries and frameworks.
+ *
+ *
As this repackaging happens at the class file level, sources
+ * and javadocs are not available here.
+ */
+ package org.springframework.asm;
+
+```
+
+×¢ÒâµÚÒ»¾ä£º`Spring's repackaging of ASM 7.0`£¬±íÃ÷ÕâÊÇ spring ¶Ô `asm7.0` ÖØÐ´ò°ü.
+
+```
+/**
+ * Spring's repackaging of
+ * CGLIB 3.3
+ * (with Spring-specific patches; for internal use only).
+ *
+ *
This repackaging technique avoids any potential conflicts with
+ * dependencies on CGLIB at the application level or from third-party
+ * libraries and frameworks.
+ *
+ *
As this repackaging happens at the class file level, sources
+ * and javadocs are not available here.
+ */
+package org.springframework.cglib;
+
+```
+
+×¢ÒâµÚÒ»¾ä£º`Spring's repackaging of CGLIB 3.3`£¬±íÃ÷ÕâÊÇ spring ¶Ô `CGLIB 3.3` ÖØÐ´ò°ü.
+
+ºÎÎ½ÖØÐ´ò°üÄØ£¿¸öÈËÀí½â£¬¾ÍÊǽ« `asm7.0` Óë `CGLIB 3.3` µÄÔ´Âë¸Ä¸ö°üÃû£¬¸´ÖƵ½ spring ÏîĿϡ£Òò´Ë spring ²¢Ã»ÓÐÔÚ `gradle` ÎļþÖÐÒýÈë `asm` Óë `cglib` µÄÏ൱ jar °ü£¬¶øÊÇÔÚÏîÄ¿ÖÐÖ±½ÓÒýÈëÁËÕâÁ½¸öÏîÄ¿µÄÔ´Â룡
+
+### 2\. cglib ´úÀíʾÀý
+
+ÔÚÕýʽ¿ªÊ¼Ö®Ç°£¬ÎÒÃÇÏÈÀ´¿´ ¿´ cglib ´úÀíÊÇÈçºÎ½øÐеġ£
+
+Ê×ÏÈ×¼±¸Ò»¸öÀࣺ
+
+```
+package org.springframework.learn.demo04;
+
+public class CglibProxyService {
+ public void hello01() {
+ System.out.println("hello01");
+ }
+}
+
+```
+
+ÔÙ×¼±¸Ò»¸ö `MethodInterceptor`£¨Àà±È jdk ¶¯Ì¬´úÀíÖÐµÄ `InvocationHandler`£©£º
+
+```
+package org.springframework.learn.demo04;
+
+import org.springframework.cglib.proxy.MethodInterceptor;
+import org.springframework.cglib.proxy.MethodProxy;
+
+import java.lang.reflect.Method;
+
+public class MyMethodInterceptor implements MethodInterceptor {
+
+ /** Ä¿±ê¶ÔÏó */
+ private Object target;
+
+ public MyMethodInterceptor(Object target){
+ this.target = target;
+ }
+
+ @Override
+ public Object intercept(Object proxyObj, Method method, Object[] objects,
+ MethodProxy proxy) throws Throwable {
+ System.out.println("Ö´Ðз½·¨Îª:" + method.getName());
+ return proxy.invoke(target, objects);
+ }
+}
+
+```
+
+×îºóÊÇÖ÷Àࣺ
+
+```
+package org.springframework.learn.demo04;
+
+import org.springframework.cglib.proxy.Enhancer;
+
+/**
+ * £ûÕâÀïÌí¼ÓÃèÊö£ý
+ *
+ * @author fangchengyan
+ * @date 2020-11-01 9:23 ÏÂÎç
+ */
+public class Demo04Main {
+
+ public static void main(String[] args) {
+ CglibProxyService target = new CglibProxyService();
+ MyMethodInterceptor interceptor = new MyMethodInterceptor(target);
+
+ Enhancer enhancer = new Enhancer();
+ // ÉèÖø¸Àà
+ enhancer.setSuperclass(CglibProxyService.class);
+ // ÉèÖÃcallback£¬Õâ¸öcallback¾ÍÊÇÉÏÃæÌṩµÄ MyMethodInterceptor
+ enhancer.setCallback(interceptor);
+ // ʹÓà enhancer ´´½¨´úÀí¶ÔÏó
+ CglibProxyService proxy = (CglibProxyService)enhancer.create();
+ proxy.hello01();
+ }
+}
+
+```
+
+ÔËÐУ¬½á¹ûÈçÏ£º
+
+```
+Ö´Ðз½·¨Îª:hello01
+hello01
+
+```
+
+¿ÉÒÔ¿´µ½£¬×îÖÕÊÇÔÚ `MyMethodInterceptor#intercept` Ö´ÐÐÄ¿±ê¶ÔÏóµÄ·½·¨¡£
+
+ͬ jdk ¶¯Ì¬´úÀí±È½Ïºó£¬·¢ÏÖÁ½Õß´úÂë¸ß¶ÈÏàËÆ£º
+
+* `InvocationHandler` Óë `InvocationHandler`£ºÁ½Õß´úÂëÐÎʽ¼¸ºõÒ»Ö 
+
+* ´úÀí¶ÔÏóµÄ´´½¨£ºÒ»¸öÊÇʹÓà `Enhangcer` ½øÐдúÀí¶ÔÏó´´½¨£¬Ò»¸öÊÇʹÓ÷â×°ºÃµÄ·½·¨½øÐжÔÏó´´½¨¡£ 
+
+´Ó´úÀí¶ÔÏó´´½¨À´¿´£¬¿ÉÒÔ¿´³ö `cglib` Éú³É¶ÔÏóʱ£¬ÅäÖõIJÎÊý½Ï¶à£¬¹¦ÄܽϷḻ¡£
+
+¹ØÓÚ `Enhangcer` ÊÇÈçºÎ´´½¨´úÀí¶ÔÏó£¬ÒÔ¼° `org.springframework.asm` Óë `org.springframework.cglib` ÕâÁ½¸ö°üϵĴúÂ룬ÕâЩÊôÓÚ cglib µÄÄÚÈÝ£¬¾Í²»¹ý¶à·ÖÎöÁË¡£
+
+### 3\. spring ÖÐ `cglib` ´´½¨´úÀí¶ÔÏó
+
+ÎÒÃÇÔÙÀ´¿´¿´ spring ÊÇÈçºÎ´´½¨´úÀí¶ÔÏóµÄ£º
+
+> CglibAopProxy#getProxy(java.lang.ClassLoader)
+
+```
+public Object getProxy(@Nullable ClassLoader classLoader) {
+ try {
+ Class> rootClass = this.advised.getTargetClass();
+ Assert.state(rootClass != null, "...");
+
+ Class> proxySuperClass = rootClass;
+ if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
+ proxySuperClass = rootClass.getSuperclass();
+ Class>[] additionalInterfaces = rootClass.getInterfaces();
+ for (Class> additionalInterface : additionalInterfaces) {
+ this.advised.addInterface(additionalInterface);
+ }
+ }
+
+ // ¶ÔÄ¿±êÀà½øÐмì²é£¬Ö÷Òª¼ì²éµãÓÐÈý¸ö£º
+ // 1\. Ä¿±ê·½·¨²»ÄÜʹÓÃfinalÐÞÊΣ»
+ // 2\. Ä¿±ê·½·¨²»ÄÜÊÇprivateÀàÐ͵ģ»
+ // 3\. Ä¿±ê·½·¨²»ÄÜÊǰü·ÃÎÊȨÏ޵ģ»
+ // ÕâÈý¸öµãÂú×ãÈκÎÒ»¸ö£¬µ±Ç°·½·¨¾Í²»Äܱ»´úÀí£¬´Ëʱ¸Ã·½·¨¾Í»á±»ÂÔ¹ý
+ validateClassIfNecessary(proxySuperClass, classLoader);
+
+ Enhancer enhancer = createEnhancer();
+ if (classLoader != null) {
+ enhancer.setClassLoader(classLoader);
+ if (classLoader instanceof SmartClassLoader &&
+ ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
+ enhancer.setUseCache(false);
+ }
+ }
+ // Superclass¾ÍÊÇÒª´úÀíµÄÀà
+ enhancer.setSuperclass(proxySuperClass);
+ // ÕâÀïAopProxyUtils.completeProxiedInterfaces()·½·¨µÄÖ÷ҪĿµÄÊÇΪҪÉú³ÉµÄ´úÀíÀà
+ // Ôö¼ÓSpringProxy£¬Advised£¬DecoratingProxyÈý¸öÐèҪʵÏֵĽӿڡ£ÕâÀïÈý¸ö½Ó¿ÚµÄ×÷ÓÃÈçÏ£º
+ // 1\. SpringProxy£ºÊÇÒ»¸ö¿Õ½Ó¿Ú£¬ÓÃÓÚ±ê¼Çµ±Ç°Éú³ÉµÄ´úÀíÀàÊÇSpringÉú³ÉµÄ´úÀíÀࣻ
+ // 2\. Advised£ºSpringÉú³É´úÀíÀàËùʹÓõÄÊôÐÔ¶¼±£´æÔڸýӿÚÖУ¬
+ // °üÀ¨Advisor£¬AdviceºÍÆäËûÏà¹ØÊôÐÔ£»
+ // 3\. DecoratingProxy£º¸Ã½Ó¿ÚÓÃÓÚ»ñÈ¡µ±Ç°´úÀí¶ÔÏóËù´úÀíµÄÄ¿±ê¶ÔÏóµÄClassÀàÐÍ¡£
+ enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
+ enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
+ enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
+
+ // Ìí¼Ócallback
+ Callback[] callbacks = getCallbacks(rootClass);
+ Class>[] types = new Class>[callbacks.length];
+ for (int x = 0; x < types.length; x++) {
+ types[x] = callbacks[x].getClass();
+ }
+ // ÉèÖôúÀíÀàÖи÷¸ö·½·¨½«ÒªÊ¹ÓõÄÇÐÃæÂß¼£¬ÕâÀïProxyCallbackFilter.accept()·½·¨·µ»Ø
+ // µÄÕûÐÍÖµÕýºÃÒ»Ò»¶ÔÓ¦ÉÏÃæCallbackÊý×éÖи÷¸öÇÐÃæÂß¼µÄϱ꣬Ҳ¾ÍÊÇ˵ÕâÀïµÄCallbackFilter
+ // µÄ×÷ÓÃÕýºÃÖ¸¶¨ÁË´úÀíÀàÖи÷¸ö·½·¨½«ÒªÊ¹ÓÃCallbackÊý×éÖеÄÄĸö»òÄöÇÐÃæÂß¼
+ enhancer.setCallbackFilter(new ProxyCallbackFilter( this.advised.getConfigurationOnlyCopy(),
+ this.fixedInterceptorMap, this.fixedInterceptorOffset));
+ enhancer.setCallbackTypes(types);
+
+ // Éú³É´úÀí¶ÔÏó
+ return createProxyClassAndInstance(enhancer, callbacks);
+ }
+ catch (...) {
+ ...
+ }
+}
+
+```
+
+ÒÔÉÏ´úÂëºËÐÄÊÇÉèÖà `Enhancer` µÄÊôÐÔ£¬Èç `classLoader`¡¢`superclass`¡¢`callbackFilter` µÈ£¬×îºóµ÷Óà `createProxyClassAndInstance(xxx)` ´´½¨´úÀí¶ÔÏó£º
+
+> ObjenesisCglibAopProxy#createProxyClassAndInstance
+
+```
+protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
+ // ´´½¨´úÀíÀà
+ Class> proxyClass = enhancer.createClass();
+ Object proxyInstance = null;
+
+ // ¸ù¾Ý´úÀíÀ࣬ʹÓ÷´ÉäÉú³É¶ÔÏó
+ if (objenesis.isWorthTrying()) {
+ try {
+ proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
+ }
+ catch (Throwable ex) {
+ ...
+ }
+ }
+
+ if (proxyInstance == null) {
+ try {
+ Constructor> ctor = (this.constructorArgs != null ?
+ proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
+ proxyClass.getDeclaredConstructor());
+ ReflectionUtils.makeAccessible(ctor);
+ proxyInstance = (this.constructorArgs != null ?
+ ctor.newInstance(this.constructorArgs) : ctor.newInstance());
+ }
+ catch (Throwable ex) {
+ throw new AopConfigException(...);
+ }
+ }
+ // ÉèÖÃcallbackÊôÐÔ
+ // µ±ÉèÖÃÁ˶à¸ö callback ʱ£¬»áͨ¹ý CallbackFilter À´È·¶¨×îÖÕʹÓÃÄĸö callback
+ ((Factory) proxyInstance).setCallbacks(callbacks);
+ return proxyInstance;
+}
+
+```
+
+ͨ¹ýÔÚµÚ¶þ²¿·ÖµÄ `demo04` ¿ÉÒÔÖªµÀ£¬cglib ·½·¨µÄÖ´ÐУ¬»á¾¹ý `MethodInterceptor#intercept` ·½·¨µ÷Óõģ¬Ò²¾ÍÊÇ `Enhancer` µÄ `callback` ÊôÐÔ£¬Òò´Ë½ÓÏÂÀ´ÎÒÃÇÀ´¿´¿´ `callback` µÄ»ñÈ¡£¬Ïà¹Ø´úÂëλÓÚ `CglibAopProxy#getCallbacks`£º
+
+> CglibAopProxy#getCallbacks
+
+```
+private Callback[] getCallbacks(Class> rootClass) throws Exception {
+ boolean exposeProxy = this.advised.isExposeProxy();
+ boolean isFrozen = this.advised.isFrozen();
+ boolean isStatic = this.advised.getTargetSource().isStatic();
+
+ // Óû§×Ô¶¨ÒåµÄ´úÀíÂß¼µÄcallback£¬¼´¿ª·¢ÖУ¬¶¨ÒåµÄ @Before¡¢@Around¡¢@AfterµÈÇÐÃæ·½·¨£¬
+ // ½«ÔÚDynamicAdvisedInterceptor½øÐе÷ÓÃ
+ Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
+
+ Callback targetInterceptor;
+ // ÅжÏÈç¹ûÒª±©Â¶´úÀí¶ÔÏó£¬Èç¹ûÊÇ£¬ÔòʹÓÃAopContextÉèÖý«´úÀí¶ÔÏóÉèÖõ½ThreadLocalÖÐ
+ // Óû§Ôò¿ÉÒÔͨ¹ýAopContext»ñȡĿ±ê¶ÔÏó
+ if (exposeProxy) {
+ // Åжϱ»´úÀíµÄ¶ÔÏóÊÇ·ñÊǾ²Ì¬µÄ£¬Èç¹ûÊǾ²Ì¬µÄ£¬Ôò½«Ä¿±ê¶ÔÏ󻺴æÆðÀ´£¬Ã¿´Î¶¼Ê¹ÓøöÔÏó¼´¿É£¬
+ // Èç¹ûÄ¿±ê¶ÔÏóÊǶ¯Ì¬µÄ£¬ÔòÔÚDynamicUnadvisedExposedInterceptorÖÐÿ´Î¶¼Éú³ÉÒ»¸öеÄ
+ // Ä¿±ê¶ÔÏó£¬ÒÔÖ¯ÈëºóÃæµÄ´úÀíÂß¼
+ targetInterceptor = (isStatic ?
+ new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
+ new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
+ }
+ else {
+ // ÕâÀïµÄÁ½¸öÀàÓëÉÏÃæÁ½¸öµÄÎ¨Ò»Çø±ð¾ÍÔÚÓÚÊÇ·ñʹÓÃAopContext±©Â¶Éú³ÉµÄ´úÀí¶ÔÏó
+ targetInterceptor = (isStatic ?
+ new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
+ new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
+ }
+
+ // µ±Ç°CallbackÓÃÓÚ²»Óñ»´úÀíµÄ·½·¨
+ Callback targetDispatcher = (isStatic ?
+ new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());
+
+ // ½«»ñÈ¡µ½µÄcallback×éװΪһ¸öÊý×é
+ Callback[] mainCallbacks = new Callback[] {
+ // Óû§×Ô¼º¶¨ÒåµÄÀ¹½ØÆ÷
+ aopInterceptor, // for normal advice
+ // ¸ù¾ÝÌõ¼þÊÇ·ñ±©Â¶´úÀí¶ÔÏóµÄÀ¹½ØÆ÷
+ targetInterceptor, // invoke target without considering advice, if optimized
+ // ²»×öÈκβÙ×÷µÄÀ¹½ØÆ÷
+ new SerializableNoOp(), // no override for methods mapped to this
+ // ÓÃÓÚ´æ´¢Advised¶ÔÏóµÄ·Ö·¢Æ÷
+ targetDispatcher, this.advisedDispatcher,
+ // Õë¶Ôequals·½·¨µ÷ÓõÄÀ¹½ØÆ÷
+ new EqualsInterceptor(this.advised),
+ // Õë¶Ôhashcode·½·¨µ÷ÓõÄÀ¹½ØÆ÷
+ new HashCodeInterceptor(this.advised)
+ };
+
+ Callback[] callbacks;
+
+ // Èç¹ûÄ¿±ê¶ÔÏóÊǾ²Ì¬µÄ£¬²¢ÇÒÇÐÃæÂß¼µÄµ÷ÓÃÁ´Êǹ̶¨µÄ£¬Ôò¶ÔÄ¿±ê¶ÔÏóºÍÕû¸öµ÷ÓÃÁ´½øÐлº´æ
+ if (isStatic && isFrozen) {
+ Method[] methods = rootClass.getMethods();
+ Callback[] fixedCallbacks = new Callback[methods.length];
+ this.fixedInterceptorMap = new HashMap<>(methods.length);
+
+ for (int x = 0; x < methods.length; x++) {
+ Method method = methods[x];
+ // »ñȡĿ±ê¶ÔÏóµÄÇÐÃæÂß¼
+ List