Spring 实现AOP常见的两种方式（注解或者自定义注解）
第一种
导入AOP相关坐标(依赖冲突解决办法，将依赖中版本号删除，springboot会自动匹配合适的版本 )
<dependencies>
<!--spring核心依赖，会将spring-aop传递进来-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
<!--aspect: 切面, AOP；aspect-java -> aspectj-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
</dependencies>
切入点表达式标准格式：动作关键字（访问修饰符 返回值 包名。类/接口名.方法名（参数）异常名
execution(public User com.itheima.service.UserService.findById(int))
**- 动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
- 访问修饰符：public，private等，可以省略
- 返回值
- 包名
- 类/接口名
- 方法名
- 参数
- 异常名：方法定义中抛出指定异常，可以省略**
**- AOP切入点表达式
- 可以使用通配符描述切入点，快速描述
- ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现*
execution(public * com.itheima.*.UserService.find*(*))
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法。
… : 多个连续的任意符号，可以独立出现，常用语简化包名与参数的书写（参数一般使用…)
execution(public User com..UserService.findById(..))
匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法
+：专用于匹配子类类型
execution(* *..*Service+.*(..))
总结：
切入点表达式标准格式：动作关键字（访问修饰符 返回值 包名.类/接口名.方法名（参数）异常名）
* execution(* com.itheima.service.*Service.*(..))
切入点表达式描述通配符
作用：用于快速描述，范围描述
* : 匹配任意符号（常用）
.. : 匹配多个连续的任意符号（常用）
+ : 匹配子类类型
自定义注解的三个属性
1、@Target ElementType是一个枚举类型，它规范了注解的使用位置；
public enum ElementType {
/** 类, 接口 (包括注解类型), 或 枚举 声明 */
TYPE,
/** 字段声明（包括枚举常量） */
FIELD,
/** 方法声明(Method declaration) */
METHOD,
/** 正式的参数声明 */
PARAMETER,
/** 构造函数声明 */
CONSTRUCTOR,
/** 局部变量声明 */
LOCAL_VARIABLE,
/** 注解类型声明 */
ANNOTATION_TYPE,
/** 包声明 */
PACKAGE,
/**
* 类型参数声明
*
* @since 1.8
*/
TYPE_PARAMETER,
/**
* 使用的类型
*
* @since 1.8
*/
TYPE_USE
}
2、@Retention
RetentionPolicy这个枚举类型的常量描述保留注解的各种策略，它确定了注解的存活时间
public enum RetentionPolicy {
/**
* 注解只在源代码级别保留，编译时被忽略
*/
SOURCE,
/**
* 注解将被编译器在类文件中记录
* 但在运行时不需要JVM保留。这是默认的
* 行为.
*/
CLASS,
/**
*注解将被编译器记录在类文件中
*在运行时保留VM，因此可以反读。
* @see java.lang.reflect.AnnotatedElement
*/
RUNTIME
}
3、@Documented
这个注解表明将会被javadoc记录，如果类型声明被这个注解了，它将成为公共API的一部分。
第二步：在启动类上开启aop注解开发
第三步： 定义一个切面类
package com.test.easycodeauto.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
//设置切入点，@Pointcut注解要求配置在方法上方 监控业务层所有的方法
@Pointcut("execution(* com.test.easycodeauto.service.*Service.*(..))")
private void pt(){}
@Pointcut("execution(* com.test.easycodeauto.service.StudentService.queryById(..))")
private void pt1(){}
@Pointcut("execution(* com.test.easycodeauto.controller.StudentController.check*(..))")
private void pt2() {
}
@Around("pt2()")
public Object aroundCheck(ProceedingJoinPoint jpj) throws Throwable {
// 去除web层的参数空格
Object[] args = jpj.getArgs();
System.out.println(Arrays.toString(args));
for (int i = 0; i < args.length; i++) {
if(args[i].getClass().equals(String.class)) {
args[i] = args[i].toString().trim();
}
}
Object proceed = jpj.proceed(args);
return proceed;
}
/**
* 通过 JoinPoint 来拿参数,around通知 使用ProceedingJoinPint
*/
// @Before("pt1()")
public void before(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("before advice...");
}
// @After("pt1()")
public void after(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("after advide ...");
}
// @Around("pt1()")
public Object around(ProceedingJoinPoint jpj) throws Throwable {
Object[] args = jpj.getArgs();
System.out.println(Arrays.toString(args));
args[0] = "02";
Object proceed = jpj.proceed(args);
System.out.println("around advide ...");
return proceed;
}
// @AfterReturning("pt1()")
public void afterReturning() {
}
// @AfterThrowing("pt1()")
public void afterThrowing() {
}
//设置在切入点pt()的前面运行当前操作(前置通知)
@Around("pt()")
public void method(ProceedingJoinPoint pjp) throws Throwable {
// 获取执行签名信息
Signature signature = pjp.getSignature();
// 通过签名获取执行操作类型（接口名）
String className = signature.getDeclaringTypeName();
// 通过签名获取执行操作类型（方法名）
String methodName = signature.getName();
long start = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
pjp.proceed();
}
long end = System.currentTimeMillis();
System.out.println("测试业务侧接口"+className +"."+ methodName +"万次执行效率： "+ (end - start) + "ms");
}
}
第二种：基于自定义注解开发
第一种方式：
自定义注解
package com.test.easycodeauto.customaop.aop;
import java.lang.annotation.*;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TestAop {
String value() default "";
}
定义一个切面类
package com.test.easycodeauto.customaop.aop;
import com.test.easycodeauto.customaop.domain.Dept;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.HashMap;
@Component
@Aspect
@Slf4j
public class TestAopAspect {
@Pointcut("@annotation(com.test.easycodeauto.customaop.aop.TestAop)")
public void annotationPointcut(){}
/**
* 前置增强
* @param jp
*/
// @Before("annotationPointcut()")
public void beforePointCut(JoinPoint jp) {
// 此处进入方法前，可以实现一些业务逻辑
log.info("before...");
}
/**
* 后置增强
* @param jp
*/
// @After("annotationPointcut()")
public void afterPointCut(JoinPoint jp) {
// 此处进入方法，可以实现一些业务逻辑
log.info("after...");
}
@Around("annotationPointcut()")
public Object doAround(ProceedingJoinPoint jp) throws Throwable {
log.info("around...");
// 获取这个方法的注解的方法实例
MethodSignature signature = (MethodSignature) jp.getSignature();
Method method = signature.getMethod();
// 获取这个注解的信息
TestAop testAop = method.getAnnotation(TestAop.class);
// 输出这个方法上这个注解的属性信息
log.info(testAop.toString());
// 获取传入的参数
Object[] args = jp.getArgs();
// 获取传入的参数名称，是有序的数组对象
String[] argNames = signature.getParameterNames();
// 这个把参数名称和参数匹对
HashMap<String,Object> params = new HashMap<>();
for (int i = 0; i < argNames.length; i++) {
params.put(argNames[i],args[i]);
}
//通过使坏来改变参数一的值，即name的值
args[0] = "666";
// 通过反射的方式获取属性信息
Object proceed = jp.proceed(args);
// 通过使坏来改变运行结果
proceed = "Helo Wo";
return proceed;
}
}
使用方式：
package com.test.easycodeauto.customaop.service.impl;
import com.test.easycodeauto.customaop.aop.TestAop;
import com.test.easycodeauto.customaop.domain.Dept;
import com.test.easycodeauto.customaop.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Service
@Slf4j
public class DeptServiceImpl implements DeptService {
@Override
@TestAop(value="TEST_AOP")
public String testAop(String name, Dept dept) {
log.info(name);
log.info(dept.toString());
log.info("testAop");
return "testAop";
}
}
第二种方式：
自定义一个注解：
package com.test.easycodeauto.customaop.aop;
import java.lang.annotation.*;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyOperationLog {
// 方法名称
String methodName() default "";
// 当前操作人
String currentUser() default "";
// 操作
String operate() default "";
}
定义一个切面类：
package com.test.easycodeauto.customaop.aop;
import com.test.easycodeauto.customaop.domain.MyOperationLogVo;
import com.test.easycodeauto.customaop.service.LogService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Slf4j
@Component
@Aspect
public class MyLogAspect {
@Autowired
private LogService logService;
// 定义一个切入点
@Pointcut("@annotation(com.test.easycodeauto.customaop.aop.MyOperationLog)")
public void pt(){}
// 定义一个通知
@Before("pt()")
public void deBefore(JoinPoint joinPoint) {
log.info("before...");
// 获取自定义注解@MyOperationLog
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod();
if (null == method) {
return;
}
MyOperationLog myOperationLog = method.getAnnotation(MyOperationLog.class);
// 获取签名
String signa = joinPoint.getSignature().toString();
// 获取方法名
String methodName = signa.substring(signa.lastIndexOf(".") + 1, signa.indexOf("("));
String methodName1 = joinPoint.getSignature().getName();//获取目标方法的名称；
// 获取方法的execution
String longTemp = joinPoint.getStaticPart().toLongString();
//获取目标类的名称
String classType = joinPoint.getTarget().getClass().getName();
try{
Class<?> clazz = Class.forName(classType);
Method[] methods = clazz.getDeclaredMethods();
for (Method method1 : methods) {
if(method1.isAnnotationPresent(MyOperationLog.class)&& method1.getName().equals(methodName)) {
// 封装对象，可以进行一些业务逻辑
// 解析
MyOperationLogVo myOperationLogVos = parseAnnotation(method1);
// 日志添加
logService.addLog(myOperationLogVos);
}
}
}catch (Exception e) {
e.printStackTrace();
}
}
private MyOperationLogVo parseAnnotation(Method method) {
MyOperationLog myOperationLog = method.getAnnotation(MyOperationLog.class);
if (null == myOperationLog) {
return null;
}
MyOperationLogVo myOperationLogVo = new MyOperationLogVo();
myOperationLogVo.setMethodName(myOperationLog.methodName());
myOperationLogVo.setCurrentUser(myOperationLog.currentUser());
myOperationLogVo.setOperate(myOperationLog.operate());
return myOperationLogVo;
}
}
使用方式：
@RequestMapping("/controller")
@MyOperationLog(methodName = "testLog",currentUser = "admin",operate = "查询")
public String testLog() {
return "log";
}
