Spring Aop

Spring开启AOP一般是使用@EnableAspectJAutoProxy来开启的。这个注解的主要作用是注入了一个实现了BeanPostProcessor接口的类。这个接口在前面介绍过，会嵌入到Bean的实例化过程。 所以只要我们注入这个类AnnotationAwareAspectJAutoProxyCreator也可以开启AOP功能了。完整的代码放在Github上。

    @Bean
    public AnnotationAwareAspectJAutoProxyCreator makeAnnotationAwareAspectJAutoProxyCreator() {
        return new AnnotationAwareAspectJAutoProxyCreator();
    }

调试AnnotationAwareAspectJAutoProxyCreator的源码会发现，这个类继承的AbstractAutoProxyCreator的方法postProcessAfterInitialization中对符合切片的bean进行了二次代理，具体的代码如下。

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.containsKey(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (beanName != null && this.targetSourcedBeans.containsKey(beanName)) {
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
        // Create proxy if we have advice.
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            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;
    }

Aspect是通过BeanFactoryAspectJAdvisorsBuilder的buildAspectJAdvisors方法加载的。这个方法会读取bean的切片信息，并生成Advisor的列表，同时存在advisorsCache里面。

    public List<Advisor> buildAspectJAdvisors() {
        List<String> aspectNames = null;
        synchronized (this) {
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                List<Advisor> advisors = new LinkedList<Advisor>();
                aspectNames = new LinkedList<String>();
                String[] beanNames =
                        BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
                for (String beanName : beanNames) {
                    if (!isEligibleBean(beanName)) {
                        continue;
                    }
                    // We must be careful not to instantiate beans eagerly as in this
                    // case they would be cached by the Spring container but would not
                    // have been weaved
                    Class beanType = this.beanFactory.getType(beanName);
                    if (beanType == null) {
                        continue;
                    }
                    if (this.advisorFactory.isAspect(beanType)) {
                        aspectNames.add(beanName);
                        AspectMetadata amd = new AspectMetadata(beanType, beanName);
                        if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                            MetadataAwareAspectInstanceFactory factory =
                                    new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                            List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                            if (this.beanFactory.isSingleton(beanName)) {
                                this.advisorsCache.put(beanName, classAdvisors);
                            }
                            else {
                                this.aspectFactoryCache.put(beanName, factory);
                            }
                            advisors.addAll(classAdvisors);
                        }
                        else {
                            // Per target or per this.
                            if (this.beanFactory.isSingleton(beanName)) {
                                throw new IllegalArgumentException("Bean with name '" + beanName +
                                        "' is a singleton, but aspect instantiation model is not singleton");
                            }
                            MetadataAwareAspectInstanceFactory factory =
                                    new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                            this.aspectFactoryCache.put(beanName, factory);
                            advisors.addAll(this.advisorFactory.getAdvisors(factory));
                        }
                    }
                }
                this.aspectBeanNames = aspectNames;
                return advisors;
            }
        }
        if (aspectNames.isEmpty()) {
            return Collections.EMPTY_LIST;
        }
        List<Advisor> advisors = new LinkedList<Advisor>();
        for (String aspectName : aspectNames) {
            List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
            if (cachedAdvisors != null) {
                advisors.addAll(cachedAdvisors);
            }
            else {
                MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
                advisors.addAll(this.advisorFactory.getAdvisors(factory));
            }
        }
        return advisors;
    }

