自定义注解

最新推荐文章于 2024-06-29 03:30:33 发布
最新推荐文章于 2024-06-29 03:30:33 发布
阅读量309 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35599414/article/details/112918624
版权

一、官方对注解的说明：

注解是一种能被添加到java代码中的元数据，类、方法、变量、参数和包都可以用注解来修饰。注解对于它所修饰的代码并没有直接的影响。

二、通过官方描述得出以下结论：

  1. 注解是一种元数据形式。即注解是属于java的一种数据类型，和类、接口、数组、枚举类似。
  2. 注解用来修饰，类、方法、变量、参数、包。
  3. 注解不会对所修饰的代码产生直接的影响。

三、官方对于注解的使用范围：

注解有许多用法，其中有：为编译器提供信息 - 注解能被编译器检测到错误或抑制警告。编译时和部署时的处理 - 软件工具能处理注解信息从而生成代码，XML文件等等。运行时的处理 - 有些注解在运行时能被检测到。

四、注解的流程：

基于上一节，已对注解有了一个基本的认识：注解其实就是一种标记，可以在程序代码中的关键节点（类、方法、变量、参数、包）上打上这些标记，然后程序在编译时或运行时可以检测到这些标记从而执行一些特殊操作。因此可以得出自定义注解使用的基本流程：

  • 第一步，定义注解——相当于定义标记；
  • 第二步，配置注解——把标记打在需要用到的程序代码中；
  • 第三步，解析注解——在编译期或运行时检测到标记，并进行特殊操作。

五、基本语法

1、注解类型的声明部分：

注解在Java中，与类、接口、枚举类似，因此其声明语法基本一致，只是所使用的关键字有所不同@interface。在底层实现上，所有定义的注解都会自动继承java.lang.annotation.Annotation接口。、

public @interface CherryAnnotation {
}

注解类型的实现部分：

根据我们在自定义类的经验，在类的实现部分无非就是书写构造、属性或方法。但是，在自定义注解中，其实现部分只能定义一个东西：注解类型元素（annotation type element）（一个注解元素其实对应一个抽象方法）。咱们来看看其语法：

public @interface CherryAnnotation {
	public String name();
	int age();
	int[] array();
}

也许你会认为这不就是接口中定义抽象方法的语法嘛？别着急，咱们看看下面这个：

public @interface CherryAnnotation {
	public String name();
	int age() default 18;
	int[] array();
}

看到关键字default了吗？还觉得是抽象方法吗？

注解里面定义的是：注解类型元素！

定义注解类型元素时需要注意如下几点：

  1. 访问修饰符必须为public，不写默认为public；
  2. 该元素的类型只能是基本数据类型、String、Class、枚举类型、注解类型（体现了注解的嵌套效果）以及上述类型的一位数组；
  3. 该元素的名称一般定义为名词，如果注解中只有一个元素，请把名字起为value（后面使用会带来便利操作）；
  4. ()不是定义方法参数的地方，也不能在括号中定义任何参数，仅仅只是一个特殊的语法；
  5. default代表默认值，值必须和第2点定义的类型一致；
  6. 如果没有默认值，代表后续使用注解时必须给该类型元素赋值。

可以看出，注解类型元素的语法非常奇怪，即又有属性的特征（可以赋值）,又有方法的特征（打上了一对括号）。但是这么设计是有道理的，我们在后面的章节中可以看到：注解在定义好了以后，使用的时候操作元素类型像在操作属性，解析的时候操作元素类型像在操作方法。

2、常用的元注解

一个最最基本的注解定义就只包括了上面的两部分内容：1、注解的名字；2、注解包含的类型元素。但是，我们在使用JDK自带注解的时候发现，有些注解只能写在方法上面（比如@Override）；有些却可以写在类的上面（比如@Deprecated）。当然除此以外还有很多细节性的定义，那么这些定义该如何做呢？接下来就该元注解出场了！
元注解：专门修饰注解的注解。它们都是为了更好的设计自定义注解的细节而专门设计的。我们为大家一个个来做介绍。

