` ˡ
+
+### 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();
+ //ʹproxyFactorycopyǰе
+ proxyFactory.copyFrom(this);
+
+ // жǷʹCglib̬עָ
+ // @EnableAspectJAutoProxy(proxyTargetClass = true)
+ if (!proxyFactory.isProxyTargetClass()) {
+ // beanFactory ConfigurableListableBeanFactory
+ // BeanDefinition ԣijһʹ 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ǷΪInitializingBeanDisposableBean
+ // CloseableAutoCloseableԼ Aware
+ // 2.isInternalLanguageInterface: ǷΪڲԽӿڣgroovymock
+ // 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();
+ //ʹproxyFactorycopyǰе
+ 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);
+ // ýӿڣ SpringProxyAdvised
+ 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`ʵϣһIJҲ `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 װֽIJͱüˣ**¶ʹ 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);
+ // callbackcallbackṩ 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()ҪĿΪҪɵĴ
+ // SpringProxyAdvisedDecoratingProxyҪʵֵĽӿڡӿڵ£
+ // 1\. SpringProxyһսӿڣڱǵǰɵĴSpringɵĴࣻ
+ // 2\. AdvisedSpringɴʹõԶڸýӿУ
+ // AdvisorAdviceԣ
+ // 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