Spring 提供了很多的实现AOP的方式：Spring 接口方式，schema配置方式和注解的方式. 
如果使用接口方式引入AOP,就是用JDK提供的动态代理来实现.
如果没有使用接口的方式引入. 那么就是使用CGLIB来实现的.

AspectJ的特点
1. AspectJ属于静态织入. 他是通过修改代码实现的. 它的织入时机有三种
    1) Compile-time weaving: 编译期织入. 例如: 类A使用AspectJ增加了一个属性. 类B引用了类A,这个场景就需要在编译期的时候进行织入,否则类B就没有办法编译,会报错.
    2) Post-compile weaving: 编译后织入.也就是已经生成了.class文件了,或者是都已经达成jar包了. 这个时候,如果我们需要增强,就要使用到编译后织入
    3) Loading-time weaving: 指的是在加载类的时候进行织入. 
 
2. AspectJ实现了对AOP变成完全的解决方案. 他提供了很多Spring AOP所不能实现的功能
3. 由于AspectJ是在实际代码运行前就完成了织入,因此可以认为他生成的类是没有额外运行开销的.

package com.lxl.www.aop.interfaceAop;
/**
 * 使用接口方式实现AOP,默认通过JDK的动态代理来实现. 非接口方式,使用的是cglib实现动态代理
 *
 * 业务接口类-- 计算器接口类
 *
 * 定义三个业务逻辑方法
 */
public interface IBaseCalculate {
    int add(int numA,int numB);
    int sub(int div(int multi(int mod( numB);
}

package com.lxl.www.aop.interfaceAop;//业务类，也是目标对象
import com.lxl.www.aop.Calculate;
import org.springframework.aop.framework.AopContext;
import org.springframework.stereotype.Service;
*
 * 业务实现类 -- 基础计算器
 */
 
class BaseCalculate implements IBaseCalculate {
    @Override
     numB) {
        System.out.println("执行目标方法: add");
        return numA + numB;
    }
    @Override
    执行目标方法: subreturn numA -执行目标方法: multireturn numA *执行目标方法: divreturn numA /执行目标方法: mod);
        int retVal = ((Calculate) AopContext.currentProxy()).add(numA,numB);
        return retVal % numA;
    }
}

package com.lxl.www.aop.interfaceAop;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
*
 * 定义前置通知
 * 实现MethodBeforeAdvice接口
  BaseBeforeAdvice implements MethodBeforeAdvice {
    *
     *
     * @param method 切入的方法
     * @param args 切入方法的参数
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    void before(Method method,Object[] args,Object target) throws Throwable {
        System.===========进入beforeAdvice()============);
        System.前置通知--即将进入切入点方法===========进入beforeAdvice() 结束============\n);
    }
}

package com.lxl.www.aop.interfaceAop;
import org.aspectj.lang.annotation.AfterReturning;
import org.springframework.aop.AfterAdvice;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
*
 * 后置通知
 * 实现AfterReturningAdvice接口
  BaseAfterReturnAdvice implements AfterReturningAdvice {
    *
     *
     * @param returnValue 切入点执行完方法的返回值，但不能修改
     * @param method 切入点方法
     * @param args 切入点方法的参数数组
     * @param target 目标对象
     * @throws Throwable
      afterReturning(Object returnValue,Method method,1)">\n==========进入afterReturning()===========后置通知--切入点方法执行完成==========进入afterReturning() 结束=========== );
    }
}

package com.lxl.www.aop.interfaceAop;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
*
 * 环绕通知
 * 实现MethodInterceptor接口
  BaseAroundAdvice implements MethodInterceptor {
    *
     * invocation ：连接点
     public Object invoke(MethodInvocation invocation) throws Throwable {
        System.===========around环绕通知方法 开始=========== 调用目标方法之前执行的动作
        System.环绕通知--调用方法之前: 执行 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行
        Object returnValue = invocation.proceed();
        System.环绕通知--调用方法之后: 执行===========around环绕通知方法  结束===========return returnValue;
    }
}

package com.lxl.www.aop.interfaceAop;
import org.springframework.aop.framework.Proxyfactorybean;
import org.springframework.context.annotation.Bean;
*
 * 配置类
  MainConfig {
    *
     * 被代理的对象
     * @return
     
    @Bean
     IBaseCalculate baseCalculate() {
        return new BaseCalculate();
    }
    *
     * 前置通知
     * @return
      BaseBeforeAdvice baseBeforeAdvice() {
         BaseBeforeAdvice();
    }
    *
     * 后置通知
     * @return
      BaseAfterReturnAdvice baseAfterReturnAdvice() {
         BaseAfterReturnAdvice();
    }
    *
     * 环绕通知
     * @return
      BaseAroundAdvice baseAroundAdvice() {
         BaseAroundAdvice();
    }
    *
     * 使用接口方式,一次只能给一个类增强,如果想给多个类增强,需要定义多个Proxyfactorybean
     * 而且,曾增强类的粒度是到类级别的. 不能指定对某一个方法增强
     * @return
      Proxyfactorybean calculateProxy() {
        Proxyfactorybean proxyfactorybean =  Proxyfactorybean();
        proxyfactorybean.setInterceptorNames(baseAfterReturnAdvice",baseBeforeAdvicebaseAroundAdvice);
        proxyfactorybean.setTarget(baseCalculate());
         proxyfactorybean;
    }
}

package com.lxl.www.aop.interfaceAop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 InterfaceMainClass{
    static  main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.);
        IBaseCalculate calculate = context.getBean(calculateProxyout.println(calculate.getClass());
        calculate.add(1,1)">3);
    }
}

