本章介绍的@Aspect拦截用的注解方式，对于想要实现多数据源切换，在指定类或方法上只需加上一个注解便可以实现入参出参日志打印的小伙伴，要认真看那一大堆有关Spring AOP支持的AspectJ切入点指示符的注释了。
使用 @Pointcut("@within(com.example.springboot.common.aspectj.LogAspect)") 就是在你想打日志的类上加上自定义注解@LogAspect；
使用 @Pointcut("@annotation(com.example.springboot.common.aspectj.LogAspect)") 就是在你想打日志的方法上加上自定义注解@LogAspect；
其他的指示符大家自行探索其中的奥秘吧，有需要改进的联系我哦！
1.第一步创建自定义注解
@LogAspect
package com.example.springboot.common.aspectj;
import java.lang.annotation.*;
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface LogAspect {
}
2.第二步在service层创建两个测试用的实现类,注意只在父类上加上了自定义注解@LogAspect,为什么继承Father的Child不加这个注解，这是为了同时测试这个注解是否具有被继承的效果。
Father.java
package com.example.springboot.service;
import com.example.springboot.common.aspectj.LogAspect;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@LogAspect
@Slf4j
@Service
public class Father {
public String eat(String food){
String f = food+"太好吃了吧！";
log.info("执行方法...");
return f;
}
}
Child.java
package com.example.springboot.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@Service
public class Child extends Father {
public String drink(String drink){
String d = drink+"太好喝了吧！";
log.info("执行方法...");
return d;
}
}
3.第三部在controller层创建测试类，注意不要与上一章（Spring AOP中@Aspect拦截介绍（一））测试的controller在同一个包下，因为这样会重复拦截，好奇心强的小伙伴可以试试
TestController.java
package com.example.springboot.cheng.controller;
import com.example.springboot.service.Child;
import com.example.springboot.service.Father;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/tc")
public class TestController {
@Autowired
private Father father;
@Autowired
private Child child;
/**
* 测试父类内方法是否打印日志
* @param name
* @return
*/
@GetMapping("/a01")
public String testa01(String name){
return father.eat(name);
}
/**
* 测试没有注解的子类内的方法是否打印日志
* @param name
* @return
*/
@GetMapping("/a02")
public String testa02(String name){
return child.drink(name);
}
}
4.最后一步，就是修改第一章（Spring AOP中@Aspect拦截介绍（一））中的拦截器了，就加了了切点拦截和一些注释，建议替换掉
注意：
@within：这个最后实现的效果是吧自定义注解加到类上，本章便是用的这个注解
@annotation这个最后实现的效果是吧自定义注解加到方法上
TestAspect.java
package com.example.springboot.common.aspectj;
import com.example.springboot.cheng.domain.User;
import com.example.springboot.common.core.domain.AjaxResult;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
/**
* @description 使用该切面拦截时，有两种方式,选择其中一种注掉另一种即可，建议使用第二种，因为可以拦截后修改传入参数：1.@Before+@After 2.@Around
* Spring AOP支持的AspectJ切入点指示符:
* execution：用于匹配方法执行的连接点；
* within：用于匹配指定类型内的方法执行；
* this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；
* target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；
* args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；
* @within：用于匹配所以持有指定注解类型内的方法；
* @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；
* @args：用于匹配当前执行的方法传入的参数持有指定注解的执行；
* @annotation：用于匹配当前执行方法持有指定注解的方法
* bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法；例如:bean(*Service) 匹配所有以Service命名（id或name）结尾的Bean
* reference pointcut：表示引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持。
*/
@Aspect
@Component
public class TestAspect {
private static final Logger logger = LoggerFactory.getLogger(TestAspect.class);
ThreadLocal<Long> startTime = new ThreadLocal<>();
/**
* 第一个*代表返回类型不限
* 第二个*代表所有类
* 第三个*代表所有方法
* (..) 代表参数不限
* com.example.springboot.controller 测试的controller层
*/
@Pointcut("execution(public * com.example.springboot.controller.*.*(..))")
public void pointCut(){};
/**
* 注解方式标注指定类或方法来执行拦截
*
*/
@Pointcut("@within(com.example.springboot.common.aspectj.LogAspect)")
public void pointCutAnnotation(){};
//@Before(value = "pointCut()")
public void before(JoinPoint joinPoint){
System.out.println("方法执行前执行......before");
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
logger.info("<=====================================================");
logger.info("请求来源： =》" + request.getRemoteAddr());
logger.info("请求URL：" + request.getRequestURL().toString());
logger.info("请求方式：" + request.getMethod());
logger.info("响应方法：" + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
logger.info("请求参数：" + Arrays.toString(joinPoint.getArgs()));
logger.info("连接点的方法签名对象："+joinPoint.getSignature());
logger.info("连接点所在的目标对象："+joinPoint.getTarget());
logger.info("代理对象："+joinPoint. getThis());
logger.info("------------------------------------------------------");
startTime.set(System.currentTimeMillis());
}
// 定义需要匹配的切点表达式，同时需要匹配参数
/**
* @description 要拦截修改参数的值只有使用这个方法，Around相当于before+after, AspectJ使用 且（&&）、或（||）、非（！）来组合切入点表达式。
* @param pjp
* @param arg 类型可以根据pointCut指定切点类下的方法确定，也可以使用统一的Object,也可以不写参数
* @return
* @throws Throwable
*/
@Around("pointCut()&& args(arg)")
public Object around(ProceedingJoinPoint pjp, Object arg) throws Throwable{
logger.info("入参：{}",arg);
logger.info("方法环绕start...around");
//修改入参
User user = (User)pjp.getArgs()[0];
user.setAge(user.getAge()-5);
Object[] objects = new Object[]{user};
Object object = pjp.proceed(objects);
logger.info("方法环绕end...around");
logger.info("出参：{}",object.toString());
return object;
}
@Around("pointCutAnnotation()&& args(arg)")
public Object aroundNo(ProceedingJoinPoint pjp, Object arg) throws Throwable{
logger.info("入参：{}",arg);
logger.info("方法环绕start...around");
Object object = pjp.proceed();
logger.info("方法环绕end...around");
logger.info("出参：{}",object.toString());
return object;
}
//@After("within(com.example.springboot.controller.*)")
public void after(){
System.out.println("方法之后执行...after.");
}
/**
*
* @param rst 该参数类型需要与测试的Controller层的返回值类型一致，否则不生效，也就是找不到
* 该测试中的AjaxResult是测试项目中封装好的出参
*/
//@AfterReturning(pointcut="pointCut()",returning = "rst")
public void afterRunning(AjaxResult rst){
if(startTime.get() == null){
startTime.set(System.currentTimeMillis());
}
System.out.println("方法执行完执行...afterRunning");
logger.info("耗时（毫秒）：" + (System.currentTimeMillis() - startTime.get()));
logger.info("返回数据：{}", rst);
logger.info("==========================================>");
}
@AfterThrowing("within(com.example.springboot.controller.*)")
public void afterThrowing(){
System.out.println("异常出现之后...afterThrowing");
}
}
5.使用postman测试（要看）
使用postman调用TestController中的两个方法，测试后发现子类继承了父类中的自定义注解@LogAspect。
第二步测试，去掉LogAspect类中的@Inherited注解，重新启动项目测试就会发现子类不再继承父类的自定义注解。