使用的时候，Spring会根据pointCut选择合适的Advisor对相应的Bean做代理。

    protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) {
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

二次代理的Bean在执行的过程中是使用ReflectiveMethodInvocation的proceed方法来执行Advisor的处理逻辑的。 上一步选出来的Advisor存在interceptorsAndDynamicMethodMatchers属性里，这是一个Advisor的列表，所以执行的过程中采用了责任链模式，不同的Advisor会依次调用下一个Advisor。

    public Object proceed() throws Throwable {
        //    We start with an index of -1 and increment early.
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }
        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

这条责任链里包含了Advisor的处理顺序，通过程序的流程图能能明显的表示出来，为了完整描述，这里假设是完整的Advisor。 

从图中可以完整的看出来各个Advisor的执行顺序。

自定义AOP

所以自定义AOP也是相同的思路，通过继承BeanPostProcessor来二次代理bean，完整的代码放在Github上了。 为了简便起见，只定义了一个注解@MyAspect，具体的Advisor通过函数名控制。 先看注解的定义，加上Component使Spring可以识别这个注解，并加载，pointCut属性则是定义切片。

@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface MyAspect {
    String value() default "";
    String pointCut();
}

再看具体的使用上，pointCut定义了切片，然后定义了before，after，around，这三个方法，目前只实现了这三个具有代表性的Advisor。

@Configuration
public class CustomizeAspectTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
        annotationConfigApplicationContext.register(CustomizeAspectTest.class);
        annotationConfigApplicationContext.refresh();
        Test test = annotationConfigApplicationContext.getBean(Test.class);
        test.test();
    }
    @Component
    public static class Test {
        public void test() {
            System.out.println("hello world");
        }
    }
    @MyAspect(pointCut = "org.wcong.test.spring.aop.CustomizeAspectTest.Test.test")
    public static class MyAspectClass {
        void before(Object[] args) {
            System.out.println("aop before");
        }
        void after(Object[] args) {
            System.out.println("aop after");
        }
        void around(MethodInvocation methodInvocation, Object[] args) throws Throwable {
            System.out.println("aop around before");
            methodInvocation.proceed(methodInvocation);
            System.out.println("aop around after");
        }
    }
    @Bean
    public CustomizeAspectProxy getCustomizeAspectScan() {
        return new CustomizeAspectProxy();
    }
}

可以发现最后导出了一个CustomizeAspectProxy的类，这个就是自定义Aop的切入点了。这里面主要实现了Advisor的加载，和对符合切片的Bean的二次代理。

public class CustomizeAspectProxy implements BeanPostProcessor, ApplicationContextAware {
    private ApplicationContext applicationContext;
    private List<AbstractAdvisor> advisorList;
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        buildAdvisor();
        Map<Method, List<AbstractAdvisor>> matchAdvisorMap = matchAdvisor(bean);
        if (matchAdvisorMap.isEmpty()) {
            return bean;
        } else {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(bean.getClass());
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setCallback(new MethodInterceptorImpl(matchAdvisorMap));
            return enhancer.create();
        }
    }
    private Map<Method, List<AbstractAdvisor>> matchAdvisor(Object bean) {
        Class<?> beanClass = bean.getClass();
        Method[] methods = beanClass.getMethods();
        if (methods == null) {
            return Collections.emptyMap();
        }
        Map<Method, List<AbstractAdvisor>> methodListMap = new HashMap<Method, List<AbstractAdvisor>>();
        for (Method method : methods) {
            for (AbstractAdvisor abstractAdvisor : advisorList) {
                if (!abstractAdvisor.isMatch(bean.getClass(), method)) {
                    continue;
                }
                List<AbstractAdvisor> advisorList = methodListMap.get(method);
                if (advisorList == null) {
                    advisorList = new LinkedList<AbstractAdvisor>();
                    methodListMap.put(method, advisorList);
                }
                advisorList.add(abstractAdvisor);
            }
        }
        return methodListMap;
    }
    private void buildAdvisor() {
        if (advisorList != null) {
            return;
        }
        synchronized (this) {
            if (advisorList != null) {
                return;
            }
            String[] beanNames = applicationContext.getBeanDefinitionNames();
            advisorList = new ArrayList<AbstractAdvisor>();
            for (String beanName : beanNames) {
                Class<?> beanClass = applicationContext.getType(beanName);
                MyAspect myAspect = beanClass.getAnnotation(MyAspect.class);
                if (myAspect == null) {
                    continue;
                }
                Method[] methods = beanClass.getDeclaredMethods();
                if (methods == null) {
                    continue;
                }
                Object bean = applicationContext.getBean(beanName);
                List<AbstractAdvisor> beanAdvisorList = new ArrayList<AbstractAdvisor>(methods.length);
                for (Method method : methods) {
                    if (method.getName().equals("before")) {
                        beanAdvisorList.add(new MethodInvocation.BeforeAdvisor(bean, method));
                    } else if (method.getName().equals("around")) {
                        beanAdvisorList.add(new MethodInvocation.AroundAdvisor(bean, method));
                    } else if (method.getName().equals("after")) {
                        beanAdvisorList.add(new MethodInvocation.AfterAdvisor(bean, method));
                    }
                }
                advisorList.addAll(beanAdvisorList);
            }
            Collections.sort(advisorList, new Comparator<AbstractAdvisor>() {
                public int compare(AbstractAdvisor o1, AbstractAdvisor o2) {
                    return o1.getOrder() - o2.getOrder();
                }
            });
        }
    }
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