===========进入beforeAdvice()============
前置通知--即将进入切入点方法
===========进入beforeAdvice() 结束============
 
===========around环绕通知方法 开始===========
环绕通知--调用方法之前: 执行
执行目标方法: add
环绕通知--调用方法之后: 执行
===========around环绕通知方法  结束===========
 
==========进入afterReturning()===========
后置通知--切入点方法执行完成
==========进入afterReturning() 结束=========== 

　　@Bean
    public Proxyfactorybean calculateProxy() {
        Proxyfactorybean proxyfactorybean = new Proxyfactorybean();
        proxyfactorybean.setInterceptorNames( "baseAfterReturnAdvice","baseBeforeAdvice","baseAroundAdvice");
        proxyfactorybean.setTarget(baseCalculate());
        return proxyfactorybean;
    }

　　@Bean
    public Proxyfactorybean calculateProxy() {
        Proxyfactorybean proxyfactorybean = new Proxyfactorybean();
        proxyfactorybean.setInterceptorNames("baseAroundAdvice","baseAfterReturnAdvice","baseBeforeAdvice");
        proxyfactorybean.setTarget(baseCalculate());
        return proxyfactorybean;
    }

===========around环绕通知方法 开始===========
环绕通知--调用方法之前: 执行
===========进入beforeAdvice()============
前置通知--即将进入切入点方法
===========进入beforeAdvice() 结束============
 
执行目标方法: add
 
==========进入afterReturning()===========
后置通知--切入点方法执行完成
==========进入afterReturning() 结束=========== 
环绕通知--调用方法之后: 执行
===========around环绕通知方法  结束===========

 Proxyfactorybean extends ProxyCreatorSupport
        implements factorybean<Object>,BeanClassLoaderAware,beanfactoryAware {
......
　　 @Override
    @Nullable
     Object getObject() throws BeansException {
        *
         * 初始化通知链: 将通知放入链中
         * 后面初始化的时候,是通过责任链的方式调用这些通知链的的. 
         * 那么什么是责任链呢?
         */
        initializeAdvisorChain();
        if (isSingleton()) {
            *
             * 创建动态代理
             */
             getSingletonInstance();
        }
        else {
            if (this.targetName == null) {
                logger.info(Using non-singleton proxies with singleton targets is often undesirable. " +
                        Enable prototype proxies by setting the 'targetName' property.);
            }
             newPrototypeInstance();
        }
    }
......
}

private synchronized Object getSingletonInstance() {
        this.singletonInstance == ) {
            this.targetSource = freshTargetSource();
            this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
                 Rely on AOP infrastructure to tell us what interfaces to proxy.
                Class<?> targetClass = getTargetClass();
                if (targetClass == ) {
                    throw new factorybeanNotInitializedException(Cannot determine target class for proxy);
                }
                setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass,this.proxyClassLoader));
            }
             Initialize the shared singleton instance.
            super.setFrozen(.freezeProxy);
            *
             * 创建动态代理
             this.singletonInstance = getProxy(createAopProxy());
        }
        .singletonInstance;
    }

@Override
     Object getProxy(@Nullable ClassLoader classLoader) {
         (logger.isTraceEnabled()) {
            logger.trace(Creating JDK dynamic proxy: " + .advised.getTargetSource());
        }
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised,1)">true);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        *
         * 创建动态代理
         */
        return Proxy.newProxyInstance(classLoader,proxiedInterfaces,this);
    }

package com.lxl.www.aop.interfaceAop.chainDemo;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.MethodBeforeAdvice;
*
 * 为什么 我们可以让MethodBeforeAdvice 前置通知继承自环绕通知的接口呢?
 * 主要原因是,环绕通知的前半部分,就是前置通知
  BeforeAdviceInterceptor implements MethodInterceptor {
   前置通知
  MethodBeforeAdvice methodBeforeAdvice;
 
   BeforeAdviceInterceptor(MethodBeforeAdvice methodBeforeAdvice) {
    this.methodBeforeAdvice = methodBeforeAdvice;
  }
  *
   * 使用了环绕通知的前半部分. 就是一个前置通知
   * @param invocation the method invocation joinpoint
   * @return
   * @throws Throwable
   
  @Override
   Object invoke(MethodInvocation invocation) throws Throwable {
    methodBeforeAdvice.before(invocation.getMethod(),invocation.getArguments(),invocation.getClass());
    return invocation.proceed();
  }
}

    /**
     * 把一条链上的都初始化
     *
     * 有一条链,这条链上都有一个父类接口 MethodInterceptor.
     * 也就是说,链上都已一种类型的工人. 但每种工人的具体实现是不同的. 不同的工人做不同的工作
     *
     * 这里定义了一个责任链. 连上有两个工人. 一个是前置通知. 一个是环绕通知.
     * 前置通知和环绕通知实现的接口是不同的. 为了让他们能够在一条链上工作. 我们自定义了一个MethodBeforeAdviceInterceptor
     * 相当于为BaseBeforeAdvice()包装了一层MethodInterceptor
     */
    List<MethodInterceptor> list = new ArrayList<>();
    list.add(new BeforeAdviceInterceptor(new BaseBeforeAdvice()));
    list.add(new BaseAroundAdvice());

