<bean id="testAdvisor" class="com.abc.TestAdvisor"/>
        <bean id="testAOP" class="org.springframework.aop.ProxyFactoryBean>
        <property name="proxyInterfaces"><value>com.test.AbcInterface"</value></property>
        <property name="target">
            <bean class="com.abc.TestTarget"/>
        </property>
        <property name="interceptorNames">
            <list><value> testAdvisor</value></list>
        </property>
        </bean>

        public Object getObject() throws BeansException {
            //這里初始化通知器鏈
            initializeAdvisorChain();
            //這里對singleton和prototype的類型進(jìn)行區(qū)分,生成對應(yīng)的proxy
            if (isSingleton()) {
                return getSingletonInstance();
            }
            else {
                if (this.targetName == null) {
                    logger.warn("Using non-singleton proxies with singleton targets is
                    often undesirable. " +"Enable prototype proxies by setting the
                    'targetName' property.");
                }
                return newPrototypeInstance();
            }
        }

        private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
            if (this.advisorChainInitialized) {
                return;
            }
            if (!ObjectUtils.isEmpty(this.interceptorNames)) {
                if (this.beanFactory == null) {
                    throw new IllegalStateException("No BeanFactory available anymore
                    (probably due to serialization) " +
                    "- cannot resolve interceptor names " + Arrays.asList
                    (this.interceptorNames));
                }
                    if (this.interceptorNames[this.interceptorNames.length -1].
                    endsWith(GLOBAL_SUFFIX) &&this.targetName == null &&
                    this.targetSource == EMPTY_TARGET_SOURCE) {
                    throw new AopConfigException("Target required after globals");
                }
                // 這里是添加Advisor鏈的調(diào)用，是通過interceptorNames屬性進(jìn)行配置的
                for (String name : this.interceptorNames) {
                    if (logger.isTraceEnabled()) {
                          logger.trace("Configuring advisor or advice '" + name + "'");
                    }
                    if (name.endsWith(GLOBAL_SUFFIX)) {
                          if (!(this.beanFactory instanceof ListableBeanFactory)) {
                              throw new AopConfigException(
                                      "Can only use global advisors or interceptors with a
                                      ListableBeanFactory");
                            }
                            addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
                                    name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
                    }
                    else {
                            /＊ 如果程序在這里被調(diào)用，那么需要加入命名的攔截器advice，并且需要檢查這
                              個(gè)Bean是singleton還是prototype類型＊/
                            Object advice;
                            //如果是singleton類型Bean
                            if (this.singleton || this.beanFactory.isSingleton(name)) {
                            //加入advice或者advisor
                                advice = this.beanFactory.getBean(name);
                            }
                            else {
                                //對prototype類型Bean的處理
                                advice = new PrototypePlaceholderAdvisor(name);
                            }
                            addAdvisorOnChainCreation(advice, name);
                    }
                }
            }
            this.advisorChainInitialized = true;
        }

        private synchronized Object getSingletonInstance() {
            if (this.singletonInstance == null) {
                this.targetSource = freshTargetSource();
                if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 &&
                !isProxyTargetClass()) {
                    //根據(jù)AOP框架來判斷需要代理的接口
                    Class targetClass = getTargetClass();
                    if (targetClass == null) {
                          throw new FactoryBeanNotInitializedException("Cannot determine
                          target class for proxy");
                    }
        // 這里設(shè)置代理對象的接口
        setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
                }
                super.setFrozen(this.freezeProxy);
                // 注意這里的方法會使用ProxyFactory來生成需要的Proxy
                this.singletonInstance = getProxy(createAopProxy());
            }
            return this.singletonInstance;
        }
        //通過createAopProxy返回的AopProxy來得到代理對象
        protected Object getProxy(AopProxy aopProxy) {
            return aopProxy.getProxy(this.proxyClassLoader);
        }

        protected final synchronized AopProxy createAopProxy() {
            if (!this.active) {
                activate();
            }
            //通過AopProxyFactory取得AopProxy，這個(gè)AopProxyFactory是在初始化函數(shù)中
            //定義的，使用的是DefaultAopProxyFactory
            return getAopProxyFactory().createAopProxy(this);
        }

        public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
            if (config.isOptimize() || config.isProxyTargetClass() ||hasNoUserSupplied-
                ProxyInterfaces(config)) {
                Class targetClass = config.getTargetClass();
                if (targetClass == null) {
                    throw new AopConfigException("TargetSource cannot determine target class: " +
                    "Either an interface or a target is required for proxy creation.");
                }//如果targetClass是接口類，使用JDK來生成Proxy
                if (targetClass.isInterface()) {
                    return new JdkDynamicAopProxy(config);
                }
                if (!cglibAvailable) {
                    throw new AopConfigException(
                            "Cannot proxy target class because CGLIB2 is not available. " +
                            "Add CGLIB to the class path or specify proxy interfaces.");
                } //如果不是接口類要生成Proxy，那么使用CGLIB來生成
                return CglibProxyFactory.createCglibProxy(config);
            }
            else {
                return new JdkDynamicAopProxy(config);
            }
        }

        public Object getProxy(ClassLoader classLoader) {
            if (logger.isDebugEnabled()) {
                logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.
                getTargetSource());
            }
            Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces
            (this.advised);
            findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
            //這是調(diào)用JDK生成Proxy的地方
            return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
        }

        public Object getProxy(ClassLoader classLoader) {
            if (logger.isDebugEnabled()) {
                logger.debug("Creating CGLIB2 proxy: target source is " + this.advised.
                getTargetSource());
            }
            //從advised中取得在IoC容器中配置的target對象
            try {
                Class rootClass = this.advised.getTargetClass();
                Assert.state(rootClass != null, "Target class must be available for creating a
                CGLIB proxy");
                Class proxySuperClass = rootClass;
                if (AopUtils.isCglibProxyClass(rootClass)) {
                    proxySuperClass = rootClass.getSuperclass();
                    Class[] additionalInterfaces = rootClass.getInterfaces();
                    for (Class additionalInterface : additionalInterfaces) {
                          this.advised.addInterface(additionalInterface);
                    }
                }
                //驗(yàn)證代理對象的接口設(shè)置
                // 創(chuàng)建并配置CGLIB的Enhancer，這個(gè)Enhancer對象是CGLIB的主要操作類
                Enhancer enhancer = createEnhancer();
                if (classLoader != null) {
                    enhancer.setClassLoader(classLoader);
                    if (classLoader instanceof SmartClassLoader &&
                           ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                          enhancer.setUseCache(false);
                    }
                }
                //設(shè)置Enhancer對象，包括設(shè)置代理接口，回調(diào)方法
                //來自advised的IoC配置，比如使用AOP的DynamicAdvisedInterceptor攔截器
                enhancer.setSuperclass(proxySuperClass);
                enhancer.setStrategy(new UndeclaredThrowableStrategy
                (UndeclaredThrowableException.class));
                enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
                enhancer.setInterceptDuringConstruction(false);
                Callback[] callbacks = getCallbacks(rootClass);
                enhancer.setCallbacks(callbacks);
                enhancer.setCallbackFilter(new ProxyCallbackFilter(
                          this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap,
                          this.fixedInterceptorOffset));
                Class[] types = new Class[callbacks.length];
                for (int x = 0; x < types.length; x++) {
                    types[x] = callbacks[x].getClass();
                }
                enhancer.setCallbackTypes(types);
                // 通過Enhancer生成代理對象
                Object proxy;
                if (this.constructorArgs != null) {
                    proxy = enhancer.create(this.constructorArgTypes, this.constructorArgs);
                }
                else {
                    proxy = enhancer.create();
                }
                return proxy;
            }
            catch (CodeGenerationException ex) {
                throw new AopConfigException("Could not generate CGLIB subclass of class [" +
                        this.advised.getTargetClass() + "]: " +
                        "Common causes of this problem include using a final class or a
                        non-visible class",ex);
            }
            catch (IllegalArgumentException ex) {
                throw new AopConfigException("Could not generate CGLIB subclass of class [" +
                        this.advised.getTargetClass() + "]: " +
                        "Common causes of this problem include using a final class or anon-visible
                        class", ex);
            }
            catch (Exception ex) {
                throw new AopConfigException("Unexpected AOP exception", ex);
            }
        }