一、AOP--动态代理

指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式

二、使用栗子

一、导入aop模块

       <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>

二、定义一个业务逻辑类

在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）

public class MathCalculator {
	
	public int div(int i,int j){
		System.out.println("MathCalculator...div...");
		return i/j;	
	}

}

三、定义一个日志切面类

切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；

/**
 * 切面类
 *
 * @Aspect： 告诉Spring当前类是一个切面类
 *
 */
@Aspect
public class LogAspects {

	//抽取公共的切入点表达式
	//1、本类引用
	//2、其他的切面引用
	@Pointcut("execution(public int com.spring.annotate.aop.MathCalculator.*(..))")
	public void pointCut(){};

	//@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
	@Before("pointCut()")
	public void logStart(JoinPoint joinPoint){
		Object[] args = joinPoint.getArgs();
		System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
	}

	@After("com.spring.annotate.aop.LogAspects.pointCut()")
	public void logEnd(JoinPoint joinPoint){
		System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
	}

	//JoinPoint一定要出现在参数表的第一位
	@AfterReturning(value="pointCut()",returning="result")
	public void logReturn(JoinPoint joinPoint,Object result){
		System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
	}

	@AfterThrowing(value="pointCut()",throwing="exception")
	public void logException(JoinPoint joinPoint,Exception exception){
		System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
	}

}

四、给切面类的目标方法标注何时何地运行（通知注解）

一、通知方法：
              前置通知(@Before)：logStart：在目标方法(div)运行之前运行
              后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
              返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
              异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
              环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

五、将切面类和业务逻辑类（目标方法所在类）都加入到容器中

@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {

	//业务逻辑类加入容器中
	@Bean
	public MathCalculator calculator(){
		return new MathCalculator();
	}

	//切面类加入到容器中
	@Bean
	public LogAspects logAspects(){
		return new LogAspects();
	}
}

六、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect) 

七、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】

三、AOP原理

一、@EnableAspectJAutoProxy注解

一、@EnableAspectJAutoProxy详情

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;
}

 这个注解主要是导入了@Import({AspectJAutoProxyRegistrar.class})，AspectJAutoProxyRegistrar这个类，也就是说具体功能就是在这个类中。

二、 AspectJAutoProxyRegistrar.class详解

1、AspectJAutoProxyRegistrar源码

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    AspectJAutoProxyRegistrar() {
    }

    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 注册一个AnnotationAwareAspectJAutoProxyCreator
对象，名字是internalAutoProxyCreator
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
      
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }

            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }

    }
}

 2、AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);源码

 private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
            BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                int requiredPriority = findPriorityForClass(cls);
                if (currentPriority < requiredPriority) {
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }

            return null;
        } else {
            RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
            beanDefinition.setSource(source);
            beanDefinition.getPropertyValues().add("order", Integer.MIN_VALUE);
            beanDefinition.setRole(2);
            registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
            return beanDefinition;
        }
    }

这里主要就是往容器中注册参数Class<?> cls对象，也就是AnnotationAwareAspectJAutoProxyCreator，名字为internalAutoProxyCreator。而AnnotationAwareAspectJAutoProxyCreator对象就是整个aop的核心。

三、AnnotationAwareAspectJAutoProxyCreator详解 

AnnotationAwareAspectJAutoProxyCreator层级关系

 AnnotationAwareAspectJAutoProxyCreator的父类
           ->AspectJAwareAdvisorAutoProxyCreator的父类
               ->AbstractAdvisorAutoProxyCreator的父类
                  ->AbstractAutoProxyCreator实现了
                        implements SmartInstantiationAwareBeanPostProcessor（后置处理器）, BeanFactoryAware（bean工厂）
 主要关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

二、AnnotationAwareAspectJAutoProxyCreator创建和注册流程

AnnotationAwareAspectJAutoProxyCreator其实就是后置处理器，他会在其他bean创建或者加载之前提前创建，那么当其他bean有使用aop功能时，会经历对象的生命周期，在生命周期中会执行后置处理器，那么AnnotationAwareAspectJAutoProxyCreator就会在bean创建的时候拦截到。

一、传入配置类，创建ioc容器

二、注册配置类，调用refresh（）刷新容器；

三、 registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；   

    一、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor（后置处理器）

其中一个对象就是org.springframework.aop.config.internalAutoProxyCreator

二、给容器中加别的BeanPostProcessor
 

三、优先注册实现了PriorityOrdered接口的BeanPostProcessor；  再给容器中注册实现了Ordered接口的BeanPostProcessor；最后注册没实现优先级接口的BeanPostProcessor；

注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；里面调用了getBean方法，也就是创建bean的方法，进去就是spring bean的创建流程了

 进入常见bean方法，首先是获取单例bean，获取不到再进行bean的创建

 

创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
 

 

1、创建Bean的实例

2、populateBean；给bean的各种属性赋值

3、initializeBean：初始化bean 

  1、调用invokeAwareMethods()：处理Aware接口的方法回调

    private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware)bean).setBeanName(beanName);
            }

            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = this.getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                }
            }

            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

2、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）

3、invokeInitMethods()；执行自定义的初始化方法

4、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）

4、经过上面几步，BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder

四、把BeanPostProcessor注册到BeanFactory中；