Spring AOP的实现(2)---Spring AOP的设计与实现

本文解析了Spring AOP的实现原理,介绍了如何通过JDK动态代理和CGLIB生成AOP代理对象,并探讨了AOP基础设施的构建过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

2. Spring AOP的设计与实现

2.1 JVM 的动态代理特性

  在Spring AOP实现中,使用的核心技术是动态代理,而这种动态代理实际上是JDK的一个特性(在JDK 1.3以上的版本里,实现了动态代理模式).通过JDK的动态代理特性,可以为任意Java对象创建代理对象,对于具体使用来说,这个特性是通过Java Reflection API归来完成的。
java代理模式介绍:https://www.cnblogs.com/cenyu/p/6289209.html

2.2 Spring AOP的设计分析

Spring AOP将.AspectJ集成了进来,为IoC容器和Spring应用开发提供了一个一致性的AOP解决方案。
  Spring AOP的核心技术JDK动态代理技术.以动态代理技术为基础,设计出了一系列AOP的横切实现,比如前置通知、返回通知、异常通知等。同时, Spring AOP还提供了一系列的Pointcut来匹配切人点,可以使用现有的切入点来设计横切面,也可以扩展相关的Pointcut方法来实现切入需求。
  在Spring AOP中,虽然对于AOP的使用者来说,只需要配置相关的Bean定义即可,但仔细分析Spring AOP的内部设计可以看到,为了让AOP起作用,需要完成一系列过程,比如,需要为目标对象建立代理对象,这个代理对象可以通过使用JDK的Proxy来完成,也可以通过第三方的类生成器CGLIB来完成。然后,还需要启动代理对象的拦截器来完成各种横切面的织入,这一系列的织入设计是通过一系列Adapter来实现的。通过一系列Adapter的设计,可以把AOP的横切面设计和Proxy模式有机地结合起来,从而实现在AOP中定义好的各种织入方式。
  Spring AOP的应用场景
  Spring AOP为loC的使用提供了更多的便利, 一方面,应用可以直接使用AOP的功能,设计应用的横切关注点,把跨越应用程序多个模块的功能抽象出来,并通过简单的AOP的使用,灵活地编制到模块中,比如可以通过AOP实现应用程序中的日志功能.另一方面,在Spring内部,一些支持模块也是通过Spring AOP来实现的,事务处理。

3.3 建立AopProxy代理对象

3.1 设计原理

  在Spring的AOP模块中,一个主要的部分是代理对象的生成,而对于Spring应用,可以看到,是通过配置和调用Spring的ProxyFactoryBean来完成这个任务的。在ProxyFactoryBean中,封装了主要代理对象的生成过程。在这个生成过程中,可以使用JDK的Proxy和CGLIB两种生成方式。
  以ProxyFactory的设计为中心,可以看到相关的类继承关系如图所示。
这里写图片描述
  在这个类继承关系中,可以看到完成AOP应用的类,比如AspectJProxyFactory 、ProxyFactory和ProxyFactory Bean ,它们都在同一个类的继承体系下,都是ProxyConfig 、AdvisedSupport和ProxyCreatorSupport的子类.作为共同基类,可以将ProxyConfig看成是一个数据基类,这个数据基类为ProxyFactoryBean这样的子类提供了配置属性,在另一个基类AdvisedSupport的实现中,封装了AOP对通知和通知器的相关操作,这些操作对于不同的AOP的代理对象的生成都是一样的,但对于具体的AOP代理对象的创建, AdvisedSupport把它交给它的子类们去完成。对于ProxyCreatorSupport ,可以将它看成是其子类创建AOP代理对象的一个辅助类.通过继承以上提到的基类的功能实现,具体的AOP代理对象的生成,根据不同的需要,分别由ProxyFactoryBean 、AspectJProxy Factory和ProxyFactory来完成。对于需要使用AspectJ的AOP应用,AspectJProxyFactory起到集成Spring和AspectJ的作用,对于使用Spring AOP的应用, ProxyFactory Bean和ProxyFactoy都提供了AOP功能的封装,只是使用ProxyFactoryBean , 可以在IoC容器中完成声明式配置,而使用ProxyFactory ,则需要编程式地使用Spring AOP的功能。ProxyFactoryBean相关的类层次关系如图所示。
