SpringAOP原理探究

思考：springAOP底层运用了什么设计模式？

生成代理类：代理设计模式、底层五个通知形成调用链采用：责任链设计模式

下面我们回顾下SpringAop实现流程：

1、配置@EnableAspectJAutoProxy：开启AOP权限

2、@Import(AspectJAutoProxyRegistrar.class)：往IOC容器中注入SpringAOP切面类

3、registerAspectJAnnotationAutoProxyCreatorIfNecessary（）：注册切面类

4、AnnotationAwareAspectJAutoProxyCreator.class：注册到IOC容器中，【AOP的入口】

5、AnnotationAwareAspectJAutoProxyCreator：祖宗是BeanPostProcessor接口，而实现BeanPostProcessor接口后，当Spring加载这个Bean会在实例化前调用其后置处理器实现增强

6、postProcessAfterInitialization：后置处理器【AOP实现核心逻辑】

####6.1、wrapIfNecessary（）判断该对象是否在AOP的扫包范围内，真正创建代理类的地方

#########6.1.1、getAdvicesAndAdvisorsForBean创建代理对象包括获取增强方法和根据获取的增强进行代理

#########6.1.2、createAopProxy()判断被代理类是否实现了接口，如果有实现了接口的化，是采用JDK动态代理，否则情况下就使用CGLIB代理

####6.2、根据条件判断使用JdkDynamicAopProxy或者JdkDynamicAopProxy方法实现代理

####6.3、最终执行目标方法的时候，就会进入到JdkDynamicAopProxy 的invoke方法或者JdkDynamicAopProxy的****intercept方法

####6.5、****底层使用集合存放使用通知，然后再使用责任链设计模式循环的调用

创建代理

我们先来总结下JDK和CGLIB方式

• 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
• 如果目标对象实现了接口，可以强制使用CGLIB实现AOP
• 如果目标对象没有实现接口，必须采用CGLIB库，Spring会自动在JDK动态代理和CGLIB之间转换

JDK动态代理和CGLIB字节码生成的区别？

JDK动态代理只能对实现了接口的类生成代理，而不能针对类。

CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，因为是继承，所以该类或者方法最好不要声明为final

获取代理

1.JDK代理使用示例

public interface UserService { ** //目标方法** public abstract void add(); }

public class UserServiceImpl implements UserService { /** * dynamic.proxy.UserService#add() */ public void add() { System.out.println("add......."); } }

public class MyInvocationHandler implements InvocationHandler {

**//目标对象**
private Object target;

/\*\*
 \* **构造函数**
 \* @param target：目标对象
 \*/
public MyInvocationHandler(Object target) {
    super();
    this.target = target;
}

/\*\*
 \* **执行目标对象的方法**
 \* @param proxy
 \* @param method
 \* @param args
 \* @return
 \* @throws Throwable
 \*/
public Object **invoke**(Object proxy, Method method, Object\[\] args) throws Throwable {
    System.out.println("-------------before-----------");
    Object result = method.invoke(target, args);
    System.out.println("-------------after------------");
    return result;
}

public Object getProxy(){
    return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
            target.getClass().getInterfaces(),this);
}

}

public class ProxyTest { public static void main(String[] args) { //实例化目标对象 UserService userService = new UserServiceImpl(); //实例化InvocationHandler MyInvocationHandler invocationHandler = new MyInvocationHandler(userService); //根据目标对象生成代理对象 UserService proxy = (UserService) invocationHandler.getProxy(); //调用代理对象的方法 proxy.add(); } }

输出结果：

JdkProxy使用示例源码分析

我们再次回顾下JDK代理方式，在整个创建过程中，对于InvocationHandler的创建是最为核心的，在自定义的InvocationHandler中需要重写三个函数

构造函数，将代理的对象传入

invoke方法，此方法中实现了AOP增强的所有逻辑

getProxy方法，此方法千篇一律，但是必不可少。

那么我们看看Spring中的JDK代理实现是不是也是这么做的呢？继续之前的跟踪，到达JdkDynamicAopProxy的getProxy方法。

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { return bean; } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) { Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null); if (specificInterceptors != DO_NOT_PROXY) { this.advisedBeans.put(cacheKey, Boolean.TRUE); Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));//如果循环遍历找到需要代理的对象，则会进入到这里创建代理 this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } else { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } } else { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } }

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.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {
    if (this.shouldProxyTargetClass(beanClass, beanName)) {
        proxyFactory.setProxyTargetClass(true);
    } else {
        this.evaluateProxyInterfaces(beanClass, proxyFactory);
    }
}

Advisor\[\] **advisors** \= this.buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
this.customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (this.advisorsPreFiltered()) {
    proxyFactory.setPreFiltered(true);
}

return proxyFactory.**getProxy**(this.getProxyClassLoader());

}

获取了五个通知：

public Object getProxy(@Nullable ClassLoader classLoader) { return this.createAopProxy().getProxy(classLoader); }

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

Class<?>\[\] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

}

我们可以推断出，在JdkDynamicAopProxy中一定会有个invoke函数，并且JdkDynamicAopProxy会把AOP的核心逻辑写在里面。我们查看代码发现确实是有invoke方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object oldProxy = null; boolean setProxyContext = false; TargetSource targetSource = this.advised.targetSource; Object target = null;

Class var9;
try {
    if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
        Boolean var19 = this.equals(args\[0\]);
        return var19;
    }

    if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
        Integer var18 = this.hashCode();
        return var18;
    }

    if (method.getDeclaringClass() != DecoratingProxy.class) {
        Object retVal;
        if (!this.advised.opaque && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) {
            retVal = AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            return retVal;
        }

            //有时候目标对象内部的自我调用将无法实施切面中的增强则需要通过此属性暴露代理 if (this.advised.exposeProxy) { oldProxy = AopContext.setCurrentProxy(proxy); setProxyContext = true; }

        target = targetSource.getTarget();
        Class<?> targetClass = target != null ? target.getClass() : null;

            //获取当前方法的拦截器链 List