元注解中主要有四个：@Target、@Retention、@Documented、@Inherited

2.1、@Target注解

是专门用来限定某个自定义注解能够被应用在哪些Java元素上面的。它使用一个枚举类型定义如下：

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

    /** 属性的声明 */
    FIELD,

    /** 方法的声明 */
    METHOD,

    /** 方法形式参数声明 */
    PARAMETER,

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

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

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

    /** 包的声明 */
    PACKAGE
}

例如：下面的该自定义注解只能使用在类、接口和方法上

//@CherryAnnotation被限定只能使用在类、接口或方法上面
@Target(value = {ElementType.TYPE,ElementType.METHOD})
public @interface CherryAnnotation {
    String name();
    int age() default 18;
    int[] array();
}

2.2、@Retention注解

注解的生命周期有三个阶段：1、Java源文件阶段；2、编译到class文件阶段；3、运行期阶段。同样使用了RetentionPolicy枚举类型定义了三个阶段：

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     * （注解将被编译器忽略掉）
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     * （注解将被编译器记录在class文件中，但在运行时不会被虚拟机保留，这是一个默认的行为）
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     * （注解将被编译器记录在class文件中，而且在运行时会被虚拟机保留，因此它们能通过反射被读取到）
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

我们再详解一下：

  1. 如果一个注解被定义为RetentionPolicy.SOURCE，则它将被限定在Java源文件中，那么这个注解即不会参与编译也不会在运行期起任何作用，这个注解就和一个注释是一样的效果，只能被阅读Java文件的人看到；
  2. 如果一个注解被定义为RetentionPolicy.CLASS，则它将被编译到Class文件中，那么编译器可以在编译时根据注解做一些处理动作，但是运行时JVM（Java虚拟机）会忽略它，我们在运行期也不能读取到；
  3. 如果一个注解被定义为RetentionPolicy.RUNTIME，那么这个注解可以在运行期的加载阶段被加载到Class对象中。那么在程序运行阶段，我们可以通过反射得到这个注解，并通过判断是否有这个注解或这个注解中属性的值，从而执行不同的程序代码段。我们实际开发中的自定义注解几乎都是使用的RetentionPolicy.RUNTIME；
  4. 在默认的情况下，自定义注解是使用的RetentionPolicy.CLASS。

2.3、@Documented

@Documented注解，是被用来指定自定义注解是否能随着被定义的java文件生成到JavaDoc文档当中。

2.4 @Inherited

@Inherited注解，是指定某个自定义注解如果写在了父类的声明部分，那么子类的声明部分也能自动拥有该注解。@Inherited注解只对那些@Target被定义为ElementType.TYPE的自定义注解起作用。

3 自定义注解的配置使用

回顾一下注解的使用流程：

  • 第一步，定义注解——相当于定义标记；
  • 第二步，配置注解——把标记打在需要用到的程序代码中；
  • 第三步，解析注解——在编译期或运行时检测到标记，并进行特殊操作。

到目前为止我们只是完成了第一步，接下来我们就来学习第二步，配置注解，如何在另一个类当中配置它。

3.1 在具体的Java类上使用注解

首先，定义一个注解、和一个供注解修饰的简单Java类

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD})
@Documented
public @interface CherryAnnotation {
    String name();
    int age() default 18;
    int[] score();
}

public class Student{
    public void study(int times){
        for(int i = 0; i < times; i++){
            System.out.println("Good Good Study, Day Day Up!");
        }
    }
}

简单分析下：

  1. CherryAnnotation的@Target定义为ElementType.METHOD，那么它书写的位置应该在方法定义的上方，即：public void study(int times)之上；
  2. 由于我们在CherryAnnotation中定义的有注解类型元素，而且有些元素是没有默认值的，这要求我们在使用的时候必须在标记名后面打上()，并且在()内以“元素名=元素值“的形式挨个填上所有没有默认值的注解类型元素（有默认值的也可以填上重新赋值），中间用“,”号分割；

所以最终书写形式如下：

