学习目标:

掌握注解的定义与使用
熟悉2个元注解的作用
掌握使用注解处理器获取注解信息

注解与注释#

注释

单行注释//
多行注释/* */
文档注释/** */

注释的作用:

传递额外的信息进行解释说明, 给程序员看的

注释不参与编译

1
注释只有语法形式, 具体内容没有要求
2
// 年龄在18-25之间, [18,25], 18<=age<=25
3
boolean judegeAge(int age){
4
}

什么是注解

Annotation其实是代码里的特殊标记，这些标记可以在编译、类加载、运行时被读取，并执行相应的处理

注解的作用

通过使用Annotation，程序开发人员可以在不改变原有逻辑的情况下，在源文件嵌入一些补充信息

Annotation就像修饰符一样被使用，可用于修饰类、构造器、方法、成员变量、参数…，这些信息被存储在Annotation的“属性名=属性值”对中

注解 VS 注释

相同点
- 都是用来传递额外信息的
不同点
- 注解可以参与编译,注释不行
- 注解有使用范围,注释没有(想咋写咋写)
- 注解作为一种数据类型,跟class interface具有同等地位

注解定义#

语法

1
权限修饰符 @interface 注解名字{
2
    // 注解体定义
3
    属性类型 属性名();
4
    属性类型 属性名();
5
    属性类型 属性名();
6
    ......
7
}
8
举例:
9
public @interface Override {
10
}
11

12
属性类型:
13
基本数据类型
14
String类型
15
Class类型
16
注解类型
17
枚举类型
18
以及以上类型的数组形式

注意:

注解不允许继承

注解和接口的关系：

注解和接口的定义都使用同一个关键字interface，而且注解体的定义也非常类似于接口中的抽象方法。

这当然不是巧合，而是因为注解本身就是一种特殊的接口。查看java.lang.annotation.Annotation接口的JDK文档，原文是：

所有注解类型都隐式扩展自该接口。但要注意，手动扩展该公共接口的接口不会定义为注解类型。还要注意此接口本身不是定义注解型。

也就是说：

当你使用”@interface”关键字定义一个注解类型时，它会自动实现java.lang.annotation.Annotation接口，即使你没有显式地声明这个继承关系。
如果使用”interface”关键字定义一个接口类型，并显式地让它继承java.lang.annotation.Annotation接口，那么这个新接口也不会被视为一个注解类型。
java.lang.annotation.Annotation接口本身并不是一个注解类型，它只是一个普通的接口类型。
注解类型并不能显式地继承其他类或接口，虽然它确实隐式实现了接口java.lang.annotation.Annotation~

当然，以上概念了解即可。虽然注解和接口确实共享了同一个关键字，但它们在实际使用中具有不同的目的和功能，可谓千差万别

元注解#

元注解的概念来源于元数据，什么是元数据呢？

图中框起来的一列数据是什么意思呢？表头的学校就负责解释这一列数据，所以这一列数据都代表某个学生的学校信息。

像“学校”这样的，用于解释数据的数据，就是元数据 meta data

元注解：描述修饰注解的注解（注解的注解）

常用元注解：

@Retention元注解，来定义我们自己定义的注解的保留级别.

RetentionPolicy.RUNTIME
RetentionPolicy.CLASS 默认
RetentionPolicy.SOURCE

@Target元注解，注解可以作用的目标

对于注解而言，可以作用的目标：

整个类 ElementType.TYPE
成员变量 ElementType.FIELD
构造方法 ElementType.CONSTRUCTOR
成员方法 ElementType.METHOD

注解的使用(重点)#

类比类对象

1
User user = new User("zs",20);
2
User user2 = new User();

使用的时候注解需要通过@符号进行实例化, 对每个属性都要赋值

1
@注解名(属性1=属性值,属性2=属性值)

解释：

”@“可以认为相当于“new”关键字，必不可少。
注解相当于给Java代码打上一个标签，所以它必须要修饰Java代码的一个结构。比如修饰一整个类，一整个方法，一个成员变量等等。
实例化注解时，必须给注解的各个属性赋值，赋值方式是：属性名 = 属性值。如果是数组类型的注解属性，用”{}“赋值。如果有多个属性，赋值时用”，“隔开。

