AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

SpringMVC之自定义注解（这期博客带你领略自定义注解的魅力）

2023-11-15 67
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： SpringMVC之自定义注解（这期博客带你领略自定义注解的魅力）


前言

       各位老铁好啊，看过我前几期博客的老铁们都知道，在之前的博客分享中我们学习到了有关JSON返回类型、异常处理机制、JSR303以及拦截器等等的知识。今天带各位老铁一起来探索一个新的领域——自定义注解。

一、Java注解简介

1. 什么是Java注解

       Java注解是Java语言的一种特殊语法元素，它可以用来为代码添加额外的元数据信息。注解可以用于类、方法、变量、参数等各种程序元素上。注解的作用是为程序的其他部分提供额外的信息，以便编译器、解析器或者运行时环境在处理这些程序元素时能够根据注解的信息进行相应的处理。

       Java注解通常使用自定义注解或者内置的预定义注解，例如@Override、@Deprecated等。你也可以根据需要自定义注解。

       使用Java注解的好处是可以通过注解为代码添加更多的语义信息，提高代码的可读性和可维护性。注解还可以用于实现一些框架、库或者工具的功能，例如JUnit测试框架、Spring框架等。

2. Java注解分类

2.1 JDK基本注解

       JDK提供的一些基本注解，它们提供了编译器级别的信息和指导，可以帮助开发者编写更准确、更高效的代码。

JDK基本注解

注解 注解说明
@Override 用于标注方法，表示该方法是覆盖父类的方法。当方法标记了@Override注解但实际没有覆盖父类方法时，编译器会给出警告。
@Deprecated 用于标注过时的方法、类、字段等。表示该项已不推荐使用，可能会在未来的版本中删除或替换。
@SuppressWarnings 用于抑制某些特定警告，可以应用于类、方法、变量等。此注解可以接受一个或多个参数，用于指定要抑制的警告类型。
@SafeVarargs 用于标记方法，表示方法是类型安全的可变参数方法。在使用可变参数的方法时，编译器会给出警告，但在使用@SafeVarargs注解后，可以抑制这种警告。
@FunctionalInterface 用于标记接口，表示该接口是函数式接口。函数式接口是只包含一个抽象方法的接口，常用于Lambda表达式和函数式编程。
@SuppressWarnings("serial") 用于抑制未序列化警告。在自定义的可序列化类中，如果没有指定serialVersionUID字段，编译器会给出警告，通过使用@SuppressWarnings("serial")注解可以抑制此警告。

2.2 JDK元注解

       JDK元注解是指Java开发工具包（JDK）中提供的一组用于标记和定义其他注解的注解。它们是Java语言提供的预定义注解，用于在编写和使用自定义注解时提供更多的控制和附加信息。

JDK云注解

注解 注解说明
@Retention 用于指定注解的保留策略，有三种保留策略可选，分别是RetentionPolicy.SOURCE、RetentionPolicy.CLASS和RetentionPolicy.RUNTIME。默认为RetentionPolicy.CLASS。（定义注解的保留策略）
@Documented 用于指定被该注解修饰的元素是否需要包含在Java文档中。（指定被修饰的该Annotation可以被javadoc工具提取成文档.）
@Target 用于指定注解适用的目标元素类型，可以是类、方法、字段等。常见的取值有ElementType.TYPE、ElementType.METHOD、ElementType.FIELD等。
@Inherited 用于指定被该注解修饰的类是否可以被子类继承，默认不会被子类继承。（指定被修饰的Annotation将具有继承性）
@Repeatable 用于指定注解是否可以重复应用于同一元素上，以便实现多次注解该元素的效果。
注：

@Retention：

@Retention(RetentionPolicy.SOURCE)             //注解仅存在于源码中，在class字节码文件中不包含。
@Retention(RetentionPolicy.CLASS)              //默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得。
@Retention(RetentionPolicy.RUNTIME)            //注解会在class字节码文件中存在，在运行时可以通过反射获取到。

@Target：

@Target：指定被修饰的Annotation可以放置的位置(被修饰的目标)

@Target(ElementType.TYPE)                      //接口、类

@Target(ElementType.FIELD)                     //属性

@Target(ElementType.METHOD)                    //方法