public class Student {
    @CherryAnnotation(name = "cherry-peng",age = 23,score = {99,66,77})
    public void study(int times){
        for(int i = 0; i < times; i++){
            System.out.println("Good Good Study, Day Day Up!");
        }
    }
}

3.2 特殊语法

特殊语法一：

如果注解本身没有注解类型元素，那么在使用注解的时候可以省略()，直接写为：@注解名，它和标准语法@注解名()等效！

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE})
@Documented
public @interface FirstAnnotation {
}

//等效于@FirstAnnotation()
@FirstAnnotation
public class JavaBean{
	//省略实现部分
}

特殊语法二：

如果注解本本身只有一个注解类型元素，而且命名为value，那么在使用注解的时候可以直接使用：@注解名(注解值)，其等效于：@注解名(value = 注解值)

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE})
@Documented
public @interface SecondAnnotation {
	String value();
}

//等效于@ SecondAnnotation(value = "this is second annotation")
@SecondAnnotation("this is annotation")
public class JavaBean{
	//省略实现部分
}

特殊用法三：

如果注解中的某个注解类型元素是一个数组类型，在使用时又出现只需要填入一个值的情况，那么在使用注解时可以直接写为：@注解名(类型名 = 类型值)，它和标准写法：@注解名(类型名 = {类型值})等效！

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE})
@Documented
public @interface ThirdAnnotation {
	String[] name();
}

//等效于@ ThirdAnnotation(name = {"this is third annotation"})
@ ThirdAnnotation(name = "this is third annotation")
public class JavaBean{
	//省略实现部分
}

特殊用法四：

如果一个注解的@Target是定义为Element.PACKAGE，那么这个注解是配置在package-info.java中的，而不能直接在某个类的package代码上面配置。

 

4 自定义注解的运行时解析

这一章是使用注解的核心，读完此章即可明白，如何在程序运行时检测到注解，并进行一系列特殊操作！

4.1 回顾注解的保持力

首先回顾一下，之前自定义的注解@CherryAnnotation，并把它配置在了类Student上，代码如下：

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD})
@Documented
public @interface CherryAnnotation {
    String name();
    int age() default 18;
    int[] score();
}

package pojos;
public class Student {
    @CherryAnnotation(name = "cherry-peng",age = 23,score = {99,66,77})
    public void study(int times){
        for(int i = 0; i < times; i++){
            System.out.println("Good Good Study, Day Day Up!");
        }
    }
}

注解保持力的三个阶段：

  1. Java源文件阶段；
  2. 编译到class文件阶段；
  3. 运行期阶段。

只有当注解的保持力处于运行阶段，即使用@Retention(RetentionPolicy.RUNTIME)修饰注解时，才能在JVM运行时，检测到注解，并进行一系列特殊操作。

4.2 反射操作获取注解

因此，明确我们的目标：在运行期探究和使用编译期的内容（编译期配置的注解），要用到Java中的灵魂技术——反射！