这里写图片描述

3.2 配置ProxyFactoryBean

  从这部分开始,进入到Spring AOP的实现部分,在分析Spring AOP的实现原理中,主要以ProxyFactoryBean 的实现作为例子和实现的基本线索进行分析。这是因为ProxyFactoryBean是在Spring loC环境中创建AOP应用的底层方法,也是最灵活的方法,Spring 通过它完成了对AOP使用的封装。以.ProxyFactoryBean的实现为入口,逐层深入。
  在了解ProxyFactoryBean的实现之前,先简要介绍一下ProxyFactoryBean的配置和使用,在基于XML配置Spring的Bean时,往往需要一系列的配置步骤来使用ProxyFactoryBean和AOP 。
  1)定义使用的通知器Advisor,这个通知器应该作为一个Bean来定义。很重要的一点是,这个通知器的实现定义了需要对目标对象进行增强的切面行为,也就是Advice通知。
  2)定义ProxyFactoryBean ,把它作为另一个Bean来定义,它是封装AOP功能的主要类。在配置ProxyFactoryBean时,需要设定与AOP实现相关的重要属性,比如proxyInterface 、interceptorNames和target等。从属性名称可以看出, interceptorNames属性的值往往设置为需要定义的通知器,因为这些通知器在ProxyFactoryBean的AOP配置下,是通过使用代理对象的拦截器机制起作用的。所以,这里依然沿用了拦截器这个名字。
  3)定义target属性,作为target属性注入的Bean ,是需要用AOP通知器中的切面应用来增强的对象,也就是前面提到的base对象。
  有了这些配置,就可以使用ProxyFactory Bean完成AOP的基本功能了。关于配置的例子,如代码所示。

<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>

  与前面提到的配置步骤相对应,可以看到,除定义了ProxyFactoryBean的AOP封装外,还定义了一个Advisor,名为testAdvisor. 作为ProxyFactory配置的一部分,还需要配置拦截的方法调用接口和目标对象。这些基本的配置,是使用ProxyFactoryBean实现AOP功能的重要组成,其实现和作用机制也是后面重点分析的内容。

3.3 ProxyFactoryBean生成AopProxy代理对象

  在Spring AOP的使用中,我们已经了解到,可以通过ProxyFactoryBean来配置目标对象和切面行为。这个ProxyFactoryBean是一个FactoryBean 。在ProxyFactoryBean中,通过interceptorNames属性来配置已
经定义好的通知器Advisor。虽然名字为interceptorNames ,但实际上却是供AOP应用配置通知器的地方。在ProxyFactoryBean中,需要为target 目标对象生成Proxy代理对象,从而为AOP横切面的编织做好准备工作。这些具体的代理对象生成工作是通过JDK的Proxy或CGLIB来完成的。具体的AopProxy生成过程如图所示。
这里写图片描述
  ProxyFactoryBean 的AOP 实现需要依赖JDK或者CG LIB 提供的Proxy 特性。从FactoryBean中获取对象,是以getObject()方法作为入口完成的, ProxyFactoryBean实现中的getObject方法。是FactoryBean需要实现的接口。对ProxyFactoryBean来说,把需要对target目标对象增加的增强处理,都通过getObject方法进行封装了,这些增强处理是为AOP功能的实现提供服务的。getObject的实现如代码所示。

/**
     * Return a proxy. Invoked when clients obtain beans from this factory bean.
     * Create an instance of the AOP proxy to be returned by this factory.
     * The instance will be cached for a singleton, and create on each call to
     * {@code getObject()} for a proxy.
     * @return a fresh AOP proxy reflecting the current state of this factory
     */
    public Object getObject() throws BeansException {
        initializeAdvisorChain();
        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();
        }
    }

  getObject方法首先对通知器链进行初始化,通知器链封装了一系列的拦截器,这些拦截器都要从配置中读取,然后为代理对象的生成做好准备。在生成代理对象时,因为Spring中有singleton类型和prototype类型这两种不同的Bean ,所以要对代理对象的生成做一个区分。
  为Proxy代理对象配置Advisor链是在InitializeAdvisorChain方法中完成的,如代码所示。

