AOP代理生成

AOP就是面向切面编程，主要作用就是抽取公共代码，无侵入的增强现有类的功能。从一个简单的spring AOP配置开始：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-3.0.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    <!-- 定义target -->

    <bean id="human" class="org.lep.springtest.aop.Human">

    </bean>

    <!-- 定义advice -->

    <bean id="sleepHlper" class="org.lep.springtest.aop.SleepHelper">

    </bean>

    <!-- 定义切点 -->

    <bean id="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">

        <property name="pattern" value=".*sleep"></property>

    </bean>

    <!-- 定义advisor -->

    <bean id="sleepAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">

        <property name="advice" ref="sleepHlper"></property>

        <property name="pointcut" ref="sleepPointcut"></property>

    </bean>

    <!-- 定义代理 -->

    <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="target" ref="human"></property>

        <property name="interceptorNames" value="sleepAdvisor"></property>

    </bean>

</beans>

上面的配置涉及到AOP几个重要的概念：

pointcut：切点，定义具体什么地方需要增强
advice：通知，定义在切点处进行哪些增强，也就是在切点处干的事
advisor：通知器，将pointcut和advice结合起来，也就组成了一个切面，定义了在什么地方做什么事
target：需要进行增强的目标类，定义了对谁进行增强
proxy：将切面应用在target上，说明对谁（target）做什么事（advisor）

从上面可以看出是proxy把这些东西结合起来，那么proxy是怎么实现的呢，比如：

ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");

Sleep sleeper =(Sleep) context.getBean("proxy");

sleeper.sleep();

上面有两个问题：

定义的proxy是ProxyFactoryBean类型的，为什么可以强制转化为Sleep接口类型的
在调试的时候为什么 sleeper.sleep() 直接跳进了JdkDynamicAopProxy的invoke

针对第一个问题我们分析getBean的过程，也就是ProxyFactoryBean的初始化

ProxyFactoryBean初始化

在spring IoC容器初始化之后我们分析了bean的初始化，最后提到了FactoryBean和BeanFactory的区别，但是没有详细分析涉及到的factoryBean的初始化过程，具体如下：

ProxyFactoryBean的初始化就是先当做普通的bean初始化，之后再获取具备factory能力的bean，这里分为代理对象的生成和获得真正的代理

createAopProxy
getProxy

上面图中在ProxyFactoryBean的getSingletonInstance方法中

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

        // createAopProxy里面会调用DefaultAopProxyFactory的createAopProxy方法来获取AopProxy

        // getProxy会利用上面生成的AopProxy来生成具体的代理对象

        this.singletonInstance = getProxy(createAopProxy());

    }

    return this.singletonInstance;

}

DefaultAopProxyFactory的createAopProxy如下：

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.");

        }

        // 如果目标类实现了接口则使用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.");

        }

        // 如果没有实现接口，则使用cglib来生成proxy，因为jdk的生成方法只支持实现了接口的类的proxy生成

        return CglibProxyFactory.createCglibProxy(config);

    }

    else {

        return new JdkDynamicAopProxy(config);

    }

}

在ProxyFactoryBean的getProxy方法中会调用上面获得到的AopProxy来生成proxy，生成的proxy返回，也就是最后getBean获得到对象，这个对象是实现了Sleep接口的类，只不过这个类存在内存里面，由JdkDynamicProxy动态生成的（也就是动态代理），所以可以向上转型为Sleep

将动态代理类保存在本地，反编译得到：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.lang.reflect.UndeclaredThrowableException;

import org.lep.springtest.aop.Sleep;

public final class $Proxy0 extends Proxy implements Sleep {

    private static Method m1;

    private static Method m0;

    private static Method m3;

    private static Method m2;

    public $Proxy0(InvocationHandler var1) throws  {

        super(var1);

    }

    public final boolean equals(Object var1) throws  {

        try {

            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();

        } catch (RuntimeException | Error var3) {

            throw var3;

        } catch (Throwable var4) {

            throw new UndeclaredThrowableException(var4);

        }

    }

    public final int hashCode() throws  {

        try {

            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();

        } catch (RuntimeException | Error var2) {

            throw var2;

        } catch (Throwable var3) {

            throw new UndeclaredThrowableException(var3);

        }

    }

    public final void sleep() throws  {

        try {

            super.h.invoke(this, m3, (Object[])null);

        } catch (RuntimeException | Error var2) {

            throw var2;

        } catch (Throwable var3) {

            throw new UndeclaredThrowableException(var3);

        }

    }

    public final String toString() throws  {

        try {

            return (String)super.h.invoke(this, m2, (Object[])null);

        } catch (RuntimeException | Error var2) {

            throw var2;

        } catch (Throwable var3) {

            throw new UndeclaredThrowableException(var3);

        }

    }

    static {

        try {

            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});

            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

            m3 = Class.forName("org.lep.springtest.aop.Sleep").getMethod("sleep", new Class[0]);

            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);

        } catch (NoSuchMethodException var2) {

            throw new NoSuchMethodError(var2.getMessage());

        } catch (ClassNotFoundException var3) {

            throw new NoClassDefFoundError(var3.getMessage());

        }

    }

}

为什么调用到JdkDynamicProxy的invoke方法

上面已经说到了，因为是在内存中存在的动态代理，这个代理实现了Sleep接口，也就是说调试的时候应该跳转到的是这个代理对象的sleep方法，在sleep方法中调用了InvocationHandler的invoke方法，而JdkDynamicProxy实现了InvocationHandler接口，在JdkDynamicProxy的getProxy方法中

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

        // 把JdkDynamicProxy自身传入，在proxy中调用的就是JdkDynamicProxy的invoke方法

		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

	}

巴特西

spring源码 — 三、AOP代理生成

AOP代理生成

ProxyFactoryBean初始化

为什么调用到JdkDynamicProxy的invoke方法

最新文章

热门文章