Java注解+AOP在项目中的使用

Java注解+AOP在项目中的使用

AOP思想在项目中经常能够体现到，最常见的例如我们设置的拦截器，自定义注解+切面类等，这里分享Java注解配合切面类在项目中使用的方式以及一些案例的分享：

1. 注解

Java注解又称为java标注，是在JDK5.0引入的一种注释机制。在Java程序中，无论是类，方法，变量还是包等都可以通过注解进行标注，然后可以通过反射获取标注的内容。

注解在编译器编译时被嵌入到字节码文件中，Java虚拟机将其保留下来，在运行时可以获取到对应的内容，同时支持开发人员自定义注解进行辅助开发。

1.1 内置的注解

java内置了7个注解，其中有3个存在于java.lang包中；还有四个存在于java.lang.annotation包中。

java.lang：

• @Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
• @Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
• @SuppressWarnings - 指示编译器去忽略注解中声明的警告。

java.lang.annotation：这四个注解又称为元注解，即修饰注解的注解

• @Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
• @Documented - 标记这些注解是否包含在用户文档中。
• @Target - 标记这个注解应该是哪种 Java 成员。
• @Inherited - 标记这个注解是继承于哪个注解类(默认 注解并没有继承于任何子类)

后面JDK迭代又新增了几个注解：

• @SafeVarargs - Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
• @FunctionalInterface - Java 8 开始支持，标识一个匿名函数或函数式接口。
• @Repeatable - Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

下面是Annotation接口的基本架构图：

点开Annotation接口的源码，主要有以下三个重要的类：

Annotation接口：

package java.lang.annotation;
public interface Annotation {

    boolean equals(Object obj);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}
1
2
3
4
5
6
7
8
9
10
11

ElementType枚举类：作用于@Target，表示该注解申明的目标作用位置

package java.lang.annotation;

public enum ElementType {
    TYPE,               /* 类、接口（包括注释类型）或枚举声明  */

    FIELD,              /* 字段声明（包括枚举常量）  */

    METHOD,             /* 方法声明  */

    PARAMETER,          /* 参数声明  */

    CONSTRUCTOR,        /* 构造方法声明  */

    LOCAL_VARIABLE,     /* 局部变量声明  */

    ANNOTATION_TYPE,    /* 注释类型声明  */

    PACKAGE             /* 包声明  */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

RetentionPolicy枚举类，作用于@Retention，表示注解的生命周期范围

package java.lang.annotation;
public enum RetentionPolicy {
    SOURCE,            /* Annotation信息仅存在于编译器处理期间，编译器处理完之后就没有该Annotation信息了  */

    CLASS,             /* 编译器将Annotation存储于类对应的.class文件中，即在 class 文件中有效。默认行为  */

    RUNTIME            /* 编译器将Annotation存储于class文件中，并且可由JVM读入，即在运行时有效 */
}
1
2
3
4
5
6
7
8

通过以上信息，可以归纳为以下几点：

• Annotation 就是个接口，每 1 个 Annotation 对象，都会有唯一的 RetentionPolicy 属性；ElementType 属性，则可以有 1~n 个
• ElementType 是 Enum 枚举类型，它用来指定 Annotation 的类型
• RetentionPolicy 是 Enum 枚举类型，它用来指定 Annotation 的策略-生命周期范围

1.2 自定义注解

通过上面的讲解，我们来自定义一个简单的注解

@Target(ElementType.METHOD)   
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnnotation {
  
  	String value1() default "";
    
    String value2() default "";
  
}
1
2
3
4
5
6
7
8
9
10
11

其中：

• @Target(ElementType.METHOD) 表示该注解作用在方法上
• @Retention(RetentionPolicy.RUNTIME)表示该注解在代码编译运行后依旧存在，可以被虚拟机读取
• @Documented表示修饰的注解类会被 JavaDoc 工具提取成文档
• @Inherited表示该注解具有继承属性

然后，我们定义一个Person类，里面的print方法上关联@MyAnnotation注解：

@Data
@AllArgsConstructor
public class Person {