/**
     * Create the advisor (interceptor) chain. Aadvisors that are sourced
     * from a BeanFactory will be refreshed each time a new prototype instance
     * is added. Interceptors added programmatically through the factory API
     * are unaffected by such changes.
     */
    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));
            }

            // Globals can't be last unless we specified a targetSource using the property...
            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");
            }

            // Materialize interceptor chain from bean names.
            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 {
                    // If we get here, we need to add a named interceptor.
                    // We must check if it's a singleton or prototype.
                    Object advice;
                    if (this.singleton || this.beanFactory.isSingleton(name)) {
                        // Add the real Advisor/Advice to the chain.
                        advice = this.beanFactory.getBean(name);
                    }
                    else {
                        // It's a prototype Advice or Advisor: replace with a prototype.
                        // Avoid unnecessary creation of prototype bean just for advisor chain initialization.
                        advice = new PrototypePlaceholderAdvisor(name);
                    }
                    addAdvisorOnChainCreation(advice, name);
                }
            }
        }

        this.advisorChainInitialized = true;
    }

  这个初始化过程有一个标志位advisorChainlnitialized ,这个标志用来表示通知器链是否已经初始化。如果已经初始化,那么这里就不会再初始化,而是直接返回。也就是说,这个初始化的工作发生在应用第一次通过ProxyFactoryBean去获取代理对象的时候。在完成这个初始化之后,接着会读取配置中出现的所有通知器,这个取得通知器的过程也比较简单,把通知器的名字交给容器的getBean方法就可以了,这是通过对IoC容器实现的一个回调来完成的。然后把从IoC容器中取得的通知器加入拦截器链中,这个动作是由addAdvisorOnChainCreation方法来实现的。
  生成singleton的代理对象在getSingletonlnstance()的代码中完成,这个方法是ProxyFactoryBean生成AopProxy代理对象的调用入口。代理对象会封装对target 目标对象的调用,也就是说针对target对象的方法调用行为会被这里生成的代理对象所拦截。具体的生成过程是,首先i卖取ProxyFactoryBean中的配置,为生成代理对象做好必要的准备,比如设置代理的方法调用接口等。Spring通过AopProxy类来具体生成代理对象。对于getSingletonlnstance()方法中代理对象的生成过程,如代码所示。

/**
     * Return the singleton instance of this class's proxy object,
     * lazily creating it if it hasn't been created already.
     * @return the shared singleton proxy
     */
    private synchronized Object getSingletonInstance() {
        if (this.singletonInstance == null) {
            this.targetSource = freshTargetSource();
            if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
                // Rely on AOP infrastructure to tell us what interfaces to proxy.
                Class<?> targetClass = getTargetClass();
                if (targetClass == null) {
                    throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
                }
                setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
            }
            // Initialize the shared singleton instance.
            super.setFrozen(this.freezeProxy);
            this.singletonInstance = getProxy(createAopProxy());
        }
        return this.singletonInstance;
    }

  这里出现了AopProxy类型的对象, Spring利用这个AopProxy接口类把AOP代理对象的实现与框架的其他部分有效地分离开来。AopProxy是一个接口,它由两个子类实现, 一个是Cglib2AopProxy ,另一个是JdkDynamicProxy 。顾名思义,对这两个AopProxy接口的子类的实现, Spring分别通过CGLIB和JDK来生成需要的Proxy代理对象。
  具体的代理对象的生成,是在ProxyFactoryBean的基类AdvisedSupport的实现中借助AopProxyFactory完成的,这个代理对象要么从JDK 中生成,要么借助CGLIB获得。因为ProxyFactoryBean本身就是AdvisedSupport的子类,所以在ProxyFactoryBean 中获得AopProxy是很方便的,可以在ProxyCreatorSupport 中看到,具体的AopProxy是通过AopProxyFactory 来生成的。至于需要生成什么样的代理对象,所有信息都封装在AdvisedSupport里,这个对象也是生成AopProxy的方法的输入参数,这里设置为this本身,因为ProxyCreatorSupport本身就是AdvisedSupport的子类。在ProxyCreatorSupport中生成代理对象的入口实现,如代码所示。

