package org.aopalliance.intercept;
import java.lang.reflect.Method;
/**
* 方法调用的描述，在方法调用时提供给拦截器。
* 方法调用是一个连接点，可以被方法拦截器拦截。
*/
public interface MethodInvocation extends Invocation {
/**
* 返回正在被调用得方法~~~ 返回的是当前Method对象。
* 此时，效果同父类的AccessibleObject getStaticPart() 这个方法
*/
Method getMethod();
}
通知(Advice)
通知中用来实现被增强的逻辑，通知中有2个关注点，再强调一下：方法的什么地方，执行什么操作。
Advice接口
通知的顶层接口，这个接口内部没有定义任何方法。
package org.aopalliance.aop;
public interface Advice {
}
Advice 4个子接口
MethodBeforeAdvice接口
方法执行前通知，需要在目标方法执行前执行一些逻辑的，可以通过这个实现。
通俗点说：需要在目标方法执行之前增强一些逻辑，可以通过这个接口来实现。before方法：在调用给定方法之前回调。
package org.springframework.aop;
public interface MethodBeforeAdvice extends BeforeAdvice {
/**
* 调用目标方法之前会先调用这个before方法
-
method：需要执行的目标方法
-
args：目标方法的参数
-
target：目标对象
*/
void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}
如同
public Object invoke(){
调用MethodBeforeAdvice#before方法
return 调用目标方法;
}
AfterReturningAdvice接口
方法执行后通知，需要在目标方法执行之后执行增强一些逻辑的，可以通过这个实现。
不过需要注意一点：目标方法正常执行后，才会回调这个接口，当目标方法有异常，那么这通知会被跳过。
package org.springframework.aop;
public interface AfterReturningAdvice extends AfterAdvice {
/**
* 目标方法执行之后会回调这个方法
-
method：需要执行的目标方法
-
args：目标方法的参数
-
target：目标对象
*/
void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
}
如同
public Object invoke(){
Object retVal = 调用目标方法;
调用AfterReturningAdvice#afterReturning方法
return retVal;
}
ThrowsAdvice接口
package org.springframework.aop;
public interface ThrowsAdvice extends AfterAdvice {
}
此接口上没有任何方法，因为方法由反射调用，实现类必须实现以下形式的方法，前3个参数是可选的，最后一个参数为需要匹配的异常的类型。
void afterThrowing([Method, args, target], ThrowableSubclass);
有效方法的一些例子如下：
public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)
MethodInterceptor接口
方法拦截器，这个接口最强大，可以实现上面3种类型的通知，上面3种通知最终都通过适配模式将其转换为MethodInterceptor方式去执行。
package org.aopalliance.intercept;
@FunctionalInterface
public interface MethodInterceptor extends Interceptor {
/**
* 拦截目标方法的执行，可以在这个方法内部实现需要增强的逻辑，以及主动调用目标方法
*/
Object invoke(MethodInvocation invocation) throws Throwable;
}
使用方式如：
public class TracingInterceptor implements MethodInterceptor {
Object invoke(MethodInvocation i) throws Throwable {
System.out.println("method “+i.getMethod()+” is called on “+ i.getThis()+” with args "+i.getArguments());
Object ret=i.proceed();//转到拦截器链中的下一个拦截器
System.out.println("method “+i.getMethod()+” returns "+ret);
return ret;
}
}
拦截器链
一个目标方法中可以添加很多Advice，这些Advice最终都会被转换为MethodInterceptor类型的方法拦截器，最终会有多个MethodInterceptor，这些MethodInterceptor会组成一个方法调用链。
Aop内部会给目标对象创建一个代理，代理对象中会放入这些MethodInterceptor会组成一个方法调用链，当调用代理对象的方法的时候，会按顺序执行这些方法调用链，一个个执行，最后会通过反射再去调用目标方法，进而对目标方法进行增强。
切入点(PointCut)
通知（Advice）用来指定需要增强的逻辑，但是哪些类的哪些方法中需要使用这些通知呢？这个就是通过切入点来配置的，切入点在spring中对应了一个接口
PointCut接口
package org.springframework.aop;
public interface Pointcut {
/**
* 类过滤器, 可以知道哪些类需要拦截
*/
ClassFilter getClassFilter();
/**
* 方法匹配器, 可以知道哪些方法需要拦截
*/
MethodMatcher getMethodMatcher();
/**
* 匹配所有对象的 Pointcut，内部的2个过滤器默认都会返回true
*/
Pointcut TRUE = TruePointcut.INSTANCE;
}
ClassFilter接口
比较简单，用来过滤类的
@FunctionalInterface
public interface ClassFilter {
/**
* 用来判断目标类型是否匹配
*/
boolean matches(Class<?> clazz);
}
MethodMatcher接口
用来过滤方法的。
public interface MethodMatcher {
/**
* 执行静态检查给定方法是否匹配
* @param method 目标方法
* @param targetClass 目标对象类型
*/
boolean matches(Method method, Class<?> targetClass);
/**
* 是否是动态匹配，即是否每次执行目标方法的时候都去验证一下
*/
boolean isRuntime();
/**
* 动态匹配验证的方法，比第一个matches方法多了一个参数args，这个参数是调用目标方法传入的参数
*/
boolean matches(Method method, Class<?> targetClass, Object… args);
/**
* 匹配所有方法，这个内部的2个matches方法任何时候都返回true
*/
MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
}
我估计大家看MethodMatcher还是有点晕的，为什么需要2个maches方法？什么是动态匹配？
比如下面一个类
public class UserService{
public void work(String userName){
System.out.print(userName+“,开始工作了!”);
}
}
work方法表示当前用户的工作方法，内部可以实现一些工作的逻辑。
我们希望通过aop对这个类进行增强，调用这个方法的时候，当传入的用户名是路人的粉丝的的时候，需要先进行问候，其他用户的时候，无需问候，将这个问题的代码可以放在MethodBeforeAdvice中实现，这种情况就是当参数满足一定的条件了，才会使用这个通知，不满足的时候，通知无效，此时就可以使用上面的动态匹配来实现，MethodMatcher类中3个参数的matches方法可以用来对目标方法的参数做校验。
来看一下MethodMatcher过滤的整个过程
1.调用matches(Method method, Class<?> targetClass)方法，验证方法是否匹配
2.isRuntime方法是否为true，如果为false，则以第一步的结果为准，否则继续向下
3.调用matches(Method method, Class<?> targetClass, Object… args)方法继续验证，这个方法多了一个参数，可以对目标方法传入的参数进行校验。
通过上面的过程，大家可以看出来，如果isRuntime为false的时候，只需要对方法名称进行校验，当目标方法调用多次的时候，实际上第一步的验证结果是一样的，所以如果isRuntime为false的情况，可以将验证结果放在缓存中，提升效率，而spring内部就是这么做的，isRuntime为false的时候，需要每次都进行校验，效率会低一些，不过对性能的影响基本上可以忽略。
顾问(Advisor)
通知定义了需要做什么，切入点定义了在哪些类的哪些方法中执行通知，那么需要将他们2个组合起来才有效啊。
顾问（Advisor）就是做这个事情的。
Advisor接口
package org.springframework.aop;
import org.aopalliance.aop.Advice;
/**
* 包含AOP通知（在joinpoint处执行的操作）和确定通知适用性的过滤器（如切入点[PointCut]）的基本接口。
* 这个接口不是供Spring用户使用的，而是为了支持不同类型的建议的通用性。
*/
public interface Advisor {
/**
* 返回引用的通知
*/
Advice getAdvice();
}
上面这个接口通常不会直接使用，这个接口有2个子接口，通常我们会和这2个子接口来打交道，下面看一下这2个子接口。
PointcutAdvisor接口
通过名字就能看出来，这个和Pointcut有关，内部有个方法用来获取Pointcut，AOP使用到的大部分Advisor都属于这种类型的。
在目标方法中实现各种增强功能基本上都是通过PointcutAdvisor来实现的。
package org.springframework.aop;
/**
* 切入点类型的Advisor
*/
public interface PointcutAdvisor extends Advisor {
/**
* 获取顾问中使用的切入点
*/
Pointcut getPointcut();
}
IntroductionAdvisor接口
这个接口，估计大家比较陌生，干什么的呢？
一个Java类，没有实现A接口，在不修改Java类的情况下，使其具备A接口的功能。可以通过IntroductionAdvisor给目标类引入更多接口的功能，这个功能是不是非常牛逼。
案例
–
上面都是一些概念，看起来比较枯燥乏味，下面来个使用硬编码的方式来用一下上面提到的一些类或者接口，加深理解。
来个类
package com.javacode2018.aop.demo3;
public class UserService {
public void work(String userName) {
System.out.println(userName + “,正在和路人甲java一起学Spring Aop，欢迎大家一起来！”);
}
}
下面通过aop来实现一些需求，对work方法进行增强。
案例1
需求：在work方法执行之前，打印一句：你好：userName
下面直接上代码，注释比较详细，就不细说了。
@Test
public void test1() {
//定义目标对象
UserService target = new UserService();
//创建pointcut，用来拦截UserService中的work方法
Pointcut pointcut = new Pointcut() {
@Override
public ClassFilter getClassFilter() {
//判断是否是UserService类型的
return clazz -> UserService.class.isAssignableFrom(clazz);
}
@Override
public MethodMatcher getMethodMatcher() {
return new MethodMatcher() {
@Override
public boolean matches(Method method, Class<?> targetClass) {
//判断方法名称是否是work
return “work”.equals(method.getName());
}
@Override
public boolean isRuntime() {
return false;
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object… args) {
return false;
}
};
}
};
//创建通知，此处需要在方法之前执行操作，所以需要用到MethodBeforeAdvice类型的通知
MethodBeforeAdvice advice = (method, args, target1) -> System.out.println(“你好:” + args[0]);
//创建Advisor，将pointcut和advice组装起来
DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
//通过spring提供的代理创建工厂来创建代理
ProxyFactory proxyFactory = new ProxyFactory();
//为工厂指定目标对象
proxyFactory.setTarget(target);
//调用addAdvisor方法，为目标添加增强的功能，即添加Advisor，可以为目标添加很多个Advisor
proxyFactory.addAdvisor(advisor);
//通过工厂提供的方法来生成代理对象
UserService userServiceProxy = (UserService) proxyFactory.getProxy();
//调用代理的work方法
userServiceProxy.work(“路人”);
}
运行输出
你好:路人
路人,正在和路人甲java一起学Spring Aop，欢迎大家一起来！
上面是采用硬编码的方式来感受一下aop的用法，大家看了上面代码之后，估计会有疑问：我晕，这么复杂？？？
如果大家有使用过spring中的aop经验，可能只需要几行代码就实现了上面的功能，的确，spring中把整个功能简化了很多，不过我们得去了解他的内部是如何实现的，然后才能走的更远。
案例2
需求：统计一下work方法的耗时，将耗时输出
@Test
public void test2() {
//定义目标对象
UserService target = new UserService();
//创建pointcut，用来拦截UserService中的work方法
Pointcut pointcut = new Pointcut() {
@Override
public ClassFilter getClassFilter() {
//判断是否是UserService类型的
return clazz -> UserService.class.isAssignableFrom(clazz);
}
@Override
public MethodMatcher getMethodMatcher() {
return new MethodMatcher() {
@Override
public boolean matches(Method method, Class<?> targetClass) {
//判断方法名称是否是work
return “work”.equals(method.getName());
}
@Override
public boolean isRuntime() {
return false;
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object… args) {
return false;
}
};
}
};
//创建通知，需要拦截方法的执行，所以需要用到MethodInterceptor类型的通知
MethodInterceptor advice = new MethodInterceptor() {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println(“准备调用:” + invocation.getMethod());
long starTime = System.nanoTime();
Object result = invocation.proceed();
long endTime = System.nanoTime();
System.out.println(invocation.getMethod() + “，调用结束！”);
System.out.println(“耗时(纳秒):” + (endTime - starTime));
return result;
}
};
//创建Advisor，将pointcut和advice组装起来
DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
//通过spring提供的代理创建工厂来创建代理
ProxyFactory proxyFactory = new ProxyFactory();
//为工厂指定目标对象
proxyFactory.setTarget(target);
//调用addAdvisor方法，为目标添加增强的功能，即添加Advisor，可以为目标添加很多个Advisor
proxyFactory.addAdvisor(advisor);
//通过工厂提供的方法来生成代理对象
UserService userServiceProxy = (UserService) proxyFactory.getProxy();
//调用代理的work方法
userServiceProxy.work(“路人”);
}
运行输出
准备调用:public void com.javacode2018.aop.demo3.UserService.work(java.lang.String)
路人,正在和路人甲java一起学Spring Aop，欢迎大家一起来！
public void com.javacode2018.aop.demo3.UserService.work(java.lang.String)，调用结束！
耗时(纳秒):9526200
案例3
需求：userName中包含“粉丝”关键字，输出一句：感谢您一路的支持
此处需要用到 MethodMatcher 中的动态匹配了，通过参数来进行判断。
重点在于Pointcut中的getMethodMatcher方法，返回的MethodMatcher，@1必须返回true，此时才会进入到@2中对参数进行校验。
代码如下：
@Test
public void test2() {
//定义目标对象
UserService target = new UserService();
//创建pointcut，用来拦截UserService中的work方法
Pointcut pointcut = new Pointcut() {
@Override
public ClassFilter getClassFilter() {
//判断是否是UserService类型的
return clazz -> UserService.class.isAssignableFrom(clazz);
}
@Override
public MethodMatcher getMethodMatcher() {
return new MethodMatcher() {
@Override
public boolean matches(Method method, Class<?> targetClass) {
//判断方法名称是否是work
return “work”.equals(method.getName());
}
@Override
public boolean isRuntime() {
return true; // @1：注意这个地方要返回true
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object… args) {
// @2：isRuntime为true的时候，会执行这个方法
if (Objects.nonNull(args) && args.length == 1) {
String userName = (String) args[0];
return userName.contains(“粉丝”);
}
return false;
}
};
}
};
//创建通知，此处需要在方法之前执行操作，所以需要用到MethodBeforeAdvice类型的通知
MethodBeforeAdvice advice = (method, args, target1) -> System.out.println(“感谢您一路的支持!”);
//创建Advisor，将pointcut和advice组装起来
DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
//通过spring提供的代理创建工厂来创建代理
ProxyFactory proxyFactory = new ProxyFactory();
//为工厂指定目标对象
proxyFactory.setTarget(target);
//调用addAdvisor方法，为目标添加增强的功能，即添加Advisor，可以为目标添加很多个Advisor
proxyFactory.addAdvisor(advisor);
//通过工厂提供的方法来生成代理对象
UserService userServiceProxy = (UserService) proxyFactory.getProxy();
//调用代理的work方法
userServiceProxy.work(“粉丝：A”);
}
运行输出
感谢您一路的支持!
粉丝：A,正在和路人甲java一起学Spring Aop，欢迎大家一起来！
本文案例代码入口
com.javacode2018.aop.demo3.Test3
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
最后
文章中涉及到的知识点我都已经整理成了资料，录制了视频供大家下载学习，诚意满满，希望可以帮助在这个行业发展的朋友，在论坛博客等地方少花些时间找资料，把有限的时间，真正花在学习上，所以我把这些资料，分享出来。相信对于已经工作和遇到技术瓶颈的朋友们，在这份资料中一定都有你需要的内容。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
rviceProxy = (UserService) proxyFactory.getProxy();
//调用代理的work方法
userServiceProxy.work(“粉丝：A”);
}
运行输出
感谢您一路的支持!
粉丝：A,正在和路人甲java一起学Spring Aop，欢迎大家一起来！
本文案例代码入口
com.javacode2018.aop.demo3.Test3
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-sdej4vJv-1713338914829)]
[外链图片转存中…(img-KquGQHTF-1713338914829)]
[外链图片转存中…(img-7iTycir6-1713338914829)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
最后
文章中涉及到的知识点我都已经整理成了资料，录制了视频供大家下载学习，诚意满满，希望可以帮助在这个行业发展的朋友，在论坛博客等地方少花些时间找资料，把有限的时间，真正花在学习上，所以我把这些资料，分享出来。相信对于已经工作和遇到技术瓶颈的朋友们，在这份资料中一定都有你需要的内容。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
扫一扫
8112
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