@Target(ElementType.PARAMETER)                 //方法参数

@Target(ElementType.CONSTRUCTOR)               //构造函数

@Target(ElementType.LOCAL_VARIABLE)            //局部变量

@Target(ElementType.ANNOTATION_TYPE)           //注解

@Target(ElementType.PACKAGE)                   //包

例如：

@Target({ElementType.METHOD, ElementType.TYPE})，也就是此注解可以在方法和类上面使用

2.3 自定义注解

       自定义注解是指在Java中使用开发者自己定义的注解（Annotation）。注解是一种元数据，它提供了程序额外的信息，可以用于在代码中添加标记、配置和动态行为。

       通过自定义注解，开发者可以根据自己的需求，给类、方法、字段等元素添加额外的信息和语义。自定义注解需要使用Java提供的注解元编程机制，使用特定的注解元素和注解处理器来实现。

       自定义注解的定义方式和普通接口类似，使用关键字@interface定义注解，然后在其中定义注解元素。

案例：
import java.lang.annotation.*;
@Target(ElementType.TYPE) // 指定注解应用的目标类型（这里是类）
@Retention(RetentionPolicy.RUNTIME) // 指定注解保留的策略（这里是运行时）
public @interface MyAnnotation {
    String value() default ""; // 定义注解元素
}

上述代码示例定义了一个名为MyAnnotation的自定义注解。该注解可以被应用于类（ElementType.TYPE），并且在运行时（RetentionPolicy.RUNTIME）保留注解信息。注解中定义了一个名为value的注解元素。

二、 自定义注解（SpringMVC中运用）

案例讲解

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

部署测试（定义三个常量）

创建一个annotation文件夹，在文件下创建一个TranscationModel.java类及测试类

TranscationModel.java

package com.yx.annotation;
public enum  TranscationModel {
    Read, Write, ReadWrite
}

对应的测试类

package com.yx.annotation;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 测试类
 *
 */
public class Test01 {
    public static void main(String[] args) {
        System.out.println(TranscationModel.Read);
        System.out.println(TranscationModel.Write);
        System.out.println(TranscationModel.ReadWrite);
    }
}

运行结果

定义编写三个自定义标签类
自定义标签01（MyAnnotation1.java）
package com.yx.annotation.demo01;
import java.lang.annotation.*;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 注解1
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation1 {
    String name();
}
自定义标签02（MyAnnotation2.java）
package com.yx.annotation.demo01;
import java.lang.annotation.*;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 注解02
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}
自定义标签03（MyAnnotation3.java）
package com.yx.annotation.demo01;
import java.lang.annotation.*;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 注解03
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}
相关测试类
Demo1.java
package com.yx.annotation.demo01;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "muyi")
public class Demo1 {
    @MyAnnotation1(name = "xixi")
    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
package com.yx.annotation.demo01;
import org.junit.Test;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//muyi
//        获取方法上的注解
        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());// xixi
    }
    @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()方法测试结果

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

测试的是value的默认值和default默认值的赋予。

编写的自定义标签类
package com.yx.annotation.demo02;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";
    String what() default "这里是默认的what属性对应的值";
}
测试案例
package com.yx.annotation.demo02;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * 获取类属性上的注解属性值
 */
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;
}
测试卷类代码
package com.yx.annotation.demo02;
import org.junit.Test;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
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());
    }
}
测试结果
test()02测试结果

test()03测试结果

test()04测试结果

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

编写的自定义标签类
package com.yx.annotation.demo03;
import java.lang.annotation.*;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}
测试案例
package com.yx.annotation.demo03;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * 获取参数修饰注解对应的属性值
 */
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);
    }
}
测试卷类代码
package com.yx.annotation.demo03;
import org.junit.Test;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
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()方法测试结果

hello1()方法测试结果（name属性为空）

不给name属性值则不调用方法

三、Aop自定义注解案例（重点）

测试案例

MyLog.java

package com.yx.annotation.aop;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

切面类

MyLogAspect.java

package com.yx.aspect;
import com.yx.annotation.aop.MyLog;
import org.aspectj.lang.JoinPoint;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.yx.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());
    }
}

控制器类

LogController.java