/**
     * Subclasses should call this to get a new AOP proxy. They should <b>not</b>
     * create an AOP proxy with {@code this} as an argument.
     */
    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        return getAopProxyFactory().createAopProxy(this);
    }

  这里使用了AopProxyFactory 来创建AopProxy, AopProxyFactory 使用的是DefaultAopProxyFactory 。这个被使用的AopProxyFactory ,作为AopProxy的创建工厂对象,是在ProxyFactoryBean的基类ProxyCreatorSupport中被创建的。在创建AopProxyFactory时,它被设置为DefaultAopProxyFactory ,很显然, Spring给出了这个默认的AopProxyFactory工厂的实现。有了这个AopProxyFactory对象以后,问题就转换为在DefaultAopProxyFactory 中,AopProxy是怎样生成的了。
  关于AopProxy代理对象的生成,需要考虑使用哪种生成方式,如果自标对象是接口类,那适合使用JDK来生成代理对象,否则lSpring会使用CGLIB来生成目标对象的代理对象。为了满足不同的代理对象生成的要求, DefaultAopProxyFactory作为AopProxy对象的生产工厂,可以根据不同的需要生成这两种AopProxy对象。对于AopProxy对象的生产过程,在Defaul山opProxyFactory
创建AopProxy的过程中可以清楚地看到,但这是一个比较高层次的AopProxy代理对象的生成过程,如代码所示。

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(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.");
            }
            if (targetClass.isInterface()) {
                return new JdkDynamicAopProxy(config);
            }
            return CglibProxyFactory.createCglibProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

  所谓高层次,是指在DefaultAopProxyFactory创建AopProxy的过程中,对不同的AopProxy代理对象的生成所涉及的生成策略和场景做了相应的设计,但是对于具体的AopProxy代理对象的生成,最终并设有由DefaultAopProxyFactory来完成,比如对JDK和CGLIB这些具体的技术的使用,对具体的实现层次的代理对象的生成,是由Spring 封装的JdkDynamicAopProxy和CglibProxyFactory类来完成的。
  在AopProxy代理对象的生成过程中,首先要从AdvisedSupport对象中取得配置的目标对象,这个目标对象是实现AOP功能所必需的,道理很简单, AOP完成的是切面应用对目标对象的增强。如果这里没有配置目标对象,会直接抛出异常,提醒AOP应用,需要提供正确的目标对象的配置。在对目标对象配置的检查完成以后,需要根据配置的情况来决定使用什么方式来创建AopProxy 代理对象,一般而言,默认的方式是使用JDK来产生AopProxy代理对象,但是如果遇到配置的目标对象不是接口类的实现,会使用CGLIB来产生AopProxy代理对象,在使用CGLIB来产生AopProxy代理对象时, 因为CGLIB是一个第三方的类库,本身不在JDK的基本类库中,所以需要在CLASSPATH路径中进行正确的配置,以便能够加载和使用。在Spring 中,使用JDK和CGLIB来生成AopProxy代理对象的工作,是由JdkDynamicAopProxy和CglibProxyFactory来完成的。

3.4 JDK生成AopProxy代理对象

  AopProxy代理对象可以由JDK或CGLIB来生成,而JdkDynamicAopProxy和Cglib2AopProxy实现的都是通过AopProxy接口,它们的层次关系如图所示。
这里写图片描述
  在这里可以看到使用两种代理对象的实现方式, 一种是使用CGLIB , 另一种使用JDK 自己的Proxy。具体怎样生成代理对象,通过这两个类的源代码实现就可以了解,在AopProxy的接口下,设计了Cglib2AopProxy和JdkDynamicAopProxy两种Proxy代理对象的实现,而AopProxy的接口设计也很简单,就是在得Proxy代理对象.获得Proxy代理对象的方式有两种,一种方式是需要指定ClassLoader,另一种方式则不需要指定。
   在AopProxy接口实现中,这个代理对象的生成过程如代码所示。

public Object getProxy() {
        return getProxy(ClassUtils.getDefaultClassLoader());
    }

    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);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

