【SpringMVC】自定义注解

🎉🎉欢迎来到我的CSDN主页！🎉🎉

🏅我是Java方文山，一个在CSDN分享笔记的博主。📚📚

🌟在这里，我要推荐给大家我的专栏《Spring MVC》。🎯🎯

🚀无论你是编程小白，还是有一定基础的程序员，这个专栏都能满足你的需求。我会用最简单易懂的语言，带你走进Spring MVC的世界，让你从零开始，一步步成为JAVA大师。🚀🏆

🌈让我们一起在SpringMVC的世界里畅游吧！🌈🌈

👉点击这里，就可以查看我的主页啦！👇👇

Java方文山的个人主页

🎁如果感觉还不错的话请记得给我点赞哦！🎁🎁

💖期待你的加入，一起学习，一起进步！💖💖

目录

一、前言

1.1.什么是注解

1.2.注解的用处

1.3.注解的原理

二、注解的分类

2.1.JDK基本注解

2.1.1.@Override

2.1.2.@SuppressWarnings

2.2.JDK元注解

2.2.1.@Retention

2.2.2.@Target

2.2.3.@Inherited

2.2.4.@Documented

2.3.自定义注解

2.3.1.自定义注解的分类

三、注解取值的应用

3.1.前期准备工作

3.2.案例一（获取类与方法上的注解值）

3.3. 案例二（获取类属性上的注解属性值）   

3.4. 案例三（获取参数修饰注解对应的属性值）

四、自定义注解案例

---

一、前言

1.1.什么是注解

 Annontation是Java5开始引入的新特征，中文名称叫注解。

它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观、更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。

Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。

1.2.注解的用处

•  生成文档。这是最常见的，也是java 最早提供的注解。常用的有@param @return 等
• 跟踪代码依赖性，实现替代配置文件功能。比如Dagger 2 依赖注入，未来java 开发，将大量注解配置，具有很大用处;
• 在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。

1.3.注解的原理

注解本质是一个继承了Annotation 的特殊接口，其具体实现类是Java 运行时生成的动态代理类。而我们通过反射获取注解时，返回的是Java 运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler 的invoke 方法。该方法会从memberValues 这个Map 中索引出对应的值。而memberValues 的来源是Java 常量池。

二、注解的分类

2.1.JDK基本注解

2.1.1.@Override

      java.lang.Override 是一个标记类型注解，它被用作标注方法。它说明了被标注的方法重写了父类的方法，起到了断言的作用。如果我们使用了这种注解在一个没有覆盖父类方法的方法时，java 编译器将以一个编译错误来警示。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@Override是给javac(java编译器)看的，编译完以后就@Override注解就没有价值了，@Override注解在源代码中有用，编译成.class文件后@Override注解就没有用了，因此@Override的Retention的属性值是RetentionPolicy.SOURCE。

2.1.2.@SuppressWarnings

@SuppressWarnings是给javac(java编译器)看的，编译器编译完java文件后，@SuppressWarnings注解就没有用了，所以@SuppressWarnings的Retention的属性值是RetentionPolicy.SOURCE。

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
 
    String[] value();
}

2.2.JDK元注解

看完以上的JDK基本注解你是否更蒙了！？为什么注解类里面还有注解，那其实是JDK的元注解。

所有元注解定义在java.lang.annotation包下面，其中Annotation是注解的基本接口，所有的注解都继承这个接口。

java.lang.annotation 提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）

2.2.1.@Retention

指定注解的生命周期（源码、class文件、运行时）或是称作定义注解的保留策略。

该元注解中有三个属性值

@Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含

@Retention(RetentionPolicy.CLASS) //默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得

@Retention(RetentionPolicy.RUNTIME) //注解会在class字节码文件中存在，在运行时可以通过反射获取到

 下面我用别人写好的注解来给大家演示：

@Retention(RetentionPolicy.SOURCE) 

@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE)
@java.lang.annotation.Target({java.lang.annotation.ElementType.TYPE})
public @interface Slf4j {
    java.lang.String topic() default "";
}

 这是Slf4j的注解，用了元注解@Retention(RetentionPolicy.SOURCE) ，说明该注解仅存在于源码中，class文件中不包括我们来看看。

 确实如此我们的源码中有@Slf4j但是字节码文件中却没有，这就是该元注解以及属性的作用。

 用到最多的还是@Retention(RetentionPolicy.RUNTIME)，下面我们来看一下该元注解的使用。

@java.lang.annotation.Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.TYPE})
@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@java.lang.annotation.Documented
@org.springframework.web.bind.annotation.Mapping
public @interface RequestMapping {
    java.lang.String name() default "";
 
    @org.springframework.core.annotation.AliasFor("path")
    java.lang.String[] value() default {};
 
    @org.springframework.core.annotation.AliasFor("value")
    java.lang.String[] path() default {};
 
