Spring AOP 基本概念与代理模式 实现原理 及常用AspectJ注解
Spring AOP 基本概念与代理模式 实现原理 及常用AspectJ注解
文章目录
0. 背景
Spring框架用的时间蛮久了，但是一直都没怎么系统的学习，致使用法比较单一不灵活，也出过一些低级错误，是时候好好学习一下啦
1. AOP简述
回到主题，何为AOP？AOP即面向切面编程——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
如下图，可以很直接明了的展示整个AOP的过程：
1.1 一些基本概念
- 通知(Adivce)
通知有5种类型：
-
Before在方法被调用之前调用 -
After在方法完成后调用通知，无论方法是否执行成功 -
After-returning在方法成功执行之后调用通知 -
After-throwing在方法抛出异常后调用通知 -
Around通知了好、包含了被通知的方法，在被通知的方法调用之前后调用之后执行自定义的行为
我们可能会问，那通知对应系统中的代码是一个方法、对象、类、还是接口什么的呢？我想说一点，其实都不是，你可以理解通知就是对应我们日常生活中所说的通知，比如‘某某人，你2019年9月1号来学校报个到’，通知更多地体现一种告诉我们（告诉系统何）何时执行，规定一个时间，在系统运行中的某个时间点（比如抛异常啦！方法执行前啦！），
并非对应代码中的方法！并非对应代码中的方法！并非对应代码中的方法！ -
- 切点（Pointcut） 哈哈，这个你可能就比较容易理解了，切点在Spring AOP中确实是对应系统中的方法。但是这个方法是定义在切面中的方法，一般和通知一起使用，一起组成了切面。
- 连接点（Join point） 比如：方法调用、方法执行、字段设置/获取、异常处理执行、类初始化、甚至是 for 循环中的某个点 理论上, 程序执行过程中的任何时点都可以作为作为织入点, 而所有这些执行时点都是 Joint point 但 Spring AOP 目前仅支持方法执行 (method execution) 也可以这样理解，连接点就是你准备在系统中执行切点和切入通知的地方（一般是一个方法，一个字段）
- 切面（Aspect） 切面是切点和通知的集合，一般单独作为一个类。通知和切点共同定义了关于切面的全部内容，它是什么时候，在何时和何处完成功能。
- 引入（Introduction） 引用允许我们向现有的类添加新的方法或者属性
- 织入（Weaving） 组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。
2. 代理模式
首先AOP思想的实现一般都是基于代理模式，在JAVA中一般采用JDK动态代理模式，但是我们都知道，JDK动态代理模式只能代理接口，如果要代理类那么就不行了。因此，Spring AOP 会这样子来进行切换，因为Spring AOP 同时支持 CGLIB、ASPECTJ、JDK动态代理，当你的真实对象有实现接口时，Spring AOP会默认采用JDK动态代理，否则采用cglib代理。
- 如果目标对象的实现类实现了接口，Spring AOP 将会采用 JDK 动态代理来生成 AOP 代理类；
- 如果目标对象的实现类没有实现接口，Spring AOP 将会采用 CGLIB 来生成 AOP 代理类——不过这个选择过程对开发者完全透明、开发者也无需关心。
这里简单说说代理模式，代理模式的UML类图如下：
2.1 静态代理
接口类：
interface Person {
void speak();
}真实实体类：
class Actor implements Person {
private String content;
public Actor(String content) {
this.content = content;
}
@Override
public void speak() {
System.out.println(this.content);
}
}代理类：
class Agent implements Person {
private Actor actor;
private String before;
private String after;
public Agent(Actor actor, String before, String after) {
this.actor = actor;
this.before = before;
this.after = after;
}
@Override
public void speak() {
//before speak
System.out.println("Before actor speak, Agent say: " + before);
//real speak
this.actor.speak();
//after speak
System.out.println("After actor speak, Agent say: " + after);
}
}测试方法:
public class StaticProxy {
public static void main(String[] args) {
Actor actor = new Actor("I am a famous actor!");
Agent agent = new Agent(actor, "Hello I am an agent.", "That's all!");
agent.speak();
}
}
2.2 动态代理
在讲JDK的动态代理方法之前，不妨先想想如果让你来实现一个可以任意类的任意方法的代理类，该怎么实现？有个很naive的做法，通过反射获得Class和Method，再调用该方法，并且实现一些代理的方法。我尝试了一下，很快就发现问题所在了。于是乎，还是使用JDK的动态代理接口吧。
JDK自带方法
首先介绍一下最核心的一个接口和一个方法：
首先是java.lang.reflect包里的InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}我们对于被代理的类的操作都会由该接口中的invoke方法实现，其中的参数的含义分别是：
- proxy：被代理的类的实例
- method：调用被代理的类的方法
- args：该方法需要的参数
使用方法首先是需要实现该接口，并且我们可以在invoke方法中调用被代理类的方法并获得返回值，自然也可以在调用该方法的前后去做一些额外的事情，从而实现动态代理，下面的例子会详细写到。
另外一个很重要的静态方法是java.lang.reflect包中的Proxy类的newProxyInstance方法：
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException其中的参数含义如下：
- loader：被代理的类的类加载器
- interfaces：被代理类的接口数组
- invocationHandler：就是刚刚介绍的调用处理器类的对象实例
该方法会返回一个被修改过的类的实例，从而可以自由的调用该实例的方法。下面是一个实际例子。
Fruit接口：
public interface Fruit {
public void show();
}Apple实现Fruit接口：
public class Apple implements Fruit{
@Override
public void show() {
System.out.println("<<<);
}
}代理类Agent.java：
public class DynamicAgent {
//实现InvocationHandler接口，并且可以初始化被代理类的对象
static class MyHandler implements InvocationHandler {
private Object proxy;
public MyHandler(Object proxy) {
this.proxy = proxy;
}
//自定义invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(">>>>before invoking");
//真正调用方法的地方
Object ret = method.invoke(this.proxy, args);
System.out.println(">>>>after invoking");
return ret;
}
}
//返回一个被修改过的对象
public static Object agent(Class interfaceClazz, Object proxy) {
return Proxy.newProxyInstance(interfaceClazz.getClassLoader(), new Class[]{interfaceClazz},
new MyHandler(proxy));
}
}测试类：
public class ReflectTest {
public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
//注意一定要返回接口，不能返回实现类否则会报错
Fruit fruit = (Fruit) DynamicAgent.agent(Fruit.class, new Apple());
fruit.show();
}
}结果：
可以看到对于不同的实现类来说，可以用同一个动态代理类来进行代理，实现了“一次编写到处代理”的效果。但是这种方法有个缺点，就是被代理的类一定要是实现了某个接口的，这很大程度限制了本方法的使用场景。下面还有另外一个使用了CGlib增强库的方法。
2.3 CGLIB库的方法
CGlib是一个字节码增强库，为AOP等提供了底层支持。下面看看它是怎么实现动态代理的。
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CGlibAgent implements MethodInterceptor {
private Object proxy;
public Object getInstance(Object proxy) {
this.proxy = proxy;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.proxy.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
//回调方法
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println(">>>>before invoking");
//真正调用
Object ret = methodProxy.invokeSuper(o, objects);
System.out.println(">>>>after invoking");
return ret;
}
public static void main(String[] args) {
CGlibAgent cGlibAgent = new CGlibAgent();
Apple apple = (Apple) cGlibAgent.getInstance(new Apple());
apple.show();
}
}
3. Spring中的AOP: @AspectJ
3.1 @AspectJ 由来
AspectJ是一个AOP框架，它能够对java代码进行AOP编译（一般在编译期进行），让java代码具有AspectJ的AOP功能（当然需要特殊的编译器），可以这样说AspectJ是目前实现AOP框架中最成熟，功能最丰富的语言，更幸运的是，AspectJ与java程序完全兼容，几乎是无缝关联，因此对于有java编程基础的工程师，上手和使用都非常容易。
其实AspectJ单独就是一门语言，它需要专门的编译器(ajc编译器). Spring AOP 与ApectJ的目的一致，都是为了统一处理横切业务，但与AspectJ不同的是，Spring AOP并不尝试提供完整的AOP功能(即使它完全可以实现)，Spring AOP 更注重的是与Spring IOC容器的结合，并结合该优势来解决横切业务的问题，因此在AOP的功能完善方面，相对来说AspectJ具有更大的优势，同时,Spring注意到AspectJ在AOP的实现方式上依赖于特殊编译器(ajc编译器)，因此Spring很机智回避了这点，转向采用动态代理技术的实现原理来构建Spring AOP的内部机制（动态织入），这是与AspectJ（静态织入）最根本的区别。在AspectJ 1.5后，引入@Aspect形式的注解风格的开发，Spring也非常快地跟进了这种方式，因此Spring 2.0后便使用了与AspectJ一样的注解。请注意，Spring 只是使用了与 AspectJ 5 一样的注解，但仍然没有使用 AspectJ 的编译器，底层依是动态代理技术的实现，因此并不依赖于 AspectJ 的编译器。
所以，Spring AOP虽然是使用了AspectJ那一套注解，其实实现AOP的底层是使用了动态代理(JDK或者CGLib)来动态植入。
3.2 举个栗子
小狗类，会说话:
public class Dog {
private String name;
public void say(){
System.out.println(name + "在汪汪叫!...");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}切面类:
@Aspect //声明自己是一个切面类
public class MyAspect {
/**
* 前置通知
*/
//@Before是增强中的方位
// @Before括号中的就是切入点了
//before()就是传说的增强(建言):说白了，就是要干啥事.
@Before("execution(* com.zdy..*(..))")
public void before(){
System.out.println("前置通知....");
}
}这个类是重点，先用@Aspect声明自己是切面类，然后before()为增强，@Before(方位)+切入点可以具体定位到具体某个类的某个方法的方位. Spring配置文件:
//开启AspectJ功能.
<aop:aspectj-autoproxy />
<bean id="dog" class="com.zdy.Dog" />
<bean name="myAspect" class="com.zdy.MyAspect"/>然后Main方法:
ApplicationContext ac =new ClassPathXmlApplicationContext("applicationContext.xml");
Dog dog =(Dog) ac.getBean("dog");
System.out.println(dog.getClass());
dog.say();输出结果:
class com.zdy.Dog$$EnhancerBySpringCGLIB$$80a9ee5f
前置通知....
null在汪汪叫!...说白了，就是把切面类丢到容器，开启一个AdpectJ的功能，Spring AOP就会根据切面类中的(@Before+切入点)定位好具体的类的某个方法(我这里定义的是com.zdy包下的所有类的所有方法)，然后把增强before()切入进去.
3.3 举个Spring Boot中的栗子
这个栗子很实用，关于Aop做切面去统一处理Web请求的日志:
@Aspect
@Component
public class WebLogAspect {
private Logger logger = Logger.getLogger(getClass());
@Pointcut("execution(public * com.didispace.web..*.*(..))")
public void webLog(){}
@Before("webLog()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
// 接收到请求，记录请求内容
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
// 记录下请求内容
logger.info("URL : " + request.getRequestURL().toString());
logger.info("HTTP_METHOD : " + request.getMethod());
logger.info("IP : " + request.getRemoteAddr());
logger.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
logger.info("ARGS : " + Arrays.toString(joinPoint.getArgs()));
}
@AfterReturning(returning = "ret", pointcut = "webLog()")
public void doAfterReturning(Object ret) throws Throwable {
// 处理完请求，返回内容
logger.info("RESPONSE : " + ret);
}
}可以看上面的例子，通过@Pointcut定义的切入点为com.didispace.web包下的所有函数（对web层所有请求处理做切入点），然后通过@Before实现，对请求内容的日志记录（本文只是说明过程，可以根据需要调整内容），最后通过@AfterReturning记录请求返回的对象。
通过运行程序并访问：http://localhost:8080/hello?name=didi，可以获得下面的日志输出
2016-05-19 13:42:13,156 INFO WebLogAspect:41 - URL : http://localhost:8080/hello
2016-05-19 13:42:13,156 INFO WebLogAspect:42 - HTTP_METHOD : http://localhost:8080/hello
2016-05-19 13:42:13,157 INFO WebLogAspect:43 - IP : 0:0:0:0:0:0:0:1
2016-05-19 13:42:13,160 INFO WebLogAspect:44 - CLASS_METHOD : com.didispace.web.HelloController.hello
2016-05-19 13:42:13,160 INFO WebLogAspect:45 - ARGS : [didi]
2016-05-19 13:42:13,170 INFO WebLogAspect:52 - RESPONSE:Hello didi3.4 Spring AOP支持的几种AspectJ注解
- 前置通知@Before: 前置通知通过@Before注解进行标注，并可直接传入切点表达式的值，该通知在目标函数执行前执行，注意JoinPoint，是Spring提供的静态变量，通过joinPoint 参数，可以获取目标对象的信息,如类名称,方法参数,方法名称等，该参数是可选的。
@Before("execution(...)")
public void before(JoinPoint joinPoint){
System.out.println("...");
}- 后置通知@AfterReturning: 通过@AfterReturning注解进行标注，该函数在目标函数执行完成后执行，并可以获取到目标函数最终的返回值returnVal，当目标函数没有返回值时，returnVal将返回null，必须通过returning = “returnVal”注明参数的名称而且必须与通知函数的参数名称相同。请注意，在任何通知中这些参数都是可选的，需要使用时直接填写即可，不需要使用时，可以完成不用声明出来。
@AfterReturning(value="execution(...)",returning = "returnVal")
public void AfterReturning(JoinPoint joinPoint,Object returnVal){
System.out.println("我是后置通知...returnVal+"+returnVal);
}- 异常通知 @AfterThrowing:该通知只有在异常时才会被触发，并由throwing来声明一个接收异常信息的变量，同样异常通知也用于Joinpoint参数，需要时加上即可.
@AfterThrowing(value="execution(....)",throwing = "e")
public void afterThrowable(Throwable e){
System.out.println("出现异常:msg="+e.getMessage());
}- 最终通知 @After:该通知有点类似于finally代码块，只要应用了无论什么情况下都会执行.
@After("execution(...)")
public void after(JoinPoint joinPoint) {
System.out.println("最终通知....");
}- 环绕通知 @Around: 环绕通知既可以在目标方法前执行也可在目标方法之后执行，更重要的是环绕通知可以控制目标方法是否指向执行，但即使如此，我们应该尽量以最简单的方式满足需求，在仅需在目标方法前执行时，应该采用前置通知而非环绕通知。案例代码如下第一个参数必须是ProceedingJoinPoint，通过该对象的proceed()方法来执行目标函数，proceed()的返回值就是环绕通知的返回值。同样的，ProceedingJoinPoint对象也是可以获取目标对象的信息,如类名称,方法参数,方法名称等等
@Around("execution(...)")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("我是环绕通知前....");
//执行目标函数
Object obj= (Object) joinPoint.proceed();
System.out.println("我是环绕通知后....");
return obj;
}然后说下一直用"…"忽略掉的切入点表达式，这个表达式可以不是exection(…)，还有其他的一些，我就不说了，说最常用的execution:
//scope ：方法作用域，如public,private,protect
//returnt-type：方法返回值类型
//fully-qualified-class-name：方法所在类的完全限定名称
//parameters 方法参数
execution(<scope> <return-type> <fully-qualified-class-name>.*(parameters))
<fully-qualified-class-name>.*(parameters)注意这一块，如果没有精确到class-name，而是到包名就停止了，要用两个"…"来表示包下的任意类:
- execution(* com.zdy…*(…))：com.zdy包下所有类的所有方法.
- execution(* com.zdy.Dog.*(…)): Dog类下的所有方法.
具体详细语法，大家如果有需求自行google了，我最常用的就是这俩了。要么按照包来定位，要么按照具体类来定位.
在使用切入点时，还可以抽出来一个@Pointcut来供使用:
/**
* 使用Pointcut定义切点
*/
@Pointcut("execution(...)")
private void myPointcut(){}
/**
* 应用切入点函数
*/
@After(value="myPointcut()")
public void afterDemo(){
System.out.println("最终通知....");
}可以避免重复的execution在不同的注解里写很多遍…
3.5 AOP切面的优先级
由于通过AOP实现，程序得到了很好的解耦，但是也会带来一些问题，比如：我们可能会对Web层做多个切面，校验用户，校验头信息等等，这个时候经常会碰到切面的处理顺序问题。
所以，我们需要定义每个切面的优先级，我们需要@Order(i)注解来标识切面的优先级。i的值越小，优先级越高。假设我们还有一个切面是CheckNameAspect用来校验name必须为derry，我们为其设置@Order(10)，而上文中WebLogAspect设置为@Order(5)，所以WebLogAspect有更高的优先级，这个时候执行顺序是这样的：
- 在
@Before中优先执行@Order(5)的内容，再执行@Order(10)的内容 - 在
@After和@AfterReturning中优先执行@Order(10)的内容，再执行@Order(5)的内容
所以我们可以这样子总结：
- 在切入点前的操作，按order的值由小到大执行
- 在切入点后的操作，按order的值由大到小执行