/**
   * 责任链调用
   */
  public static class MyMethodInvocation implements MethodInvocation {
    // 这是责任链
    protected List<MethodInterceptor> list;
    // 目标类
    protected final BaseCalculate target;
    public MyMethodInvocation(List<MethodInterceptor> list) {
      this.list = list;
      this.target = new BaseCalculate();
    }
    int i = 0;
    public Object proceed() throws Throwable {
      if (i == list.size()) {
        /**
         * 执行到责任链的最后一环,执行目标方法
         */
        return target.add(2,2);
      }
      MethodInterceptor interceptor = list.get(i);
      i++;
      /**
       * 执行责任链调用
       * 这个调用链第一环是: 包装后的前置通知
       * 调用链的第二环是: 环绕通知.
       * 都执行完以后,执行目标方法.
       */
      return interceptor.invoke(this);
    }
    @Override
    public Object getThis() {
      return target;
    }
    @Override
    public AccessibleObject getStaticPart() {
      return null;
    }
    @Override
    public Method getMethod() {
      try {
        return target.getClass().getMethod("add",int.class,int.class);
      } catch (NoSuchMethodException e) {
        e.printStackTrace();
      }
      return null;
    }
    @Override
    public Object[] getArguments() {
      return new Object[0];
    }
  }
}

 proxyfactorybean;
    }

RegexpMethodPointcutAdvisor 按正则匹配类
NameMatchMethodPointcutAdvisor 按方法名匹配
DefaultbeanfactoryPointcutAdvisor xml解析的Advisor
InstantiationModelAwarePointcutAdvisorImpl 注解解析的advisor(@Before @After....)

*
   * Advisor 种类很多：
   * RegexpMethodPointcutAdvisor 按正则匹配类
   * NameMatchMethodPointcutAdvisor 按方法名匹配
   * DefaultbeanfactoryPointcutAdvisor xml解析的Advisor
   * InstantiationModelAwarePointcutAdvisorImpl 注解解析的advisor(@Before @After....)
   
  @Bean
   NameMatchMethodPointcutAdvisor aspectAdvisor() {
    *
     * 通知和通知者的区别:
     * 通知(Advice)  ：是我们的通知类 没有带切点
     * 通知者(Advisor)：是经过包装后的细粒度控制方式。 带了切点
     
    NameMatchMethodPointcutAdvisor advisor =  NameMatchMethodPointcutAdvisor();
    // 切入点增强的通知类型--前置通知
    advisor.setAdvice(baseBeforeAdvice());
    // 指定切入点方法名--div
    advisor.setMappedNames("div");
     advisor;
  }

  @Bean
  public Proxyfactorybean calculateProxy() {
    Proxyfactorybean userService = new Proxyfactorybean();
    userService.setInterceptorNames("aspectAdvisor");
    userService.setTarget(baseCalculate());
    return userService;
  }

     * 通知和通知者的区别:
     * 通知(Advice)  ：是我们的通知类 没有带切点
     * 通知者(Advisor)：是经过包装后的细粒度控制方式。 带了切点
      NameMatchMethodPointcutAdvisor();
     切入点增强的通知类型--前置通知
    advisor.setAdvice(baseBeforeAdvice());
     指定切入点方法名--div
    advisor.setMappedNames(div);
     advisor;
  }
  *
   * autoProxy: BeanPostProcessor 手动指定Advice方式,* @return
   */ BeanNameAutoProxyCreator autoProxyCreator() {
     使用bean名字进行匹配
    BeanNameAutoProxyCreator beanNameAutoProxyCreator =  BeanNameAutoProxyCreator();
    beanNameAutoProxyCreator.setBeanNames(base* 设置拦截链的名字
    beanNameAutoProxyCreator.setInterceptorNames(aspectAdvisor beanNameAutoProxyCreator;
  }

);
        IBaseCalculate calculate = context.getBean(baseCalculate);
        calculate.add(******************);
        calculate.div(3);
    }
}

执行目标方法: add
******************
===========进入beforeAdvice()============
前置通知--即将进入切入点方法
===========进入beforeAdvice() 结束============
执行目标方法: div