    org.springframework.web.bind.annotation.RequestMethod[] method() default {};
 
    java.lang.String[] params() default {};
 
    java.lang.String[] headers() default {};
 
    java.lang.String[] consumes() default {};
 
    java.lang.String[] produces() default {};
}

这是注解RequestMapping，因为@Retention中所填写的是RetentionPolicy.RUNTIME，所以被该注解所修饰的类/方法/属性就可以在运行时可以通过反射获取到。

2.2.2.@Target

指定被修饰的Annotation指定注解使用的目标范围（类、方法、字段等）。

刚刚在上面我们提到了一个关键信息，被@RequestMapping注解所修饰的类/方法/属性，那我们怎么知道又怎么决定那些注解可以用于类/方法/属性呢？就是通过元注解@Target来决定。

注意：可以指定多个位置，例如：
@Target({ElementType.METHOD, ElementType.TYPE})，也就是此注解可以在方法和类上面使用

不相信的同学可以回过头看看上面的代码中有没有Target哦！

2.2.3.@Inherited

指定子类可以继承父类的注解，只能是类上的注解，方法和字段的注解不能继承。即如果父类上的注解是@Inherited修饰的就能被子类继承。

当父类上的注解被@Inherited修饰时，子类可以继承该注解。下面是一个示例代码来演示这个概念：

import java.lang.annotation.*;
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface MyAnnotation {
    String value();
}
 
@MyAnnotation("我是父类的注解")
class ParentClass {
}
 
 
class ChildClass extends ParentClass {
}
 
 class Main {
    public static void main(String[] args) {
        // 获取父类上的注解
        MyAnnotation parentAnnotation = ParentClass.class.getAnnotation(MyAnnotation.class);
        System.out.println("获取父类上的注解: " + parentAnnotation.value());
 
        // 获取子类上的注解
        MyAnnotation childAnnotation = ChildClass.class.getAnnotation(MyAnnotation.class);
        System.out.println("获取子类上的注解: " + childAnnotation.value());
    }
}

如果我们没有用@Inherited会怎么样呢？

会抛出java.lang.NullPointerException异常，因为子类无法继承父类的注解。

2.2.4.@Documented

指定被修饰的该Annotation可以被javadoc工具提取成文档.

在Java中，注解（Annotation）是一种用于为代码添加元数据的方式。它们可以提供有关代码元素的信息，例如类、方法或变量。通过使用注解，开发人员可以在编译时或运行时对代码进行处理。

@Documented是Java中的一个注解属性，它指定被修饰的注解是否可以被Javadoc工具提取成文档。当一个注解被@Documented修饰时，它的目标元素（例如类、方法或字段）的相关文档中将包含该注解的描述。

这个属性对于生成API文档非常有用。当使用Javadoc工具生成API文档时，它会扫描源代码中的注解，并提取注解的描述信息。如果一个注解被@Documented修饰，那么它的描述信息将被包含在生成的API文档中，以便其他开发人员能够了解该注解的用途和作用。

总结一下，@Documented注解的作用是确保被修饰的注解可以被Javadoc工具提取成文档，并在生成的API文档中显示注解的描述信息。这样可以帮助其他开发人员更好地理解和使用你的代码。

小贴士：在Java 8中，引入了一些新的元注解，用于提供额外的功能和配置。以下是一些主要的元注解及其作用

 以上信息源于网络，更多细节请参考官方文档。

JDK官方文档https://docs.oracle.com/en/java/javase/20/

2.3.自定义注解

自定义注解类编写的一些规则:

1.    Annotation 类型定义为@interface, 所有的Annotation 会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口。
2.   参数成员只能用public 或默认(default) 这两个访问权修饰。语法：类型  属性名()  [default 默认值];      default表示默认值 ，也可以不编写默认值的.
3.   参数成员只能用基本类型byte、short、char、int、long、float、double、boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组.
4.   要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation 对象，因为你除此之外没有别的获取注解对象的方法。
5.   注解也可以没有定义成员,，不过这样注解就没啥用了。

注意: 自定义注解需要使用到元注解。

• 注解方法不能有参数。
• 注解方法的返回类型局限于原始类型，字符串，枚举，注解，或以上类型构成的数组。
• 注解方法可以包含默认值。

2.3.1.自定义注解的分类

注解分类（根据Annotation是否包含成员变量,可以把Annotation分为两类）:

标记Annotation:
没有成员变量的Annotation; 这种Annotation仅利用自身的存在与否来提供信息

元数据Annotation:
包含成员变量的Annotation; 它们可以接受(和提供)更多的元数据;

三、注解取值的应用

3.1.前期准备工作

TranscationModel枚举类

public enum  TranscationModel {
    Read, Write, ReadWrite
}

小贴士：什么是枚举类？枚举类的作用是什么？