package com.yx.web;
import com.yx.annotation.aop.MyLog;
import org.springframework.stereotype.Controller;
/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
@Controller
public class LogController {
    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(){
        System.out.println("这里随便来点啥");
    }
}

测试结果

情况一:

本期的博客分享到此结束了，希望老铁三连加关注支持一下

文章标签：
日志服务
Java
编译器
开发者
安全
JSON
关键词：
Spring MVC自定义
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
君易--鑨
目录
相关文章
Love-Java.
|
前端开发 Java 编译器
SpringMVC自定义注解---[详细介绍]
SpringMVC自定义注解---[详细介绍]
Love-Java.
43 0
君临沂
|
监控 Java 编译器
SpringMVC之自定义注解
SpringMVC之自定义注解
君临沂
54 0
阿甘兄
|
前端开发 Java
48SpringMVC - 参数绑定（自定义）
48SpringMVC - 参数绑定（自定义）
阿甘兄
50 0
艳艳耶
|
安全 Java 数据库连接
【springMvc】自定义注解的使用方式
【springMvc】自定义注解的使用方式
艳艳耶
109 0
现在是571
|
6月前
|
缓存 安全 Java
SpringMVC自定义注解和使用
SpringMVC自定义注解和使用
现在是571
137 0
尘觉
|
6月前
|
前端开发 安全 Java
解锁高级技巧：玩转 Spring MVC 自定义拦截器的神奇世界
解锁高级技巧：玩转 Spring MVC 自定义拦截器的神奇世界
尘觉
108 0
bing人
|
Java 数据安全/隐私保护 Spring
SpringMVC之自定义注解
SpringMVC之自定义注解
bing人
43 1
Kissship
|
Java 编译器 开发者
SpringMVC之自定义注解
SpringMVC之自定义注解
Kissship
42 0
SpringMVC之自定义注解
朱琳均
|
11月前
|
Java
springmvc之自定义注解--＞自定义注解简介，基本案例和aop自定义注解
springmvc之自定义注解--＞自定义注解简介，基本案例和aop自定义注解
朱琳均
54 0
懒大王o
|
11月前
|
Java 开发者
SpringMVC----自定义注解
SpringMVC----自定义注解
懒大王o
57 0

热门文章

最新文章

  • 1
    SpringMvc+Spring+MyBatis 基于注解整合
  • 2
    配置springmvc在其他类中（spring容器外）获取注入bean
  • 3
    第7章—SpringMVC高级技术—处理异常
  • 4
    SpringMVC标签用法
  • 5
    SpringMVC介绍之视图解析器ViewResolver
  • 6
    02springmvc架构原理分析
  • 7
    Dubbo与Zookeeper、SpringMVC整合和使用（负载均衡、容错）（转）
  • 8
    SpringMVC多视图技术
  • 9
    springMVC学习笔记--知识点总结1
  • 10
    Spring MVC 参数的绑定方法
  • 1
    SpringMVC04 实现简单的留言墙功能
    40
  • 2
    SpringMVC03 基础操作续与几个简单的交互
    34
  • 3
    Spring MVC框架概述
    82
  • 4
    SpringBoot与SpringMVC有哪些区别？
    397
  • 5
    SpringBoot：SpringMVC（下）
    39
  • 6
    SpringBoot：SpringMVC（上）
    49
  • 7
    生活小事件(SpringMVC主要的组件及作用和执行流程)
    94
  • 8
    数据塑造：Spring MVC中@ModelAttribute的高级数据预处理技巧
    68
  • 9
    数据之桥：深入Spring MVC中传递数据给视图的实用指南
    91
  • 10
    头头是道：揭示Spring MVC如何获取和处理请求头数据
    107

    • 相关课程

    更多
  • SpringMVC框架入门
  • Java Web开发系列课程 - Spring框架入门
  • Java Spring Boot 2.6.0开发实战-1024程序员节创造营公益课
  • Java面向对象开发

    • 相关电子书

    更多
  • Spring框架入门
  • Java Spring Boot开发实战系列课程【第6讲】：Spring Boot 2.0实战MyBatis与优化(Java面试题)
  • Java Spring Boot开发实战系列课程【第7讲】：Spring Boot 2.0安全机制与MVC身份验证实战(Java面试题)
    • 下一篇
    阿里云OSS设置跨域访问