注意事项:

每个属性都要赋值
可以不赋值,但是要有默认值, default
数组形式赋值 {}
如果只有1个属性, 名字叫value, 可以简化赋值
如果属性类型是引用类型, 不能是null

示例

1
@MyAnnotation
2
public class Test {
3
    @MyAnnotation(666)
4
    int num;
5

6
    @MyAnnotation(value = 777, b = "777", c = {"777","aaa","bb"})
7
    public void test() {
8
    }
9
}
10

11
@interface MyAnnotation {
12
    int value() default 123;
13

14
    String b() default "abc";
15

16
    String[] c() default {"123"};
17
}

注解处理器(难点)#

什么是注解处理器?

获取注解信息, 根据注解信息进行处理

如何获取注解信息?

通过反射获取注解信息

基本逻辑

获取注解所加的类的对应的Class对象

通过Class对象获取注解所加的类中的结构(Filed, Constructor, Method)对象

通过该结构对象判断是否使用了注解

通过该结构对象获取注解实例

通过注解实例获取注解信息

1
package _24annotation.com.cskaoyan._04handle;
2

3
import java.lang.annotation.ElementType;
4
import java.lang.annotation.Retention;
5
import java.lang.annotation.RetentionPolicy;
6
import java.lang.annotation.Target;
7
import java.lang.reflect.Method;
8

9
/**
10
 * @description:
11
 * @author: 景天
12
 * @date: 2022/10/24 17:41
13
 **/
14

15
public class Demo {
16
    public static void main(String[] args) throws Exception{
17
        // 获取字节码文件对象
18
        Class<?> c = Class.forName("_24annotation.com.cskaoyan._04handle.Demo");
19
        // 拿到方法对象
20
        Method loginMethod = c.getDeclaredMethod("login");
21
        // 判断方法上是否使用了注解
22
        boolean annotationPresent = loginMethod.isAnnotationPresent(Login.class);
23
        if (annotationPresent) {
24
            // 获取注解实例
25
            Login loginAnnotation = loginMethod.getAnnotation(Login.class);
26
            // 获取属性值
27
            String password = loginAnnotation.password();
28
            String username = lo
29
              ginAnnotation.username();
30
            // 打印
31
            System.out.println(password);
32
            System.out.println(username);
33

34
        }else {
35
            System.out.println("没有使用注解");
36
        }
37
    }
38

39
    @Login
40
    public static void login(){
41

42
    }
43
}
44

45
// 定义注解
46
@Retention(RetentionPolicy.RUNTIME)
47
@Target(ElementType.METHOD)
48
@interface Login{
49
    // 属性
50
    String username() default "admin";
51

52
    String password() default "123456";
53
}

练习:

通过创建自定义注解和注解处理器来实现对数据有效性的校验。

我们将创建一个名为 ValidateData 的注解，用于指定成员变量数据的最小长度、最大长度以及不满足条件时的报错信息。

然后，我们将编写一个注解处理器来实际执行这些校验。

步骤 1: 创建 Validated 注解

1
import java.lang.annotation.ElementType;
2
import java.lang.annotation.Retention;
3
import java.lang.annotation.RetentionPolicy;
4
import java.lang.annotation.Target;
5

6
@Retention(RetentionPolicy.RUNTIME)
7
@Target(ElementType.FIELD) // 应用于字段
8
public @interface Validated {
9
    int min() default 0;          // 最小长度，默认为 0
10

11
    int max() default Integer.MAX_VALUE; // 最大长度，默认为 Integer 的最大值
12

13
    String message() default "";  // 校验失败时的报错信息，默认为空
14
}

步骤2: 将注解加在目标成员变量

1
public class User {
2
    @Validated(min = 2,max = 5,message = "名字长度必须在2-5之间")
3
    private String name;
4

5
    @Validated(min = 18,max = 25,message = "年龄必须在18-25之间")
6
    private int age;
7

8
    public User(String name, int age) {
9
        this.name = name;
10
        this.age = age;
11
    }
12

13
}

步骤 3: 创建注解处理器

注解处理器将读取 ValidateData 注解的属性，并根据这些属性执行校验逻辑。

1
import java.lang.reflect.Field;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2023/11/14 11:44
7
 **/