枚举类是Java中一种特殊的数据类型，用于定义一组固定的命名常量。枚举类型提供了一种更强大、更安全和更易读的方式来表示一组相关的常量。在Java中，枚举类型是通过关键字`enum`来定义的。

枚举类的作用是提供一种类型安全的方式来表示一组固定的值，避免使用数字或字符串常量时可能出现的错误。通过使用枚举类型，可以限制变量只能取预定义的值，并且可以在代码中使用这些常量的名称来提高可读性和可维护性。

MyAnnotation1自定义注解类

/**
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation1 {
    String name();
}

MyAnnotation2自定义注解类

 
/**
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

MyAnnotation3自定义注解类

 
/**
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

TestAnnotation自定义注解类

//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";
 
    String what() default "这里是默认的what属性对应的值";
}

IsNotNull自定义注解类

/**
 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

3.2.案例一（获取类与方法上的注解值）

Demo1测试类

/**
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "abc")
public class Demo1 {
 
    @MyAnnotation1(name = "xyz")
    private Integer age;
 
    @MyAnnotation2(model = TranscationModel.Read)
    public void list() {
        System.out.println("list");
    }
 
    @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    public void edit() {
        System.out.println("edit");
    }
}

Demo1Test测试类

public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//abc
 
//        获取方法上的注解
        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
        System.out.println(myAnnotation2.model());//Read
 
//        获取属性上的注解
        MyAnnotation1 myAnnotation1 = Demo1.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
        System.out.println(myAnnotation1.name());// xyz
    }
 
    @Test
    public void edit() throws Exception {
        MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
        for (TranscationModel model : myAnnotation3.models()) {
            System.out.println(model);//Read,Write
        }
    }
}

 运行list方法结果：

 运行edit方法结果：

3.3. 案例二（获取类属性上的注解属性值）   

Demo2测试类

/**
 * 获取类属性上的注解属性值
 */
public class Demo2 {
    @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    private static String msg1;
 
    @TestAnnotation("这就是value对应的值1")
    private static String msg2;
 
    @TestAnnotation(value = "这就是value对应的值2")
    private static String msg3;
 
    @TestAnnotation(what = "这就是what对应的值")
    private static String msg4;
}

Demo2Test测试类

public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());
        System.out.println(msg1.what());
    }
 
    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());
        System.out.println(msg2.what());
    }
 
    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());
        System.out.println(msg3.what());
    }
 
    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());
        System.out.println(msg4.what());
    }
}

  运行test1方法结果：

  运行test2方法结果：

  运行test3方法结果：

  运行test4方法结果：

总结：如果我们注解上没有指定是value还是what默认就是value,如果只想转递一个参数又不想默认是value那就需要指定what=""即可。

3.4. 案例三（获取参数修饰注解对应的属性值）

Demo3测试类

public class Demo3 {
 
    public void hello1(@IsNotNull(true) String name) {
        System.out.println("hello:" + name);
    }
 
    public void hello2(@IsNotNull String name) {
        System.out.println("hello:" + name);
    }
}

Demo3Test测试类

public class Demo3Test {
 
    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
            }
        }
    }
 
    @Test
    public void hello2() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//false
            }
        }
    }
 
    @Test
    public void hello3() throws Exception {
//        模拟浏览器传递到后台的参数 解读@requestParam
        String name = "zs";
        Demo3 demo3 = new Demo3();
        Method method = demo3.getClass().getMethod("hello1", String.class);
        for (Parameter parameter : method.getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
                if (annotation.value() && !"".equals(name)){
                    method.invoke(demo3,name);
                }
            }
        }
    }
}

运行hello1方法结果：

运行hello2方法结果：

运行hello3方法结果：

如果我们属性不为true,或者名字不为zs会怎样？

总结：这个案例像不像我们的注解@RequestParam必须传递参数，除非指定required为false就可与不传参数，我们这个案例也是如此。

四、自定义注解案例

在写项目的过程中，肯定遇到过记录日志的功能要求，这时候我们就可以根据这个要求建立一个自定义注解类，只有被该注解修饰的方法就会走AOP切面类进行日志保存。

MyLog自定义注解类

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

MyLogAspect切面类

@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
 
    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.csdn.xw.annotation.aop.MyLog)")
    private void MyValid() {
    }
 
    @Before("MyValid()")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        logger.debug("[" + signature.getName() + " : start.....]");
        System.out.println("[" + signature.getName() + " : start.....]");
 
        MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
        logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
        System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
    }
}

Controller层代码

@Component
@RequestMapping("/aa")
public class LogController {
 
    @RequestMapping("/mylog")
    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(){
        System.out.println("这里随便来点啥");
    }
}

 这时候我们访问的地址为：

http://localhost:8080/aa/mylog

配置了我们所编写的自定义注解类就可以走切面类然后根据我想要的内容进行获取保存到数据库。

到这里我的分享就结束了，欢迎到评论区探讨交流！！

💖如果觉得有用的话还请点个赞吧 💖