OOP 面向对象编程，AOP(Aspect-Oriented Programming) 面向切面编程。
官方文档： https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop
1. AOP简介
主要有以下AOP技术：
1》AspectJ： 源代码和字节码级别的编织器，用户需要使用不同于Java的新语言
2》AspectWerkz：AOP框架，使用字节码动态编织器和XML配置
3》JBoss-AOP：基于拦截器和元数据的AOP框架，运行在JBoss应用服务器上，以及在AOP中用到的一些相关的技术实现
4》BCEL(Byte-Code Engineering Library): Java字节码操作类 库
5》Javassist：Java字节码操作类型，JBOSS的一个子项目
对应于现有的AOP实现方法，AOP联盟对它们进行了一定程度的抽象，从而定义出AOP体系结构。AOP联盟定义的AOP体系结构如图：
AOP联盟定义的体系结构把与AOP相关的概念大致分为由高到低、从使用到实现的三个层次。从上往下，最高层是语言和开发环境，在这个环境中可以看到几个重要的概念：
(1) 基础(base) 可以视为待增强对象或者说目标对象
(2) 切面(aspect) 通常包含对于基础的增强应用
(3) 配置(configuration)可以看成是一种编织，通过在AOP体系中提供这个配置环境，可以把基础和切面结合起来，从而完成切面对目标对象的编织实现
在SpringAOP的实现中，使用Java语言来实现增强对象与切面增强应用，并为这两者的结合提供了配置环境。对于编织配置，毫无疑问，可以使用IoC容器了完成；对于POJO对象的配置，本身就是Spring核心IoC容器的强项。因此，对于使用SpringAOP开发而言，使用POJO就能完成AOP任务。但是，对于其他AOP实现方案，可能需要使用特定的实现语言、配置环境甚至是特定的编译环境。例如在AspectJ中，尽管切面增强的是Java对象，但却需要使用特定的Aspect语言和Aspect编译器。
AOP体系的第二个层次是为语言和开发环境提供支持的，在这个层次中可以看到AOP框架的高层实现，主要包括配置和编织实现两部分内容。
最底层是编织的具体实现模块，比如反射、程序预处理、拦截器框架、类装载器框架、元数据处理等。
2. Spring AOP简介
AOP与IoC容器的结合使用，为应用开发或Spring自身功能的扩展都提供了许多便利。Spring AOP的实现和其他特性的实现一样，除了可以Spring本身提供的AOP实现之外，还封装了业界优秀的AOP解决方法AspectJ来供应用使用。这里主要眼界Spring自身的AOP实现原理。Spring充分利用了IoC容器Proxy代理对象以及AOP拦截器的功能特性，通过这些对AOP基本功能的封装机制，为用户提供了AOP的实现框架。所以Java的Proxy机制是Spring AOP的重点。
1. Advice通知
Advice(通知) 定义在连接点做什么，为切面增强提供织入接口。在SpringAOP中，它主要描述SpringAOP围绕方法调用而注入的切面行为。Advice是AOP联盟定义的一个接口，具体的接口在 org.aopalliance.aop 包下。在SpringAOP实现中，使用了这个统一接口，并通过这个接口，为AOP切面增强的植入功能做了更多的细化和扩展，衍生出很多接口，如下：
以 BeforeAdvice 接口为例进行分析。Advice和BeforeAdvice 都是一个空接口。BeforeAdvice继承关系如下：
MethodBeforeAdvice 接口定义了为待增强的目标方法设置的前置增强接口，接口包含一个方法如下：
package org.springframework.aop; import java.lang.reflect.Method; import org.springframework.lang.Nullable; public interface MethodBeforeAdvice extends BeforeAdvice { void before(Method method, Object[] args, @Nullable Object target) throws Throwable; }
作为回调函数，before方法的实现在Advice中被配置到目标方法后，会在调用目标方法前被回调。具体的调用参数有：Method对象，这个参数是目标方法的反射对象；Object[] 对象数组，这个对象数组包含目标方法的输入参数。以CountingBeforeAdvice为例子说明其用法。CountingBeforeAdvice 完成的工作是统计被调用的方法次数。作为切面增强实效，它会根据调用方法的方法名进行统计，把统计结果根据方法名和调用次数作为键值对存入一个map中。源码如下：
package org.springframework.tests.aop.advice; import java.lang.reflect.Method; import org.springframework.aop.MethodBeforeAdvice; @SuppressWarnings("serial") public class CountingBeforeAdvice extends MethodCounter implements MethodBeforeAdvice { @Override public void before(Method m, Object[] args, Object target) throws Throwable { count(m); } }
MethodCounter源码如下：
package org.springframework.tests.aop.advice; import java.io.Serializable; import java.lang.reflect.Method; import java.util.HashMap; /** * Abstract superclass for counting advices etc. * * @author Rod Johnson * @author Chris Beams */ @SuppressWarnings("serial") public class MethodCounter implements Serializable { /** Method name --> count, does not understand overloading */ private HashMap<String, Integer> map = new HashMap<>(); private int allCount; protected void count(Method m) { count(m.getName()); } protected void count(String methodName) { Integer i = map.get(methodName); i = (i != null) ? new Integer(i.intValue() + 1) : new Integer(1); map.put(methodName, i); ++allCount; } public int getCalls(String methodName) { Integer i = map.get(methodName); return (i != null ? i.intValue() : 0); } public int getCalls() { return allCount; } /** * A bit simplistic: just wants the same class. * Doesn't worry about counts. * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object other) { return (other != null && other.getClass() == this.getClass()); } @Override public int hashCode() { return getClass().hashCode(); } }
Spring提供了与BeforeAdvice 对等的AfterAdvice，类图如下：
以AfterReturningAdvice 为例进行分析：
package org.springframework.aop; import java.lang.reflect.Method; import org.springframework.lang.Nullable; public interface AfterReturningAdvice extends AfterAdvice { void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable; }
afterReturning 方法在目标方法调用结束并成功返回时调用。对于回调参数有 目标方法的返回结果、反射对象、以及调用参数等。有一个实现类CountingAfterReturningAdvice，它的实现与上面CountingBeforeAdvice 基本一样：
package org.springframework.tests.aop.advice; import java.lang.reflect.Method; import org.springframework.aop.AfterReturningAdvice; @SuppressWarnings("serial") public class CountingAfterReturningAdvice extends MethodCounter implements AfterReturningAdvice { @Override public void afterReturning(Object o, Method m, Object[] args, Object target) throws Throwable { count(m); } }
AfterAdvice还有一个子接口ThrowsAdvice，它在抛出异常时回调，这个回调是AOP使用反射机制完成的。可以通过查看CountingThrowsAdvice，如下：
public static class CountingThrowsAdvice extends MethodCounter implements ThrowsAdvice { public void afterThrowing(IOException ex) throws Throwable { count(IOException.class.getName()); } public void afterThrowing(UncheckedException ex) throws Throwable { count(UncheckedException.class.getName()); } }
在afterThrowing 方法中，从输入的异常对象中得到异常的名字并进行统计。这个count方法同样是继承MethodCounter 的方法。只是前面两个Advice统计的是方法调用次数，这里count方法统计的是抛出异常的次数。
补充：Spring AbstractAspectJAdvice类下面的五个接口代表了常见的五种通知
对应五种通知类型：
@Before 前置通知
@AfterReturning 后置通知
@Around 环绕通知
@After 最终通知
@AfterThrowing 异常抛出通知
2. Pointcut 切点
Pointcut切点决定Advice通知应该作用于哪个连接点，也就是说通过Pointcut来定义需要增强的方法的集合，这些集合的选取可以按照一定的规则来完成。在这种情况下，Pointcut通常意味着标识方法，例如：这些需要增强的地方可以由某个正则表达式进行标识，或者根据某个方法名称进行匹配。
为了方便用户使用，Spring AOP提供了具体的切点供用户使用，切点在Spring AOP的类继承体系如下：
Pointcut接口如下：
package org.springframework.aop; public interface Pointcut { ClassFilter getClassFilter(); MethodMatcher getMethodMatcher(); Pointcut TRUE = TruePointcut.INSTANCE; }
可以看到需要返回一个Methodmatcher。对于Point的匹配判断功能，具体是由这个MethodMatcher 来完成的，也就是说这个MethodMatcher需要判断是否需要对当前方法调用进行增强，或者是否需要对当前调用方法应用配置好的Advice通知。
以JdkRegexpMethodPointcut 为例说明Pointcut的原理。其源码如下：
public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut { /** * Compiled form of the patterns. */ private Pattern[] compiledPatterns = new Pattern[0]; /** * Compiled form of the exclusion patterns. */ private Pattern[] compiledExclusionPatterns = new Pattern[0]; /** * Initialize {@link Pattern Patterns} from the supplied {@code String[]}. */ @Override protected void initPatternRepresentation(String[] patterns) throws PatternSyntaxException { this.compiledPatterns = compilePatterns(patterns); } /** * Initialize exclusion {@link Pattern Patterns} from the supplied {@code String[]}. */ @Override protected void initExcludedPatternRepresentation(String[] excludedPatterns) throws PatternSyntaxException { this.compiledExclusionPatterns = compilePatterns(excludedPatterns); } /** * Returns {@code true} if the {@link Pattern} at index {@code patternIndex} * matches the supplied candidate {@code String}. */ @Override protected boolean matches(String pattern, int patternIndex) { Matcher matcher = this.compiledPatterns[patternIndex].matcher(pattern); return matcher.matches(); } /** * Returns {@code true} if the exclusion {@link Pattern} at index {@code patternIndex} * matches the supplied candidate {@code String}. */ @Override protected boolean matchesExclusion(String candidate, int patternIndex) { Matcher matcher = this.compiledExclusionPatterns[patternIndex].matcher(candidate); return matcher.matches(); } /** * Compiles the supplied {@code String[]} into an array of * {@link Pattern} objects and returns that array. */ private Pattern[] compilePatterns(String[] source) throws PatternSyntaxException { Pattern[] destination = new Pattern[source.length]; for (int i = 0; i < source.length; i++) { destination[i] = Pattern.compile(source[i]); } return destination; } }
matches 方法使用正则表达式来对方法名进行匹配。关于AOP框架中对matches 方法的调用会在下面介绍。
在SpringAOP中，还提供了其他的MethodPointcut，比如通过方法名称进行Advice匹配的NameMatchMethodPointcut， 它的匹配是方法名相同或者相匹配。如下：
@Override public boolean matches(Method method, Class<?> targetClass) { for (String mappedName : this.mappedNames) { if (mappedName.equals(method.getName()) || isMatch(method.getName(), mappedName)) { return true; } } return false; } protected boolean isMatch(String methodName, String mappedName) { return PatternMatchUtils.simpleMatch(mappedName, methodName); }
3. Advisor 通知器
完成对目标方法的切面增强设计(Advice)和关注点(Pointcut)以后，需要一个对象把他们结合起来，完成这个作用的就是Advisor(通知器)。通过Advisor，把Advice和Pointcut结合起来，这个结合为使用IoC容器配置AOP应用，或者说即开即用地使用AOP基础设施，提供了便利。在SpringAOP中，以一个Advisor的实现DefaultPointcutAdvisor 为例，了解Advisor的工作原理，其源码如下：
package org.springframework.aop.support; import java.io.Serializable; import org.aopalliance.aop.Advice; import org.springframework.aop.Pointcut; import org.springframework.lang.Nullable; @SuppressWarnings("serial") public class DefaultPointcutAdvisor extends AbstractGenericPointcutAdvisor implements Serializable { private Pointcut pointcut = Pointcut.TRUE; public DefaultPointcutAdvisor() { } public DefaultPointcutAdvisor(Advice advice) { this(Pointcut.TRUE, advice); } public DefaultPointcutAdvisor(Pointcut pointcut, Advice advice) { this.pointcut = pointcut; setAdvice(advice); } public void setPointcut(@Nullable Pointcut pointcut) { this.pointcut = (pointcut != null ? pointcut : Pointcut.TRUE); } @Override public Pointcut getPointcut() { return this.pointcut; } @Override public String toString() { return getClass().getName() + ": pointcut [" + getPointcut() + "]; advice [" + getAdvice() + "]"; } }
在DefaultPointcutAdvisor 中，pointcut默认被设置为Pointcut.TRUE，这个Pointcut.TRUE 在Pointcut接口被定义为：
Pointcut TRUE = TruePointcut.INSTANCE;
TruePointcut.INSTANCE 是一个单例模式的对象，看名字就知道这个匹配器匹配任何方法。在TruePointcut 的MethodMatcher实现中，用TrueMethodMatcher 作为匹配器，同样是一个单例对象。
final class TruePointcut implements Pointcut, Serializable { public static final TruePointcut INSTANCE = new TruePointcut(); /** * Enforce Singleton pattern. */ private TruePointcut() { } @Override public ClassFilter getClassFilter() { return ClassFilter.TRUE; } @Override public MethodMatcher getMethodMatcher() { return MethodMatcher.TRUE; } /** * Required to support serialization. Replaces with canonical * instance on deserialization, protecting Singleton pattern. * Alternative to overriding {@code equals()}. */ private Object readResolve() { return INSTANCE; } @Override public String toString() { return "Pointcut.TRUE"; } }
org.springframework.aop.MethodMatcher#TRUE如下：
MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
TrueMethodMatcher 源码如下：
final class TrueMethodMatcher implements MethodMatcher, Serializable { public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher(); private TrueMethodMatcher() { } @Override public boolean isRuntime() { return false; } @Override public boolean matches(Method method, Class<?> targetClass) { return true; } @Override public boolean matches(Method method, Class<?> targetClass, Object... args) { // Should never be invoked as isRuntime returns false. throw new UnsupportedOperationException(); } @Override public String toString() { return "MethodMatcher.TRUE"; } private Object readResolve() { return INSTANCE; } }
补充： SpringAOP和AspectJ的关系
aop是一种思想而不是一种技术。所以说，如果抛开spring，动态代理甚至静态代理都可以算是一种aop。
spring中的aop实现分为两种,基于动态代理的aop和基于AspectJ的aop。AspectJ是完全独立于Spring存在的一个Eclipse发起的项目。AspectJ甚至可以说是一门独立的语言，在java文件编译期间，织入字节码，改变原有的类。
我们常看到的在spring中用的@Aspect注解只不过是Spring2.0以后使用了AspectJ的风格而已，本质上还是Spring的原生实现。