8

9
public class ValidatedHandler {
10
    public static void validate(Object obj) throws IllegalAccessException {
11
        // 获取校验对象的Class对象
12
        Class<?> clazz = obj.getClass();
13
        // 获取所有成员变量并遍历 检查是否需要数据验证
14
        for (Field field : clazz.getDeclaredFields()) {
15
            // 是否使用了注解
16
            if (field.isAnnotationPresent(Validated.class)) {
17
                field.setAccessible(true);
18
                // 获取注解实例
19
                Validated validate = field.getAnnotation(Validated.class);
20
                // 获取成员变量取值
21
                Object value = field.get(obj);
22
                // 成员变量类型不确定 做个分类处理
23
                if (value instanceof String) {
24
                    // 对String类型的处理
25
                    checkStringLength((String) value, validate);
26
                } else if (value instanceof Object[]) {
27
                    // 对数组的处理
28
                    checkArrayLength((Object[]) value, validate);
29
                }else {
30
                    // 对数值类型的处理
31
                    checkIntRange(((int) value),validate);
32
                }
33
                // 可以添加对更多类型的支持
34
                // .....
35
            }
36
        }
37
    }
38

39
    private static void checkIntRange(int value, Validated validate) {
40
        if (value < validate.min() || value > validate.max()) {
41
            throw new IllegalArgumentException(validate.message());
42
        }
43
    }
44

45
    private static void checkStringLength(String value, Validated validate) {
46
        if (value.length() < validate.min() || value.length() > validate.max()) {
47
            throw new IllegalArgumentException(validate.message());
48
        }
49
    }
50

51

52
    private static void checkArrayLength(Object[] value, Validated validate) {
53
        if (value.length < validate.min() || value.length > validate.max()) {
54
            throw new IllegalArgumentException(validate.message());
55
        }
56
    }
57
}

步骤 4: 使用注解和处理器进行测试

1
/**
2
 * @description:
3
 * @author: 景天
4
 * @date: 2023/11/14 11:55
5
 **/
6

7
public class ValidatedTest {
8
    public static void main(String[] args) {
9
        User user = new User("zsss", 20);
10

11
        try {
12
            ValidatedHandler.validate(user);
13
            System.out.println("校验通过");
14
        } catch (IllegalAccessException e) {
15
            throw new RuntimeException(e);
16
        }
17
    }
18
}

注解的使用场景#

在 Java 中，注解被广泛应用于多种场景，提供了一种用于添加元数据到代码中的方式。注解不会直接影响代码的操作，但可以被工具、库和框架用于生成代码、进行编译时检查或在运行时处理。以下是一些常见的 Java 注解使用场景：

编译时检查：
- 用于提高代码质量，如 @Override 确保方法覆盖，@Deprecated 表示方法过时，@SuppressWarnings 抑制编译器警告。
框架和库：
- Web 框架如 Spring 使用注解来定义路由、请求方法、依赖注入等，例如 @Controller, @RequestMapping, @Autowired。
测试代码：
- 单元测试框架如 JUnit 使用注解定义测试方法、测试前后的操作，例如 @Test
代码生成：
- 自动生成代码，如 Lombok 库使用 @Getter, @Setter, @AllArgsConstructor 等注解来自动生成 getter、setter 方法和构造函数。
配置和设置：
- 在 Spring 和其他依赖注入框架中，用于配置和设置应用程序，如 @Configuration, @Bean。
拦截器和过滤器：
- 在 AOP（面向切面编程）中，用于定义切点和通知，如 @Aspect, @Before, @After。
自定义业务逻辑：
- 创建自定义注解来实现特定的业务逻辑，如验证、日志记录等。

Java 注解提供了一种强大的机制来简化代码、提高可读性和维护性，并支持诸如配置管理、数据校验和框架开发等高级功能。通过注解，开发者可以将关键信息嵌入到代码的声明性部分，而不是执行性代码中。

注解与注释#

注解定义#

元注解#

注解的使用(重点)#

注解处理器(难点)#

注解的使用场景#

文章分享

文章目录

Java 基础语法：注解

注解与注释#

注解定义#

元注解#

注解的使用(重点)#

注解处理器(难点)#

注解的使用场景#

文章分享

文章目录