    @MyAnnotation(value1 = "haha", value2 = "xixi")
    public void print(Integer age, String name) {
        System.out.println("person:{age= " + age + ",name= " + name + "}");
    }
}
1
2
3
4
5
6
7
8
9

最后，我们进行测试，通过反射获取Person类的方法进行执行，同时通过Person反射获取的方法Method获取对应的注解信息：

public class TestMyAnnotation {
    public static void main(String[] args) throws Exception {
        Person person = new Person();
        //通过反射获取person对象的方法
        Method method = person.getClass().getMethod("print", Integer.class, String.class);
        //执行对应的print方法
        method.invoke(person,new Object[]{15,"pag"});
        //从方法中获取注解信息
        getAnnotationByMethod(method);
    }

    private static void getAnnotationByMethod(Method method) {
        //首先判断该方法是否包含MyAnnotation注解
        if (method.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
            //再获取注解的属性值，进行输出打印
            String value1 = annotation.value1();
            String value2 = annotation.value2();
            System.out.println("value1: " + value1 + ",value2: " + value2);
        }
        //同时可以获取该方法的所有注解信息
        Annotation[] annotations = method.getAnnotations();
        for (Annotation annotation: annotations) {
            System.out.println(annotation);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

输出结果：

person:{age= 15,name= pag}
value1: haha,value2: xixi
@com.feng.study.annotation.MyAnnotation(value2=xixi, value1=haha)
1
2
3

2. AOP编程

AOP是Aspect Oriented Programming的缩写，意思是：面向切面编程，它是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，其中常见的术语有：

在下面的图例中，我们将UserService【target】中addUser()，updateUser()，deleteUser()方法作为JoinPoint。而我们可以通过AOP在这些方法中增加切面，实现面向切面编程。

回到上面自定义注解的例子，如果你想只要标注@MyAnnotation注解的方法在进行方法调用之前，都需要其他某一个流程步骤的处理，又不想将代码写到方法体内，就可以通过在这个注解上增加切面，实现AOP，将这一个流程步骤的处理代码写到切面编程代码中，这里我们首先引入aop的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>2.7.2</version>
  </dependency>
1
2
3
4
5

然后定义切面类：MyAnnotationAspect

@Component
@Aspect
@Slf4j
public class MyAnnotationAspect {
    
    @Pointcut("@annotation(com.feng.study.annotation.MyAnnotation)")
    public void myAnnotationAspect(){}
    
    @Before("myAnnotationAspect()")
    public void doBefore() {
        log.info("切面编程代码-逻辑实现");
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. AOP实现日志拦截

我们在使用日志的过程中，可以需要对于前端的请求到Controller层的请求参数，返回结果进行日志记录。此时我们可以通过AOP进行实现

@Aspect
@Component
@Slf4j
public class LogAspect {

    @Pointcut("execution(* com.tfblog.blog.controller.*.*(..))") //填写你自己需要拦截的controller方法路径
    
    public void log() {}

    @Before("log()")
    public void doBefore(JoinPoint joinPoint) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String url = request.getRequestURL().toString();
        String ip = request.getRemoteAddr();
        String classMethod = joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        RequestLog requestLog = new RequestLog(url, ip, classMethod, args);
        log.info("Request : {}", requestLog);
    }

    @After("log()")
    public void doAfter() {
    }

    @AfterReturning(returning = "result",pointcut = "log()")
    public void doAfterRuturn(Object result) {
        log.info("Result : {}", result);
    }

  	@Data
  	@AllArgsConstructor
    private class RequestLog {
        private String url;
        private String ip;
        private String classMethod;
        private Object[] args;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

4. 自定义注解 + 切面实现参数前置校验

这一部分可以参考之前写的博客分享：设计模式在参数校验中的实现