Spring Aop源码走读（一）

上代码！！！

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class LogAspects {

    /**
     * 抽取公共的表达式
     */
    @Pointcut("execution(public int com.kylin.annotation.aop.MathCalculator.*(..))")
    public void pointCut(){}

    /**
     * JoinPoint 必须放到第一位
     * @param joinPoint
     */
    @Before("pointCut()")
    public void LogStart(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        System.out.println("方法名："+joinPoint.getSignature().getName()+"除法运行，LogStart  参数列表....."+ Arrays.asList(args));
    }

    @After(value = "pointCut()")
    public void LogEnd(JoinPoint joinPoint){
        System.out.println("方法名："+joinPoint.getSignature().getName()+"除法运行结束  LogEnd");
    }

    @AfterReturning(value = "pointCut()",returning = "result")
    public void LogReturn(JoinPoint joinPoint, Object result){
        System.out.println("方法名："+joinPoint.getSignature().getName()+"除法正常返回。。LogReturn。。运行结果"+result);
    }

    @AfterThrowing(value = "pointCut()", throwing = "e")
    public void LogException(JoinPoint joinPoint, Exception e){
        System.out.println("方法名："+joinPoint.getSignature().getName()+"除法异常，异常信息..LogException  ..."+e);
    }
}

public class MathCalculator {
    public int div(int i, int j) {
        return i/j;
    }
}

/**
 * Aop : [动态代理]
 *       指在程序运行期间动态的将某段代码切入到指定方法指定位置的编程方式
 *
 * 1. 导入Aop模块
 * 2， 定义一个业务类 ， 在业务逻辑上运行将日志打印
 * 3. 定义一个日志切面类（LogAspect），切面类里面需要动态感知MathCalculator类中的操作
 *      通知方法：
 *          前置通知(@Before) LogStart 目标方法执行之前运行
 *          后置通知(@After) LogEnd 目标方法运行结束之后执行
 *          返回通知(@AfterReturning) LogReturn
 *          异常通知(@AfterThrowing) LogException 目标方法出现异常以后运行
 *          环绕通知(@Around) 动态代理手动推进目标方法（joinPoint.procced()
 *  4. 给切面类标注何时何地运行(通知注解)
 *  5. 将切面类和业务逻辑（目标方法所以在类）都加入到容器中
 *  6. 告诉spring 哪个类是切面类（给切面类上加一个注解@Aspect）
 *  7. 给配置类中添加开启Aspect注解 @EnableAspectJAutoProxy 开启【Aop注解模式】
 *
 *  Aop原理：
 *     1.  @EnableAspectJAutoProxy是什么？
 *          @Import(AspectJAutoProxyRegistrar.class) 给容器中导入类
 *          通过ImportBeanDefinitionRegistrar 注册了一个类 internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator.class
 *
 *      2.    AnnotationAwareAspectJAutoProxyCreator
 *              AnnotationAwareAspectJAutoProxyCreator.class
 *                  -> AspectJAwareAdvisorAutoProxyCreator
 *                      -> AbstractAdvisorAutoProxyCreator
 *                          -> AbstractAutoProxyCreator
 *                              -> extend ProxyProcessorSupport
 *                              -> implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 *                              关注后置处理器，（在bean初始化完成前后做事情） 自动装配beanFactory
 *      AbstractAutoProxyCreator#setBeanFactory()
 *      AbstractAutoProxyCreator#postProcessBeforeInstantiation(java.lang.Class, java.lang.String) 有后置处理器
 *
 *      AbstractAdvisorAutoProxyCreator.setBeanFactory()  -> initBeanFactory()方法
 *
 *      AnnotationAwareAspectJAutoProxyCreator.initBeanFactory
 *
 * 流程:
 *      1)、 传入配置类，创建IOC容器
 *      2）、注册配置类， 调用refresh()刷新容器
 *      3）、registerBeanPostProcessors(beanFactory);注册bean后置处理器去拦截beanFactory
 *          1. beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 *              获取容器中已经定义了需要创建所有BeanPostProcessor
 *          2. 给容器中加别的BeanPostProcessor
 *              beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
 *          3. 优先注册实现了PriorityOrdered接口的BeanPostProcessor
 *          4. 再注册实现了Ordered接口的BeanPostProcessor
 *          5. 注册没实现优先级接口的普通的BeanPostProcessor
 *          6、 注册BeanPostProcessor实际上就是创建BeanPostProcessor对象，放到容器中
 *              创建internalAutoProxyCreator的BeanPostProcessor 类型为【AnnotationAwareAspectJAutoProxyCreator】
 *              1. 创建Bean实例 createBean(beanName, mbd, args);
 *              2. 各种属性赋值  populateBean
 *                  populateBean(beanName, mbd, instanceWrapper);
 *              3. 初始化bean
 * 			        exposedObject = initializeBean(beanName, exposedObject, mbd);
 * 			        1. AbstractAutowireCapableBeanFactory#invokeAwareMethods() 处理Aware接口方法回调
 * 			        2. wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 * 			            应用postProcessBeforeInitialization前置处理器初始化
 * 			        3. invokeInitMethods(beanName, wrappedBean, mbd);
 * 			            执行自定义的初始化方法（init-method）
 * 			        4. wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 * 			            应用postProcessAfterInitialization后置处理器初始化
 * 			    4.BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator) 创建成功
 * 			 7. 把BeanPostProcessor注册到BeanFactory中
 * 			        registerBeanPostProcessors
 * 			          -> beanFactory.addBeanPostProcessor(postProcessor);

 */
@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAop {

    @Bean
    public MathCalculator mathCalculator(){
        return new MathCalculator();
    }

    @Bean
    public LogAspects logAspects(){
        return new LogAspects();
    }
}