public class TestAnnotation {
    public static void main(String[] args){
        try {
            //获取Student的Class对象
            Class stuClass = Class.forName("pojos.Student");

            //说明一下，这里形参不能写成Integer.class，应写为int.class
            Method stuMethod = stuClass.getMethod("study",int.class);

            if(stuMethod.isAnnotationPresent(CherryAnnotation.class)){
                System.out.println("Student类上配置了CherryAnnotation注解！");
                //获取该元素上指定类型的注解
                CherryAnnotation cherryAnnotation = stuMethod.getAnnotation(CherryAnnotation.class);
                System.out.println("name: " + cherryAnnotation.name() + ", age: " + cherryAnnotation.age()
                    + ", score: " + cherryAnnotation.score()[0]);
            }else{
                System.out.println("Student类上没有配置CherryAnnotation注解！");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

解释一下：

  1. 如果我们要获得的注解是配置在方法上的，那么我们要从Method对象上获取；如果是配置在属性上，就需要从该属性对应的Field对象上去获取，如果是配置在类型上，需要从Class对象上去获取。总之在谁身上，就从谁身上去获取！
  2. isAnnotationPresent(Class<? extends Annotation> annotationClass)方法是专门判断该元素上是否配置有某个指定的注解；
  3. getAnnotation(Class<A> annotationClass)方法是获取该元素上指定的注解。之后再调用该注解的注解类型元素方法就可以获得配置时的值数据；
  4. 反射对象上还有一个方法getAnnotations()，该方法可以获得该对象身上配置的所有的注解。它会返回给我们一个注解数组，需要注意的是该数组的类型是Annotation类型，这个Annotation是一个来自于java.lang.annotation包的接口。

《该部分偷这个的https://blog.csdn.net/xsp_happyboy/article/details/80987484》

————————————————————————————————————————————————具体实现————————————————————————————————————————————————

可以利用自定义注解实现权限控制、属性验证等功能

一、使用spring aop实现自定义注解（对类、方法）（常用）

1、 pom.xml添加aop支持

<!-- 引入aop切面支持 -->
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

 

2、创建自定义注解类

package com.mp.mpdemo.util;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Documented
@Retention(RUNTIME)
@Target(METHOD)
public @interface LoginAnno {

}

其中元注解：元注解释义:
java.lang.annotation提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）：
@Documented –注解是否将包含在JavaDoc中
@Retention –什么时候使用该注解（上面是运行时使用）
@Target –注解用于什么地方（方法体上）
@Inherited – 是否允许子类继承该注解

3、编写切面类，实现AOP增强（自己定义使用这个注解时要实现什么逻辑）(这里只是在使用@LoginAnno注解时进行aop前置通知，这里简单的打印了自定义注解生效)

package com.mp.mpdemo.util;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * <h5>描述:通过@Aspect注解使该类成为切面类</h5>
 */
@Aspect
@Component
public class LoginAnnoImpl {

    @Pointcut("@annotation(com.mp.mpdemo.util.LoginAnno)")
    private void cut() {
    }

    /**
     * <h5>功能:前置通知</h5>
     */
    @Before("cut()")
    public void before() {
        System.out.println("自定义注解生效了");
    }
}

 

4、测试是否生效

@RequestMapping("login")
    @LoginAnno
    public String login(String userName) {
        return "欢迎您:" + userName;
    }

访问http://localhost:8080/login

查看控制台：

二、使用原生自定义注解（对属性）

需求：自定义一个注解验证是否为空和长度限制

1、自定义注解类

package com.mp.mpdemo.util;

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Constraint(validatedBy = IsFormatValidator.class) //具体的实现
@Target( { java.lang.annotation.ElementType.METHOD,
        java.lang.annotation.ElementType.FIELD })  //可以用在方法、属性上
@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@Documented
public @interface IsFormat {
    String message() default "{org.hibernate.validator.constraints.NotEmpty.message}";

    int length()  ; //一个元素属性其实对应一个抽象方法

    Class<?>[] groups() default {}; //default即默认值

    Class<? extends Payload>[] payload() default {};

}

2、注解实现逻辑（实现ConstraintValidator，重写isValid和initialize方法）

package com.mp.mpdemo.util;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

/**
 *
 * @description  功能描述: 自定义注解验证不能为空和长度
 * @param        参         数:
 * @Createdate  
 */
public class IsFormatValidator implements ConstraintValidator<IsFormat, Object> {

    private int Valuelength;
    @Override
    public boolean isValid(Object IdNumber, ConstraintValidatorContext constraintValidatorContext) {
        String message=constraintValidatorContext.getDefaultConstraintMessageTemplate();
        if(IdNumber==null||IdNumber.toString().equals("")){
            constraintValidatorContext.disableDefaultConstraintViolation();//禁用默认的message的值
            constraintValidatorContext
                    .buildConstraintViolationWithTemplate(message+"不能为空").addConstraintViolation();
            return false;
        }
        if(IdNumber.toString().length()>Valuelength){
            constraintValidatorContext.disableDefaultConstraintViolation();//禁用默认的message的值
            constraintValidatorContext
                    .buildConstraintViolationWithTemplate(message+"长度不能超过"+Valuelength+"位").addConstraintViolation();
            return false;
        }
        return true;
    }


    @Override
    public void initialize(IsFormat constraintAnnotation) {
        Valuelength=constraintAnnotation.length();
    }


}

3、测试

@RequestMapping(value = "reg",method = RequestMethod.POST)
    public String reg(@Validated  @RequestBody Demo demo) {
        System.out.println(demo.getName());
        return "欢迎您:";
    }

看下控制台：此时注解生效

三、使用非aop的自定义注解（拦截器）

 

 

a

先熬半个月
关注
开发中常用注解及自定义注解
Fzxey的博客
08-25 527
文章目录常见的注解：java自带的注解第三方注解元注解自定义注解 在java中注解是一个很重要的组成部分，使用注解能够使代码更加简洁，动态的提高代码的扩展性和可维护性。 按照来源分类： java自带的注解 第三方提供的注解 自定义的注解 元注解 常见的注解： java自带的注解 @Override 重写 @Test 测试 @Deprecated 方法过时 @SuppresWarning 忽略...
实现生成自定义注解的实体类
01-03
在Java编程语言中，自定义注解是一种强大的工具，它允许开发者创建自己的元数据，以提供额外的信息或规范代码的特定行为。自定义注解可以应用于类、接口、方法、变量等不同层级，使得代码更加模块化，易于理解和维护...
JSR303数据校验
djjdheh的博客
09-21 364
自定义注解/1. 定义一个注解 和 校验器类 ListValueConstrainValidator源码：ConstraintValidator接口第一个指定注解，第二个指定要校验的类型> {}}所以我们在自定义校验器中实现ConstraintValidator并给定注解和要校验的类型@Override}}/*** @param integer 需要验证的值*/@Override}}
java 自定义校验注解ConstraintValidator
最新发布
weixin_37000972的博客
06-29 80
AI相关视频讲解：Python性能这么差，为什么会在AI中大量使用谁来拯救我的数学？点到为止方为上策如何实现Java自定义校验注解ConstraintValidator 整体流程 首先，让我们通过一个表格来展示实现“java自定义校验注解ConstraintValidator”的整个流程： 步骤 操作 1...
自定义注解详细介绍
qq_39583810的博客
09-20 112
1 注解的概念 1.1 注解的官方定义 首先看看官方对注解的描述： An annotation is a form of metadata, that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated. Annotations have no direct effect on the operation of the code they annota
java 自定义注解的实例详解
08-29
Java 自定义注解的实例详解 Java 自定义注解是 Java 语言中的一种重要特性，它可以用于创建文档，跟踪代码中的依赖性，并且可以执行编译时期检查。自定义注解可以让开发者根据需要创建自己的注解，以满足特定的需求...
excel导入动态校验，自定义注解动态校验
06-09
本文将详细探讨"Excel导入动态校验，自定义注解动态校验"这一主题，旨在帮助你理解和掌握如何在处理Excel数据时进行有效的验证和校验。 首先，Excel导入动态校验是指在将Excel数据导入到系统或数据库时，对数据进行...
自定义注解实现拦截sql.rar
10-08
在Java开发中，自定义注解是一种非常强大的工具，它允许我们为代码添加元数据，以便在运行时或编译时进行处理。本示例中，“自定义注解实现拦截SQL”是关于如何通过注解来动态修改执行的SQL语句，以在其中增加特定的...
谈谈Java中自定义注解及使用场景
09-07
Java中的自定义注解是一种强大的工具，允许程序员在代码中添加元数据，这些元数据可以在编译时或运行时被解析和使用。自定义注解是Java 5引入的新特性，它增强了代码的可读性和可维护性，同时也简化了框架和库的开发...
Java注解
cj1140874158的博客
12-12 131
注解的概念 注解是一种能被添加到java代码中的元数据，类、方法、变量、参数和包都可以用注解来修饰。注解对于它所修饰的代码并没有直接的影响。 通俗点说，就是给修饰的代码添加标签 基本语法 声明注解： public @interface CherryAnnotation { } 注解类型的实现部分： public @interface CherryAnnotation { public String...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值