AOP介绍

SpringAOP核心概念
上述中已经出现的关键词有Advice(顶级的通知类/拦截器)、MethodInvocation(方法连接点)、MethodInterceptor(方法拦截器)
SpringAOP在此基础上又增加了几个类，丰富了AOP定义及使用概念，包括
Advisor：包含通知(拦截器)，Spring内部使用的AOP顶级接口，还需要包含一个aop适用判断的过滤器，考虑到通用性，过滤规则由其子接口定义，例如IntroductionAdvisor和PointcutAdvisor，过滤器用于判断bean是否需要被代理
Pointcut: 切点，属于过滤器的一种实现，匹配过滤哪些类哪些方法需要被切面处理，包含一个ClassFilter和一个MethodMatcher，使用PointcutAdvisor定义时需要
ClassFilter：限制切入点或引入点与给定目标类集的匹配的筛选器，属于过滤器的一种实现。过滤筛选合适的类，有些类不需要被处理
MethodMatcher：方法匹配器，定义方法匹配规则，属于过滤器的一种实现，哪些方法需要使用AOP

AOP使用方法

配置Advisor

这一步对SpringAOP使用者很关键，决定了我们如何定义配置Advisor，即SpringAOP和Aspectj，实际使用配置AOP方式有多种，还区分xml和注解，最终转化处理时我认为只分为这两种。其中Aspectj方式配置AOP应该是最常见应用最广泛的用法了。

前面提到Aspectj是一种静态代理，而SpringAOP是动态代理。但Aspectj的一套定义AOP的API非常好，直观易用。所以Spring引入了Aspectj，但只使用部分注解用来定义配置AOP，在获取Advisor阶段用来生成Advisor，与后面的代理生成和代理增强执行无关！
最少需要定义三个类，一个Advisor的实现类，一个Advice实现类（拦截器），一个aop适配过滤器(这里使用的Advisor为派生的PointcutAdvisor ，需要定义PointCut切点)。可以增加一个注解用于AOP埋点，需要给bean哪个方法进行切面，则方法上加上该注解。
Advisor：MyAdvisor，返回一个Advice，
Advice：MyInterceptAdvice，拦截器，invoke方法中可以添加切面逻辑代码
PointCut: MyPointCut，切点，匹配过滤出需要切面的类及方法，查找方法头注解了MyAnnotation的方法。
埋点注解：MyAnnotation
MyAdvisor.java

@Component
public class MyAdvisor implements PointcutAdvisor {@Overridepublic Advice getAdvice() {return new MyInterceptAdvice();}@Overridepublic boolean isPerInstance() {return false;}@Overridepublic Pointcut getPointcut() {return new MyPointCut();}
}

MyInterceptAdvice.java

public class MyInterceptAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("go go go MyAdvisor process!!!");return invocation.proceed();}
}

MyPointCut.java

public class MyPointCut implements Pointcut {@Overridepublic ClassFilter getClassFilter() {return new MyClassFilter();}@Overridepublic MethodMatcher getMethodMatcher() {return new MyMethodMatcher();}private class MyMethodMatcher implements MethodMatcher {@Overridepublic boolean matches(Method method, Class targetClass) {Annotation[] annoArray = method.getDeclaredAnnotations();if (annoArray == null || annoArray.length == 0) {return false;}for (Annotation annotation : annoArray) {if (annotation.annotationType() == MyAnnotation.class) {return true;}}return false;}@Overridepublic boolean isRuntime() {return false;}@Overridepublic boolean matches(Method method, Class targetClass, Object... args) {return false;}}private class MyClassFilter implements ClassFilter {@Overridepublic boolean matches(Class clazz) {return AnnotationUtils.isCandidateClass(clazz, MyAnnotation.class);}}
}

再定义一个测试类

@Component
public class TestService {@MyAnnotationpublic void test() {System.out.println("test!");}
}

运行方法测试发现aop生效

使用Aspectj间接配置Advisor

一个类就可以了，定义切点和增强方法

@Aspect
@Component
public class AopConfig {@Pointcut("execution(* cn.nec.aop.cnnecaop.service.*.*(..))")public void pointCut() {}@Around("pointCut()")public Object around(ProceedingJoinPoint joinPoin) {System.out.println("go go go MyAspectJ process!!!");Object obj = null;try {obj = joinPoin.proceed();} catch (Throwable throwable) {throwable.printStackTrace();}return obj;}
}

注解的形式，实际上最终还是被封装成Advice接口

注解AOP的几个执行时机

• @Before
  • 前置通知：目标方法之前执行
• MethodBeforeAdviceInterceptor

@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());return mi.proceed();}

• @After
  • 后置通知：目标方法之后执行（始终执行）
• AspectJAfterAdvice

@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {try {return mi.proceed();}finally {invokeAdviceMethod(getJoinPointMatch(), null, null);}}

• @AfterReturning
  • 返回通知：执行方法结束前执行（异常不执行）
  • AfterReturningAdviceInterceptor

	@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {Object retVal = mi.proceed();this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());return retVal;}

• @AfterThrowing
  • 异常通知：出现异常的时候执行
  • AspectJAfterThrowingAdvice

@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {try {return mi.proceed();}catch (Throwable ex) {if (shouldInvokeOnThrowing(ex)) {invokeAdviceMethod(getJoinPointMatch(), null, ex);}throw ex;}

• @Around
  • 环绕通知：环绕目标方法执行（执行前后都在一个方法中自定义）
  • AspectJAroundAdvice

	@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {if (!(mi instanceof ProxyMethodInvocation)) {throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);}ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);JoinPointMatch jpm = getJoinPointMatch(pmi);return invokeAdviceMethod(pjp, jpm, null, null);}

around方法中，不会有自动执行process的逻辑。因此，需要在自己定义的方法中自行执行

AOP原理分析

AOP入口

SpringAOP是对bean的一种扩展，是后处理器的一种处理。Spring bean在 执行初始化方法前后，会使用所有BeanPostProcessor对bean进行特殊处理。Aop代理即是一种对bean特殊处理。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction