springaop——AspectJ不可不知的细节
springaop简介
springaop是spring对AOP技术的具体实现，它是spring框架的核心技术。springaop底层使用JDK动态代理或CGLIB动态代理技术实现。
应用场景：
在多个方法中执行相同操作且和当前业务没有直接关系的逻辑，我们可以单独抽离出来。并通过aop技术为目标方法扩展实现。
如：
1）记录总日志流水
2）权限控制
3）事物管理
...
一、springaop——aspectJ详细讲解
1、aspectJ常用注解
1）@Pointcut
切点：简单理解就是一个匹配条件、规则，与切点函数组合使用。
2）@Before
前置增强：在目标方法执行前，增加执行逻辑。
为了方便理解@Pointcut及@Before，我们举个栗子：
2.1）定义一个ZeroService接口
public interface ZeroService {
void findOne();
void addZero(String id);
void deleteZero(String id);
void updateZero(String id);
void queryZero(String id);
}
2.2）增加一个实现类ZeroServiceImpl
@Service
public class ZeroServiceImpl implements ZeroService{
@Override
public void findOne() {
LogUtil.info("execute findOne()~~~");
}
@Override
public void addZero(String id) {
LogUtil.info("execute addZero(id="+id+")~~~");
if("123".equals(id)){
throw new RuntimeException("模拟异常！");
}
}
@Override
public void deleteZero(String id) {
LogUtil.info("execute deleteZero(id="+id+")~~~");
if("123".equals(id)){
throw new RuntimeException("模拟异常！");
}
}
@Override
public void updateZero(String id) {
LogUtil.info("execute updateZero(id="+id+")~~~");
if("123".equals(id)){
throw new RuntimeException("模拟异常！");
}
}
@Override
public void queryZero(String id) {
LogUtil.info("execute queryZero(id="+id+")~~~");
if("123".equals(id)){
throw new RuntimeException("模拟异常！");
}
}
}
2.3）增加一个切点函数类
@Aspect
@Component
public class ZeroAop {
@Pointcut("execution(* com.lianjinsoft.springaop.service.ZeroService.findOne(..))")
private void condition(){
}
@Before("condition()")
private void before(){
LogUtil.info("execute before method~~~");
}
}
condition方法，定义了一个切点，匹配com.lianjinsoft.springaop.service.ZeroService.findOne方法。
before方法，定义了一个前置增强，匹配条件引用了condition方法。即为ZeroService.findOne方法，增加一个前置执行方法。
2.4）通过Junit测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class ZeroServiceTests {
@Autowired
private ZeroService service;
@Test
public void test_before() {
service.findOne();
}
}
2.4.1）执行test_before()方法
15:01:12.237 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 15200 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:01:12.237 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:01:12.268 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:01:12 CST 2018]; root of context hierarchy 15:01:12.905 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.876 seconds (JVM running for 1.604) 15:01:12.938 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute before method~~~ 15:01:12.938 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute findOne()~~~ 15:01:12.941 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:01:12 CST 2018]; root of context hierarchy
从日志的第5、6行可以看出，在执行ZeroService.findOne()方法之前，先执行了ZeroAop.before()方法。
3）@AfterReturning
后置增强：在目标方法执行后，增加执行逻辑（若目标方法抛出异常，则不执行增强逻辑）。
继续举栗子：
3.1）在ZeroAop类中增加切点
@AfterReturning("execution(* com.lianjinsoft.springaop.service.ZeroService.addZero(..))")
private void afterReturning(){
LogUtil.info("execute afterReturning method~~~");
}
3.2）在ZeroServiceTests类中增加测试方法
@Test
public void test_afterReturning() {
service.addZero("666");
}
@Test
public void test_afterReturning_exception() {
service.addZero("123");
}
3.2.1）执行test_afterReturning方法
15:01:43.617 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 1420 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:01:43.617 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:01:43.638 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:01:43 CST 2018]; root of context hierarchy 15:01:44.181 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.766 seconds (JVM running for 1.504) 15:01:44.215 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute addZero(id=666)~~~ 15:01:44.216 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute afterReturning method~~~ 15:01:44.219 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:01:43 CST 2018]; root of context hierarchy
从日志的第5、6行可以看出，在执行ZeroService.addZero()方法之后，执行了ZeroAop.afterReturning()方法。
3.2.2）执行test_afterReturning_exception方法
15:01:53.984 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 19052 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:01:53.984 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:01:54.006 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:01:54 CST 2018]; root of context hierarchy 15:01:54.553 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.773 seconds (JVM running for 1.509) 15:01:54.586 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute addZero(id=123)~~~ 15:01:54.593 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:01:54 CST 2018]; root of context hierarchy
从日志的第5、6行可以看出，在执行ZeroService.addZero()方法之后，没有输出增强方法中的信息，即当目标方法抛出异常时，不会执行增强方法中的逻辑。
4）@Around
环绕增强：在目标方法执行前和执行后，增加执行逻辑。
再举个例子：
4.1）在ZeroAop类中增加切点
@Around("execution(* com.lianjinsoft.springaop.service.ZeroService.deleteZero(..))")
private void around(ProceedingJoinPoint point) throws Throwable{
LogUtil.info("execute around method start~~~");
point.proceed();
LogUtil.info("execute around method end~~~");
}
4.2）在ZeroServiceTests类中增加测试方法
@Test
public void test_around() {
service.deleteZero("666");
}
@Test
public void test_around_exception() {
service.deleteZero("123");
}
4.2.1）执行test_around方法
15:02:07.355 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 12384 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:02:07.357 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:02:07.388 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:07 CST 2018]; root of context hierarchy 15:02:07.924 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.788 seconds (JVM running for 1.525) 15:02:07.960 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute around method start~~~ 15:02:07.960 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute deleteZero(id=666)~~~ 15:02:07.960 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute around method end~~~ 15:02:07.964 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:07 CST 2018]; root of context hierarchy
从日志的第5、6、7行可以看出，在执行ZeroService.deleteZero()方法前后，分别输出了ZeroAop.around()增强方法中的调试信息。
4.2.2）执行test_around_exception方法
15:02:20.132 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 2056 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:02:20.132 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:02:20.156 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:20 CST 2018]; root of context hierarchy 15:02:20.698 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.774 seconds (JVM running for 1.525) 15:02:20.731 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute around method start~~~ 15:02:20.732 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute deleteZero(id=123)~~~ 15:02:20.738 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:20 CST 2018]; root of context hierarchy
从日志的第5、6、7行可以看出，在执行ZeroService.deleteZero()方法前，输出了增强方法中的调试信息。而在ZeroService.deleteZero()方法执行后，没有输出增强方法中的调试信息。即说明当目标方法抛出异常时，环绕增强方法中的后续逻辑不会执行。
如何保证让环绕增强后的逻辑继续执行？手动加上异常处理即可。
5）@AfterThrowing
后置增强：what？还有一个后置增强？是的，这个后置增强和@AfterReturning增强相对应。只会在目标方法抛出异常时执行。
举个栗子：
5.1）在ZeroAop类中增加切点
@AfterThrowing("execution(* com.lianjinsoft.springaop.service.ZeroService.updateZero(..))")
private void afterThrowing(){
LogUtil.info("execute afterThrowing method~~~");
}
5.2）在ZeroServiceTests类中增加测试方法
@Test
public void test_afterThrowing() {
service.updateZero("666");
}
@Test
public void test_afterThrowing_exception() {
service.updateZero("123");
}
5.2.1）执行test_afterThrowing方法
15:02:33.418 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 4920 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:02:33.418 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:02:33.443 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:33 CST 2018]; root of context hierarchy 15:02:34.009 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.796 seconds (JVM running for 1.517) 15:02:34.042 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute updateZero(id=666)~~~ 15:02:34.046 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:33 CST 2018]; root of context hierarchy
从日志的第5、6行可以看出，在执行ZeroService.updateZero()方法后，没有输出了ZeroAop.afterThrowing()增强方法中的调试信息。
5.2.2）执行test_afterThrowing_exception方法
15:02:45.049 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 16904 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:02:45.049 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:02:45.079 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:45 CST 2018]; root of context hierarchy 15:02:45.643 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.802 seconds (JVM running for 1.549) 15:02:45.674 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute updateZero(id=123)~~~ 15:02:45.675 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute afterThrowing method~~~ 15:02:45.681 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:45 CST 2018]; root of context hierarchy
从日志的第5、6行可以看出，在执行ZeroService.updateZero()方法后，输出了ZeroAop.afterThrowing()增强方法中的调试信息。即当目标方法中抛出异常时，才会触发afterThrowing后置增强。
6）@After
后置增强：纳尼？还有一个后置增强？还有吗？没有了，这是终结版。那和上面的两个后置增强又有什么区别呢？@After增强始终会被执行（不管目标方法是否抛出异常）。
再举个栗子：
6.1）在ZeroAop类中增加切点
@After("execution(* com.lianjinsoft.springaop.service.ZeroService.queryZero(..))")
private void after(){
LogUtil.info("execute after method~~~");
}
6.2）在ZeroServiceTests类中增加测试方法
@Test
public void test_after() {
service.queryZero("666");
}
@Test
public void test_after_exception() {
service.queryZero("123");
}
6.2.1）执行test_after方法
15:02:57.113 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 20348 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:02:57.114 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:02:57.139 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:57 CST 2018]; root of context hierarchy 15:02:57.677 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.771 seconds (JVM running for 1.499) 15:02:57.708 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute queryZero(id=666)~~~ 15:02:57.709 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute after method~~~ 15:02:57.713 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:02:57 CST 2018]; root of context hierarchy
从日志的第5、6行可以看出，在执行ZeroService.queryZero()方法后，输出了ZeroAop.after()增强方法中的调试信息。
6.2.2）执行test_after_exception方法
15:03:06.697 [main] INFO c.l.springaop.aop.ZeroServiceTests - Starting ZeroServiceTests on LAPTOP-1DF7S904 with PID 11540 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 15:03:06.697 [main] INFO c.l.springaop.aop.ZeroServiceTests - No active profile set, falling back to default profiles: default 15:03:06.725 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:03:06 CST 2018]; root of context hierarchy 15:03:07.280 [main] INFO c.l.springaop.aop.ZeroServiceTests - Started ZeroServiceTests in 0.79 seconds (JVM running for 1.53) 15:03:07.313 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute queryZero(id=123)~~~ 15:03:07.314 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute after method~~~ 15:03:07.321 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@7c9d8e2: startup date [Mon Apr 16 15:03:06 CST 2018]; root of context hierarchy
从日志的第5、6行可以看出，在执行ZeroService.queryZero()方法后，也输出了ZeroAop.after()增强方法中的调试信息。说明@after后置增强的方法，始终会被执行。
2.函数通配符
@AspectJ支持三种通配符
*：匹配任意字符，但是只能匹配一层或一个元素。
..：匹配任意字符，可以匹配一个或多个元素。在表示类时必须和*组合使用，在表示方法入参时可以单独使用。
+：匹配类型，可以匹配指定类型及子类（实现类）。
3.逻辑运算符
&&（and）：与运算符，计算切点的交集。由于&是xml中的特殊字符，所以需要使用转义字符&表示。spring为了方便使用，增加了and运算符。与&&等价。
||（or）：或运算符，计算切点的并集。spring也增加了一个直观的运算符or。与||等价。
!：非运算符，计算切点的反集。spring同样也增加了一个直观的运算符not。与!等价。
4.常用切点表达式函数
1）方法切点函数
1.1）execution()：最常用的切点函数，匹配方法层。
小二，上一盘栗子！好勒~
@Before("execution(* com.lianjinsoft.springaop.service.ExecutionService.find*(..))")
解释：前置增强，匹配com.lianjinsoft.springaop.service.ExecutionService类中，所有以find开头的方法。
@Before("execution(* com..ExecutionService.add*(String))")
解释：前置增强，匹配com包及子包中，所有ExecutionService类中包含add开头的方法，并且方法的入参为String类型。
@Before("execution(* *.remove*(..))")
解释：前置增强，匹配所有包中，包含所有remove开头的方法。
@Before("execution(* *.modify*(java.util.Map))")
解释：前置增强，匹配所有包中，以modify开头的方法，并且方法的入参为java.util.Map
@Before("execution(* *.get*(java.util.Map+))")
解释：前置增强，匹配所有包中，以get开头的方法，并且方法的入参为java.util.Map或为java.util.Map的子类（实现类）。
注意：当需要匹配方法的入参类型时，除了jdk自带的基本类型及String可以在匹配规则中使用简写。其他类型，必须使用类型的完整路径。
测试案例？请执行ExecutionServiceTests类中的方法，查看增强结果。
1.2）@annotation()：注解切点函数，匹配被标注指定注解的方法。
废话少说，上栗子！
老板，心急吃不了热栗子，您容我再唠叨几句~
首先我们说一下使用场景，通常使用该切点函数，是我们需要对一些特定的方法或者没有太多规律的方法进行增强。
好，那么我们可以通过在这些方法上增加注解（标记），然后通过注解切点函数，来匹配这些方法进行增强。
1.2.1）增加一个注解类（自定义注解）
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface VerifySign {
String note();
}
1.2.2）增加一个业务接口
public interface AnnotationService {
void paymentNotify(String msg);
void refundNotify(String msg);
}
1.2.3）增加一个业务实现类
@Service
public class AnnotationServiceImpl implements AnnotationService{
@VerifySign(note="需要验证数据签名")
@Override
public void paymentNotify(String msg) {
LogUtil.info("execute paymentNotify(msg="+msg+")~~~");
}
@Override
public void refundNotify(String msg) {
LogUtil.info("execute refundNotify(msg="+msg+")~~~");
}
}
1.2.4）增加一个注解切点函数类
@Aspect
@Component
public class AnnotationAop {
@Before("@annotation(com.lianjinsoft.springaop.annotation.VerifySign)")
private void verify(){
LogUtil.info("execute verify method~~~");
}
}
1.2.5）增加单元测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class AnnotationServiceTests {
@Autowired
private AnnotationService service;
@Test
public void test_paymentNotify() {
service.paymentNotify("支付结果通知");
}
@Test
public void test_refundNotify() {
service.refundNotify("退货结果通知");
}
}
1.2.5.1）执行test_paymentNotify测试方法
10:13:38.536 [main] INFO c.l.s.aop.AnnotationServiceTests - Starting AnnotationServiceTests on LAPTOP-1DF7S904 with PID 15736 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 10:13:38.537 [main] INFO c.l.s.aop.AnnotationServiceTests - No active profile set, falling back to default profiles: default 10:13:38.562 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@3d34d211: startup date [Tue Apr 17 10:13:38 CST 2018]; root of context hierarchy 10:13:39.224 [main] INFO c.l.s.aop.AnnotationServiceTests - Started AnnotationServiceTests in 0.908 seconds (JVM running for 1.649) 10:13:39.274 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute verify method~~~ 10:13:39.274 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute paymentNotify(msg=支付结果通知)~~~ 10:13:39.280 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@3d34d211: startup date [Tue Apr 17 10:13:38 CST 2018]; root of context hierarchy
从输出日志的第5、6行可以看出，在执行AnnotationService.paymentNotify()方法前，执行了AnnotationAop.verify()增强方法。
1.2.5.2）执行test_refundNotify测试方法
10:13:55.752 [main] INFO c.l.s.aop.AnnotationServiceTests - Starting AnnotationServiceTests on LAPTOP-1DF7S904 with PID 16200 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 10:13:55.752 [main] INFO c.l.s.aop.AnnotationServiceTests - No active profile set, falling back to default profiles: default 10:13:55.772 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@3d34d211: startup date [Tue Apr 17 10:13:55 CST 2018]; root of context hierarchy 10:13:56.437 [main] INFO c.l.s.aop.AnnotationServiceTests - Started AnnotationServiceTests in 0.884 seconds (JVM running for 1.635) 10:13:56.471 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute refundNotify(msg=退货结果通知)~~~ 10:13:56.475 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@3d34d211: startup date [Tue Apr 17 10:13:55 CST 2018]; root of context hierarchy
从输出日志的第4、5行可以看出，在执行AnnotationService.refundNotify()方法前，没有执行AnnotationAop.verify()增强方法。
2）方法入参切点函数
2.1）args()：匹配目标方法的入参条件（即匹配方法入参类型，又匹配入参类型的子类、实现类）。
小二，快上栗子。好的，老板~
2.1.1）增加一个业务接口
public interface ArgsService {
void insertObject(Set<String> obj);
void insertObject(List<String> obj);
void insertObject(Queue<String> obj);
void insertObject(Map<String,String> obj);
}
2.1.2）增加一个业务实现类
@Service
public class ArgsServiceImpl implements ArgsService{
@Override
public void insertObject(Set<String> obj) {
LogUtil.info("execute insertObject(Set<String> obj)~~~");
}
@Override
public void insertObject(List<String> obj) {
LogUtil.info("execute insertObject(List<String> obj)~~~");
}
@Override
public void insertObject(Queue<String> obj) {
LogUtil.info("execute insertObject(Queue<String> obj)~~~");
}
@Override
public void insertObject(Map<String, String> obj) {
LogUtil.info("execute insertObject(Map<String, String> obj)~~~");
}
}
2.1.3）增加一个切点函数类
本案例中使用了两个条件，通过and逻辑运算符关联。
匹配com.lianjinsoft包及子包中，所有类中的方法包含一个入参为java.util.Collection或java.util.Collection的子类（实现类）
@Aspect
@Component
public class ArgsAop {
@Before("execution(* com.lianjinsoft..*(..)) and args(java.util.Collection)")
private void args(){
LogUtil.info("execute args method~~~");
}
}
2.1.4）增加单元测试类
@RunWith(SpringRunner.class)
@SpringBootTest
public class ArgsServiceTests {
@Autowired
private ArgsService service;
@Test
public void test_service() {
Set<String> set = new HashSet<>();
service.insertObject(set);
List<String> list = new ArrayList<>();
service.insertObject(list);
Queue<String> queue = new LinkedBlockingQueue<>();
service.insertObject(queue);
Map<String,String> map = new HashMap<>();
service.insertObject(map);
}
}
2.1.4.1）执行test_service()测试方法
10:29:28.664 [main] INFO c.l.springaop.aop.ArgsServiceTests - Starting ArgsServiceTests on LAPTOP-1DF7S904 with PID 12536 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 10:29:28.665 [main] INFO c.l.springaop.aop.ArgsServiceTests - No active profile set, falling back to default profiles: default 10:29:28.689 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@4009e306: startup date [Wed Apr 18 10:29:28 CST 2018]; root of context hierarchy 10:29:29.491 [main] INFO c.l.springaop.aop.ArgsServiceTests - Started ArgsServiceTests in 1.036 seconds (JVM running for 1.788) 10:29:29.543 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute args method~~~ 10:29:29.543 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute insertObject(Set<String> obj)~~~ 10:29:29.544 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute args method~~~ 10:29:29.544 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute insertObject(List<String> obj)~~~ 10:29:29.545 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute args method~~~ 10:29:29.545 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute insertObject(Queue<String> obj)~~~ 10:29:29.545 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute insertObject(Map<String, String> obj)~~~ 10:29:29.554 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@4009e306: startup date [Wed Apr 18 10:29:28 CST 2018]; root of context hierarchy
从输出日志的第5~11行可以看出，insertObject入参为Set、List、Queue的方法都被增强了。只有入参为Map的方法没有增强（因为Map没有继承Collection接口）。
注意：
execution切点函数匹配的入参条件默认是绝对匹配，那想要实现和当前案例一样的效果，需要怎么操作呢？
很简单，通过函数通配符“+”实现：
@Before("execution(* com.lianjinsoft..*(java.util.Collection+))")
2.2）@args()：注解匹配函数，匹配目标方法的入参。
该函数与args使用方法类似，args匹配方法入参的类型为普通类（接口、抽象类）。而@args匹配的方法入参类型必须为注解类。
小二！小二！人呢？
咳咳..小二放假度蜜月去了..
3）目标类切点函数
3.1）within()：类切点函数，最小匹配层级为类
栗子在哪里？来了，老板。
3.1.1）增加一个业务接口
public interface WithinService {
void saveObject();
void deleteObject();
void updateObject();
void queryObject();
}
3.1.2）增加一个业务实现类
@Service
public class WithinServiceImpl implements WithinService{
@Override
public void saveObject() {
LogUtil.info("execute saveObject()~~~");
}
@Override
public void deleteObject() {
LogUtil.info("execute deleteObject()~~~");
}
@Override
public void updateObject() {
LogUtil.info("execute updateObject()~~~");
}
@Override
public void queryObject() {
LogUtil.info("execute queryObject()~~~");
}
}
3.1.3）增加一个切点函数类
匹配com.lianjinsoft包及子包下，所有Within开头的类中的方法。
@Aspect
@Component
public class WithinAop {
@Before("within(com.lianjinsoft..Within*)")
private void within(){
LogUtil.info("execute within method~~~");
}
}
3.1.4）增加一个测试类
@RunWith(SpringRunner.class)
@SpringBootTest
public class WithinServiceTests {
@Autowired
private WithinService service;
@Test
public void test_service() {
service.saveObject();
service.deleteObject();
service.updateObject();
service.queryObject();
}
}
3.1.4.1）执行test_service()测试方法
11:19:39.492 [main] INFO c.l.springaop.aop.WithinServiceTests - Starting WithinServiceTests on LAPTOP-1DF7S904 with PID 8612 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 11:19:39.492 [main] INFO c.l.springaop.aop.WithinServiceTests - No active profile set, falling back to default profiles: default 11:19:39.518 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@587e5365: startup date [Wed Apr 18 11:19:39 CST 2018]; root of context hierarchy 11:19:40.259 [main] INFO c.l.springaop.aop.WithinServiceTests - Started WithinServiceTests in 1.036 seconds (JVM running for 1.827) 11:19:40.321 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute within method~~~ 11:19:40.321 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute saveObject()~~~ 11:19:40.321 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute within method~~~ 11:19:40.321 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute deleteObject()~~~ 11:19:40.321 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute within method~~~ 11:19:40.322 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute updateObject()~~~ 11:19:40.322 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute within method~~~ 11:19:40.322 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute queryObject()~~~ 11:19:40.330 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@587e5365: startup date [Wed Apr 18 11:19:39 CST 2018]; root of context hierarchy
从输出的日志第5~12行可以看出，WithinService类中的所有方法均被增强。
within切点函数匹配的是类层面，即会将命中目标类中的所有方法增强（除私有方法）。
注意：该函数只匹配目标对象，不匹配运行时对象。若匹配条件为父类，那么调用子类方法时不会被增强。
3.2）@within() 和 @target()：这两个切点函数也是注解切点函数，但是匹配的注解是类的应用层。
@within()：匹配被标注的指定类及子孙类（实现类）中所有的方法。
@target()：匹配被标注的指定类中的所有方法（不包含子孙类）。
如图：
图一为@within示例图，当T1标注了@M注解，那么T1、T2(子类)、T3(孙类)都被匹配。
图二为@target示例图，当T1标注了@M注解，那么只有T1类会被匹配。
3.3）target()：类切点函数，最小匹配层级为类。
那么target()函数和within()函数有什么区别？
target函数不仅匹配目标类中的所有方法，而且会匹配子孙类中的所有方法（除私有方法），也就说会包含父类中没有的方法。
快！快上栗子！！喳~
3.3.1）增加两个业务接口，并实现继承关系
public interface TargetParentService {
void saveObject();
void deleteObject();
void updateObject();
void queryObject();
}
public interface TargetChildService extends TargetParentService{
void queryAll();
}
3.3.2）增加一个业务实现类
@Service
public class TargetServiceImpl implements TargetChildService{
@Override
public void saveObject() {
LogUtil.info("execute saveObject()~~~");
}
@Override
public void deleteObject() {
LogUtil.info("execute deleteObject()~~~");
}
@Override
public void updateObject() {
LogUtil.info("execute updateObject()~~~");
}
@Override
public void queryObject() {
LogUtil.info("execute queryObject()~~~");
}
@Override
public void queryAll() {
LogUtil.info("execute queryAll()~~~");
}
}
3.3.3）增加一个切点函数类
注意：target函数必须输入类的绝对路径，不支持通配符。
@Aspect
@Component
public class TargetAop {
@Before("target(com.lianjinsoft.springaop.service.TargetParentService)")
private void target(){
LogUtil.info("execute target method~~~");
}
}
3.3.4）增加一个测试类
@RunWith(SpringRunner.class)
@SpringBootTest
public class TargetServiceTests {
@Autowired
private TargetParentService service;
@Test
public void test_service() {
service.saveObject();
service.deleteObject();
service.updateObject();
service.queryObject();
((TargetChildService)service).queryAll();
}
}
3.3.4.1）执行test_service()测试方法
12:30:40.431 [main] INFO c.l.springaop.aop.TargetServiceTests - Starting TargetServiceTests on LAPTOP-1DF7S904 with PID 11928 (started by lianjinsoft in E:\workspace\springboot\spring-aop) 12:30:40.432 [main] INFO c.l.springaop.aop.TargetServiceTests - No active profile set, falling back to default profiles: default 12:30:40.465 [main] INFO o.s.c.a.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@2de23121: startup date [Wed Apr 18 12:30:40 CST 2018]; root of context hierarchy 12:30:41.433 [main] INFO c.l.springaop.aop.TargetServiceTests - Started TargetServiceTests in 1.247 seconds (JVM running for 2.051) 12:30:41.497 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute target method~~~ 12:30:41.498 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute saveObject()~~~ 12:30:41.498 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute target method~~~ 12:30:41.498 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute deleteObject()~~~ 12:30:41.498 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute target method~~~ 12:30:41.498 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute updateObject()~~~ 12:30:41.499 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute target method~~~ 12:30:41.499 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute queryObject()~~~ 12:30:41.499 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute target method~~~ 12:30:41.499 [main] INFO c.lianjinsoft.springaop.util.LogUtil - execute queryAll()~~~ 12:30:41.536 [Thread-2] INFO o.s.c.a.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@2de23121: startup date [Wed Apr 18 12:30:40 CST 2018]; root of context hierarchy
从输出日志的第5~14行可以看出，TargetParentService及TargetChildService类中的方法均被增强了。
总结：
springaop为我们提供了很多增强函数，通过不同的匹配规则、组合方式可以实现我们日常需求。
本文采用springboot作为项目基础运行环境，也是spring主推的开发模式。
本文演示源代码：https://gitee.com/skychenjiajun/spring-all