在JdkDynamicAopProxy 中,使用了JDK的Proxy类来生成代理对象,在生成Proxy对象之前,首先需要从advised对象中取得
代理对象的代理接口配置,然后调用Proxy的newProxy Instance方法,最终得到对应的Proxy
代理对象。在生成代理对象时,需要指明三个参数,一个是类装载器,一个是代理接口.另外一个就是Proxy 回调方法所在的对象,这个对象需要实现lnvocationHandler接口。这个InvocationHandler 接口定义了invoke 方法,提供代理对象的回调入口。对于JdkDynamicAopProxy ,它本身实现了InvocationHandler接口和invoke方法,这个invoke方法是Proxy代理对象的回调方法,所以可以使用this来把JdkDynamicAopProxy指派给Proxy对象,也就是说JdkDynamicAopProxy对象本身,在Proxy代理的接口方提被调用肘,会触发invoke方法的回调,这个回调方法完成了AOP编织实现的封装。在这里先重点关注AopProxy代理对象的生成, Proxy代理对象的invoke实现,将是详细分析AOP实现原理的重要部分。

3.5 CGLIB 生成AopProxy代理对象

  在AopProxy接口实现中, 可以看到使用CGLIB来生成Proxy代理对象,这个Proxy代理对象的生成可以在Cglib2AopProxy的代码实现中看到.同样是在AopProxy的接口方法getProxy的实现中完成的,如代码所示。

public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
        }

        try {
            Class<?> rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

            Class<?> proxySuperClass = rootClass;
            if (ClassUtils.isCglibProxyClass(rootClass)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                for (Class<?> additionalInterface : additionalInterfaces) {
                    this.advised.addInterface(additionalInterface);
                }
            }

            // Validate the class, writing log messages as necessary.
            validateClassIfNecessary(proxySuperClass);

            // Configure CGLIB Enhancer...
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader &&
                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new MemorySafeUndeclaredThrowableStrategy(UndeclaredThrowableException.class));
            enhancer.setInterceptDuringConstruction(false);

            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);
            enhancer.setCallbacks(callbacks);

            // Generate the proxy class and create a proxy instance.
            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 a non-visible class",
                    ex);
        }
        catch (Exception ex) {
            // TargetSource.getTarget() failed
            throw new AopConfigException("Unexpected AOP exception", ex);
        }
    }

  可以看到具体对CGLIB的使用,比如对Enhancer对象的配置,以及通过Enhancer对象生成代理对象的过程。在这个生成代理对象的过程中,需要挂意的是对Enhancer对象callback回调的设置,正是这些回调封装了Spring AOP的实现,就像前面介绍的JDK的Proxy对象的invoke 回调方法一样。在Enhancer的callback回调设置中,实际上是通过设置DynamicAdvisedlnterceptor拦截器来完成AOP功能的。
  这样,通过使用AopProxy对象封装target 目标对象之后, ProxyFactory Bean的getObject方法得到的对象就不是一个普通的Java 对象了,而是一个AopProxy 代理对象。在ProxyfactoryBean中配置的target 目标对象,这时已经不会让应用直接调用其方位实现,而是作为AOP实现的一部分。对target 目标对象的方法调用会首先被AopProxy代理对象拦截,对于不同的AopProxy代理对象生成方式,会使用不同的拦截回调入口。例如,对于JDK 的AopProxy代理对象,使用的是lnvocationHandler的invoke 回调入口,而对于CG LIB 的AopProxy代理对象,使用的是设置好的callback回调,这是由对CG LIB的使用来决定的。在这些callback 回调中,对于AOP实现,是通过DynamicAdvisedlnterceptor来完成的,而DynamicAdvisedlnterceptor的回调入口是intercept方法。通过这一系列的准备,已经为实现AOP的横切机制奠定了基础,在这个基础上, AOP的Advisor已经可以通过AopProxy代理对象的拦截机制,对需要它进行增强的target 目标对象发挥切面的强大威力。
  可以把AOP的实现部分看成由基础设施准备和AOP运行辅助这两个部分组成,这里的AopProxy代理对象的生成,可以看成是一个静态的AOP基础设施的建立过程。通过这个准备过程,把代理对象、拦截器这些待调用的部分都准备好,等待着AOP运行过程中对这些基础设施的使用。对于应用触发的AOP应用,会涉及AOP框架的运行和对AOP基础设施的使用。这些动态的运行部分,是从前面提到的拦截器回调入口开始的,这些拦截器调用的实现原理,和AopProxy代理对象生成一样,也是AOP实现的重要组成部分。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

江北望江南

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值