其中buildAdvisor是从applicationContext里面取出所有的bean选出有MyAspect注解的类，解析成Advisor，注意到后面有一个排序，是因为这个责任链是有顺序的，after>around>before。 matchAdvisor则是读取类的信息，判断需要被代理，然后返回每个方法被代理的advisorList。 接下来是实现代理的类了，这个类是cglib的一个简单的判断，发现相应的函数有Advisor，走Aop模式，没有，走普通的代理模式。

public class MethodInterceptorImpl implements MethodInterceptor {
    private Map<Method, List<AbstractAdvisor>> advisorMap;
    public MethodInterceptorImpl(Map<Method, List<AbstractAdvisor>> advisorMap) {
        this.advisorMap = advisorMap;
    }
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        List<AbstractAdvisor> advisorList = advisorMap.get(method);
        if (advisorList == null) {
            return methodProxy.invokeSuper(o, objects);
        } else {
            MethodInvocation methodInvocation = new MethodInvocation(o, method, objects, methodProxy, advisorList);
            return methodInvocation.proceed(methodInvocation);
        }
    }
}

MethodInvocation就是具体的责任链实现的Advisor的逻辑了。MethodInvocation包含了具体需要代理的方法的元数据，并在proceed方法中开启方法的执行链路，依次调用。而这条责任链的处理链路就是after->around->before->methodProxy->around->after。

public interface Proceed {   
  Object proceed(MethodInvocation methodInvocation) throws Throwable;
}
public class MethodInvocation implements Proceed {
    private List<AbstractAdvisor> advisorList;
    private Object sourceObject;
    private Method sourceMethod;
    private Object[] sourceParameters;
    private MethodProxy sourceMethodProxy;
    private int advisorIndex = -1;
    public MethodInvocation(Object o, Method method, Object[] objects, MethodProxy methodProxy,
            List<AbstractAdvisor> advisorList) {
        this.sourceObject = o;
        this.sourceMethod = method;
        this.sourceParameters = objects;
        this.sourceMethodProxy = methodProxy;
        this.advisorList = advisorList;
    }
    public Object proceed(MethodInvocation methodInvocation) throws Throwable {
        if (advisorIndex == advisorList.size() - 1) {
            return sourceMethodProxy.invokeSuper(sourceObject, sourceParameters);
        } else {
            advisorIndex += 1;
            return advisorList.get(advisorIndex).proceed(this);
        }
    }
    public static class AroundAdvisor extends AbstractAdvisor {
        public AroundAdvisor(Object aspectObject, Method aspectMethod) {
            super(aspectObject, aspectMethod);
            order = AbstractAdvisor.AROUND_ORDER;
        }
        public Object proceed(MethodInvocation methodInvocation) throws Throwable {
            Object[] param = { methodInvocation, methodInvocation.sourceParameters };
            return aspectMethod.invoke(aspectObject, param);
        }
    }
    public static class BeforeAdvisor extends AbstractAdvisor {
        public BeforeAdvisor(Object aspectObject, Method aspectMethod) {
            super(aspectObject, aspectMethod);
            order = AbstractAdvisor.BEFORE_ORDER;
        }
        public Object proceed(MethodInvocation methodInvocation) throws Throwable {
            Object[] param = { methodInvocation.sourceParameters };
            aspectMethod.invoke(aspectObject, param);
            return methodInvocation.proceed(methodInvocation);
        }
    }
    public static class AfterAdvisor extends AbstractAdvisor {
        public AfterAdvisor(Object aspectObject, Method aspectMethod) {
            super(aspectObject, aspectMethod);
            order = AbstractAdvisor.AFTER_ORDER;
        }
        public Object proceed(MethodInvocation methodInvocation) throws Throwable {
            methodInvocation.proceed(methodInvocation);
            Object[] param = { methodInvocation.sourceParameters };
            return aspectMethod.invoke(aspectObject, param);
        }
    }
}

结语

Spring Aop的实现主要是bean的二次代理，还是用到了BeanPostProcessor，来嵌入实现的。同时依赖了Aspectj的相关定义，通过Advisor的责任链来实现嵌入到bean方法的执行前后。同时也跟Aspectj高度耦合，会直接使用Aspectj的很多类，就很难实现定制化了。