• SpringMVC之自定义注解

    目录

    一、Java注解

    1.1 注解简介

    1.2 注解分类

    1.3 JDK基本注解

    1.4 JDK元注解

    1.5 自定义注解

    1.5.1 标记注解

    1.5.2 元数据注解

    1.6 如何自定义注解

    二、自定义注解的基本案例

    2.1 案例一（获取类、方法以及属性上的注解）

    2.1.1 @Ingerited的使用

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

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

    三、AOP自定义注解的应用

    3.1 定义自定义注解@Mylog

    3.2 定义切面类MyLogAspect

    3.3 创建一个控制器LogController

    一、Java注解

    1.1 注解简介

    1. Java注解（Annotations）是Java语言中的一种元程序（meta-programming）机制，提供了一种在程序中添加元数据信息的方法。注解可以应用于类、方法、变量、参数等程序元素上，用于给程序代码添加一些特别的信息，以便其他程序或工具能够更好地理解和处理这些程序元素。
    2. 注解可以带参数，也可以没有参数，定义注解时需要使用注解@interface来声明，注解中的参数通过定义成员变量来实现。注解的属性的类型可以是基本类型、字符串、枚举类型、注解类型等。注解在运行时通过反射来获取注解信息，可以用于实现动态代理、自动代码生成等功能。
    3. Java提供了许多预定义注解，如@Override、@Deprecated、@SuppressWarnings等，同时也可以自定义注解来满足特定的需求。注解的使用通常需要结合Java反射机制、Java编译器等技术来实现，可以使代码更加清晰、简洁、易于维护。

    1.2 注解分类

    Java注解（Annotation）按照其作用范围和保留策略可以分为以下几类：

    1. 元注解（Meta-Annotation）：用于修饰注解的注解，如@Target、@Retention、@Documented、@Inherited等。

    2. 编译时注解（Compile-Time Annotation）：只存在于源代码中，在编译时会被编译器处理掉，如@Override、@Deprecated、@SuppressWarnings等。

    3. 运行时注解（Runtime Annotation）：在程序运行时才会被解析和处理，通常用于实现框架或插件的功能，如@SpringBootConfiguration、@ComponentScan、@RequestMapping等。

    4. 类型注解（Type Annotation）：从Java 8开始提供的注解，可以用于指定注解的作用目标类型，如@NonNull、@Nullable等。

    5. 单值注解和多值注解：按照注解值的个数可分为单值注解和多值注解。其中单值注解只有一个值，多值注解可以有多个值，如@Value、@Order等。

    1.3 JDK基本注解

    JDK（Java Development Kit）是Java的开发工具包，提供了许多注解（Annotation）来帮助Java开发者编写更加优秀的代码。下面是JDK常用的几种注解：

    1. @Override：用于表明当前方法是重写了父类或者实现了接口中的方法。如果不小心写错了方法名或者参数类型，编译时会提示错误。

    2. @Deprecated：用于标记某个方法或者类已经过时，告诉开发者不要再使用该方法或者类。虽然标记为过时，但是还可以继续使用。

    3. @SuppressWarnings：用于抑制警告信息，可以选择性地关闭编译器对某些代码的警告提示。例如@SuppressWarnings("unchecked")，可以关闭编译器对未经检查的转换产生的警告。

    4. @SafeVarargs：用于标记当前方法使用可变参数时不会出现类型不安全的问题。该注解可以解决一些泛型转型的警告问题。

    5. @FunctionalInterface：用于标记某个接口是函数式接口，即只有一个抽象方法的接口。使用该注解可以帮助开发者避免不必要的错误，同时也可以让编译器进行更加优化的处理。

    除了上述注解，JDK还有许多其他的注解，例如@Nullable和@NonNull等。这些注解可以提高代码的可读性和可维护性，使代码更加健壮和简洁。

    1.4 JDK元注解

    元注解是用于注解其他注解的注解。在 Java 中有四个元注解，分别是：@Retention、@Target、@Inherited 和 @Documented。

    1. @Retention：用于指定注解的声明周期，即注解的保留时间。它有三个取值：RetentionPolicy.SOURCE、RetentionPolicy.CLASS、RetentionPolicy.RUNTIME。其中，RetentionPolicy.SOURCE 表示该注解只在源码中存在，编译成字节码后就不存在了；RetentionPolicy.CLASS 表示该注解会被编译到字节码中，但在运行时不会被虚拟机保留；RetentionPolicy.RUNTIME 表示该注解会保留到运行时，并可以通过反射获取到。

    2. @Target：用于指定注解的作用范围，即注解可以用在哪些元素上。它有多个取值，包括 ElementType.TYPE（类、接口、枚举）、ElementType.FIELD（字段）、ElementType.METHOD（方法）、ElementType.PARAMETER（参数）、ElementType.CONSTRUCTOR（构造方法）、ElementType.LOCAL_VARIABLE（局部变量）、ElementType.ANNOTATION_TYPE（注解类型）和 ElementType.PACKAGE（包）。

    3. @Inherited：用于指定注解是否可以被继承。如果一个注解被 @Inherited 修饰，它的子类会自动继承该注解。

    4. @Documented：用于指定注解是否可以被包含在 JavaDoc 文档中。如果一个注解被 @Documented 修饰，它会被包含在 JavaDoc 文档中，方便开发者查看。

    1.5 自定义注解

    1.5.1 标记注解

    Java中的自定义注解可以有多种类型，其中一种是标记注解（Marker Annotation）。这种注解不包含任何成员变量，只是作为一种标记，用于标识某些特殊的情况或设置。比较常见的标记注解有以下几种：

    1. @Deprecated：标记某个方法或类已经过时，不建议使用，通常用于提醒开发者避免使用这些方法或类。

    2. @Override：标记某个方法是重写了父类的方法，用于提醒开发者这个方法与父类方法同名，但已经重写，需要特别注意。

    3. @SuppressWarnings：标记某个代码段不需要被编译器警告或报错，通常用于消除编译器针对代码的一些警告信息，比如去除未使用的变量等。

    这些标记注解可以很方便地在代码中进行标识，并提供给编译器或其他工具进行处理。同时也方便其他开发者阅读和理解代码的意图。

    1.5.2 元数据注解

    Java自定义注解中的元数据注解是指用来定义注解的注解，也就是说它可以用来描述一个注解的定义。

    例如，Java中的@Target注解就是一个元数据注解，它用来指定一个注解可以应用的目标元素，如类、方法、字段等。

    另一个例子是@Retention注解，它用来指定一个注解可以在运行时保留多长时间，如只在源码中保留、在.class文件中保留、在运行时保留等。

    除了@Target和@Retention之外，还有一些其他的元数据注解可以用来描述一个注解的定义，如@Documented、@Inherited、@Repeatable等等。这些注解都是在Java语言中提供的，可以灵活地用于定义各种风格的自定义注解。

    1.6 如何自定义注解

    使用@interface关键字, 其定义过程与定义接口非常类似, 需要注意的是:
       Annotation的成员变量在Annotation定义中是以无参的方法形式来声明的, 其方法名和返回值类型定义了该成员变量的名字和类型,
       而且我们还可以使用default关键字为这个成员变量设定默认值；

    二、自定义注解的基本案例

    2.1 案例一（获取类、方法以及属性上的注解）

    前期准备：在java包下创建pakage如下：

    建包目录如下：

    在demo1下建立一个TranscationModel，代码如下：

    1. package com.Kissship.annotation.demo1;
    2.  
    3. public enum  TranscationModel {
    4.     Read, Write, ReadWrite;
    5.     private String name;
    6.     private Integer id;
    7.     public void init1(){
    8.         Read.id = 1;
    9.         Read.name = "刘一金";
    10.     }
    11.  
    12.     public void init2(){
    13.         Write.id = 2;
    14.         Write.name = "刘二金";
    15.     }
    16.  
    17.     public void init3(){
    18.         ReadWrite.id = 3;
    19.         ReadWrite.name = "刘三金";
    20.     }
    21. }

    同样是在demo1目录下新建三个MyAnnotation，如下：

    MyAnnotation1，代码如下：

    1. package com.Kissship.annotation.demo1;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * MyAnnotation1注解可以用在类、接口、属性、方法上
    7.  * 注解运行期也保留
    8.  * 不可继承
    9.  */
    10. @Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
    11. @Retention(RetentionPolicy.RUNTIME)
    12. @Documented
    13. public @interface MyAnnotation1 {
    14.     String name();
    15. }

    MyAnnotation2，代码如下：

    1. package com.Kissship.annotation.demo1;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  *  MyAnnotation2注解可以用在方法上
    7.  *  注解运行期也保留
    8.  *  不可继承
    9.  */
    10. @Target(ElementType.METHOD)
    11. @Retention(RetentionPolicy.RUNTIME)
    12. @Documented
    13. public @interface MyAnnotation2 {
    14.     TranscationModel model() default TranscationModel.ReadWrite;
    15. }

     新建MyAnnotation3，代码如下：

    1. package com.Kissship.annotation.demo1;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * @author Kissship
    7.  * @site www.Kissship.com
    8.  * @company xxx公司
    9.  * @create 2023-09-14-19:00
    10.  * MyAnnotation3注解可以用在方法上
    11.  * 注解运行期也保留
    12.  * 可继承
    13.  */
    14. @Target(ElementType.METHOD)
    15. @Retention(RetentionPolicy.RUNTIME)
    16. @Inherited
    17. @Documented
    18. public @interface MyAnnotation3 {
    19.     TranscationModel[] models() default TranscationModel.ReadWrite;
    20. }

    注：

    2.1.1 @Ingerited的使用

    • @Inherited注解是Java中的元注解之一，用于控制注解的继承性。当一个类或接口被@Inherited注解修饰时，它的子类将自动获得该注解。但需要注意的是，@Inherited只对类和接口有效，对方法、字段等无效。
    • 普通的类继承是指子类可以继承父类的所有非private的成员变量和方法，包括构造器。子类可以使用父类中的方法和属性，也可以重写父类的方法，在其基础上进行扩展或修改。

    @Ingerited注解继承与普通类继承的区别：

    因此，@Inherited注解继承与普通类继承的区别在于，@Inherited注解只能继承注解，而普通类继承可以继承所有非private的成员变量和方法。

    接下来就是测试类demo1界面，代码如下：

    1. package com.Kissship.annotation.demo1;
    2.  
    3. /**
    4.  * @author Kissship
    5.  * @site www.Kissship.com
    6.  * @company xxx公司
    7.  * @create 2023-09-14-19:00
    8.  */
    9. @MyAnnotation1(name = "刘三金")
    10. public class Demo1 {
    11.  
    12.     @MyAnnotation1(name = "《挪威的森林》")
    13.     private Integer age;
    14.  
    15.     @MyAnnotation2(model = TranscationModel.Read)
    16.     public void list() {
    17.         System.out.println("list");
    18.     }
    19.  
    20.     @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    21.     public void edit() {
    22.         System.out.println("edit");
    23.     }
    24. }

    Demo1Test，代码如下：

    1. package com.Kissship.annotation.demo1;
    2.  
    3. import org.junit.Test;
    4.  
    5. /**
    6.  * @author Kissship
    7.  * @site www.Kissship.com
    8.  * @company xxx公司
    9.  * @create 2023-09-14-19:00
    10.  */
    11. public class Demo1Test {
    12.     @Test
    13.     public void list() throws Exception {
    14. //        获取类上的注解
    15.         MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
    16.         System.out.println(annotation1.name());
    17.  
    18. //        获取方法上的注解
    19.         MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
    20.         System.out.println(myAnnotation2.model());
    21.  
    22. //        获取属性上的注解
    23.         MyAnnotation1 myAnnotation1 = Demo1.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
    24.         System.out.println(myAnnotation1.name());
    25.     }
    26.  
    27.     @Test
    28.     public void edit() throws Exception {
    29.         MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
    30.         for (TranscationModel model : myAnnotation3.models()) {
    31.             System.out.println(model);
    32.         }
    33.     }
    34. }

    然后就可进行执行测试了，案例一测试结果如下：

    list方法执行结果：

    edit方法执行结果： 

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

    新建一个demo2包用来演示案例二，如下：

    放入案例代码，如下：

    Demo2：

    1. package com.Kissship.annotation.demo2;
    2.  
    3. /**
    4.  * @author Kissship
    5.  * @site www.Kissship.com
    6.  * @company xxx公司
    7.  * @create 2023-09-14-19:00
    8.  */
    9. public class Demo2 {
    10.     @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    11.     private static String msg1;
    12.  
    13.     @TestAnnotation("这就是value对应的值1")
    14.     private static String msg2;
    15.  
    16.     @TestAnnotation(value = "这就是value对应的值2")
    17.     private static String msg3;
    18.  
    19.     @TestAnnotation(what = "这就是what对应的值")
    20.     private static String msg4;
    21. }

     Demo2Test：

    1. package com.Kissship.annotation.demo2;
    2.  
    3. import org.junit.Test;
    4.  
    5. /**
    6.  * @author Kissship
    7.  * @site www.Kissship.com
    8.  * @company xxx公司
    9.  * @create 2023-09-14-19:00
    10.  */
    11. public class Demo2Test {
    12.     @Test
    13.     public void test1() throws Exception {
    14.         TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
    15.         System.out.println(msg1.value());
    16.         System.out.println(msg1.what());
    17.     }
    18.  
    19.     @Test
    20.     public void test2() throws Exception{
    21.         TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
    22.         System.out.println(msg2.value());
    23.         System.out.println(msg2.what());
    24.     }
    25.  
    26.     @Test
    27.     public void test3() throws Exception{
    28.         TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
    29.         System.out.println(msg3.value());
    30.         System.out.println(msg3.what());
    31.     }
    32.  
    33.     @Test
    34.     public void test4() throws Exception{
    35.         TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
    36.         System.out.println(msg4.value());
    37.         System.out.println(msg4.what());
    38.     }
    39. }

    TestAnnotation：

    1. package com.Kissship.annotation.demo2;
    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.  
    8. /**
    9.  * @author Kissship
    10.  * @site www.Kissship.com
    11.  * @company xxx公司
    12.  * @create 2023-09-14-19:00
    13.  */
    14. //@Retention(RetentionPolicy.SOURCE)
    15. @Retention(RetentionPolicy.RUNTIME)
    16. @Target(ElementType.FIELD)
    17. public @interface TestAnnotation {
    18.     String value() default "默认value值";
    19.  
    20.     String what() default "这里是默认的what属性对应的值";
    21. }

     进行测试，如下：

    Test1方法结果如下：

    测试Test2方法结果如下：

    测试Test3方法结果如下： 

    测试Test4方法结果如下：

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

    同上，新建demo3进行案例三演示代码的存放，如下：

    新建自定义注解IsNotNull，代码如下：

    1. package com.Kissship.annotation.demo3;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * @author Kissship
    7.  * @site www.Kissship.com
    8.  * @company xxx公司
    9.  * @create 2023-09-14-19:00
    10.  * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
    11.  */
    12. @Documented
    13. @Target({ElementType.PARAMETER})
    14. @Retention(RetentionPolicy.RUNTIME)
    15. public @interface IsNotNull {
    16.     boolean value() default false;
    17. }

     新建测试类Demo3，代码如下：

    1. package com.Kissship.annotation.demo3;
    2.  
    3. /**
    4.  * @author Kissship
    5.  * @site www.Kissship.com
    6.  * @company xxx公司
    7.  * @create 2023-09-14-19:00
    8.  * 获取参数修饰注解对应的属性值
    9.  */
    10. public class Demo3 {
    11.  
    12.     public void hello1(@IsNotNull(true) String name) {
    13.         System.out.println("hello:" + name);
    14.     }
    15.  
    16.     public void hello2(@IsNotNull String name) {
    17.         System.out.println("hello:" + name);
    18.     }
    19. }

    新建测试类Demo3Test，代码如下：

    1. package com.Kissship.annotation.demo3;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.lang.reflect.Method;
    6. import java.lang.reflect.Parameter;
    7.  
    8. /**
    9.  * @author Kissship
    10.  * @site www.Kissship.com
    11.  * @company xxx公司
    12.  * @create 2023-09-14-19:00
    13.  */
    14. public class Demo3Test {
    15.  
    16.     @Test
    17.     public void hello1() throws Exception {
    18.         Demo3 demo3 = new Demo3();
    19.         for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
    20.             IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
    21.             if(annotation != null){
    22.                 System.out.println(annotation.value());//true
    23.             }
    24.         }
    25.     }
    26.  
    27.     @Test
    28.     public void hello2() throws Exception {
    29.         Demo3 demo3 = new Demo3();
    30.         for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
    31.             IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
    32.             if(annotation != null){
    33.                 System.out.println(annotation.value());//false
    34.             }
    35.         }
    36.     }
    37.  
    38.     @Test
    39.     public void hello3() throws Exception {
    40. //        模拟浏览器传递到后台的参数 解读@requestParam
    41.         String name = "zs";
    42.         Demo3 demo3 = new Demo3();
    43.         Method method = demo3.getClass().getMethod("hello1", String.class);
    44.         for (Parameter parameter : method.getParameters()) {
    45.             IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
    46.             if(annotation != null){
    47.                 System.out.println(annotation.value());//true
    48.                 if (annotation.value() && !"".equals(name)){
    49.                     method.invoke(demo3,name);
    50.                 }
    51.             }
    52.         }
    53.     }
    54. }

     执行hello1方法测试结果如下：

    执行hello2方法测试结果如下：

    执行hello3方法测试结果如下：

    三、AOP自定义注解的应用

    AOP（面向切面编程）是一种编程思想，它通过在代码中定义切点和切面，来实现对程序行为的控制和扩展。在AOP中，切点表示程序中的某个特定位置，切面表示在切点处要执行的逻辑。而注解是一种元数据，它可以提供额外的信息，并且可以在编译期、运行期、甚至是部署期进行处理。

    下面演示AOP与自定义注解相结合应用实现日志记录功能，如下：

    3.1 定义自定义注解@Mylog

    用于标记记录日志的方法，如下：

    1. package com.Kissship.annotation.aop;
    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.  
    8. /**
    9.  * @author Kissship
    10.  * @site www.Kissship.com
    11.  * @company xxx公司
    12.  * @create 2023-09-14-19:00
    13.  */
    14. @Target(ElementType.METHOD)
    15. @Retention(RetentionPolicy.RUNTIME)
    16. public @interface MyLog {
    17.     String desc();
    18. }

    3.2 定义切面类MyLogAspect

    在该类中定义增强逻辑，例如记录日志等。如下：

    1. package com.Kissship.aspect;
    2.  
    3. import com.Kissship.annotation.aop.MyLog;
    4. import org.aspectj.lang.JoinPoint;
    5. import org.aspectj.lang.annotation.Aspect;
    6. import org.aspectj.lang.annotation.Before;
    7. import org.aspectj.lang.annotation.Pointcut;
    8. import org.aspectj.lang.reflect.MethodSignature;
    9. import org.slf4j.Logger;
    10. import org.slf4j.LoggerFactory;
    11. import org.springframework.stereotype.Component;
    12.  
    13. /**
    14.  * @author Kissship
    15.  * @site www.Kissship.com
    16.  * @company xxx公司
    17.  * @create 2023-09-14-19:00
    18.  */
    19. @Component
    20. @Aspect
    21. public class MyLogAspect {
    22.     private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
    23.  
    24.     /**
    25.      * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
    26.      */
    27.     @Pointcut("@annotation(com.Kissship.annotation.aop.MyLog)")
    28.     private void MyValid() {
    29.     }
    30.  
    31.     @Before("MyValid()")
    32.     public void before(JoinPoint joinPoint) {
    33.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    34.         logger.debug("[" + signature.getName() + " : start.....]");
    35.         System.out.println("[" + signature.getName() + " : start.....]");
    36.  
    37.         MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
    38.         logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
    39.         System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
    40.     }
    41. }

    在上面的切面类中，使用@Aspect注解标记该类为切面类。@Pointcut("@annotation(com.CloudJun.annotation.aop.MyLog)")注解用于定义切点，表示匹配所有标记有@Log注解的方法。@Before注解表示在目标方法执行前执行增强逻辑。

    3.3 创建一个控制器LogController

    代码如下：

    1. package com.Kissship.web;
    2.  
    3. import com.Kissship.annotation.aop.MyLog;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6.  
    7. import javax.servlet.http.HttpServletRequest;
    8.  
    9. /**
    10.  * @author Kissship
    11.  * @site www.Kissship.com
    12.  * @company xxx公司
    13.  * @create 2023-09-14-19:00
    14.  */
    15. @Controller
    16. public class LogController {
    17.  
    18.     @RequestMapping("/mylog")
    19.     @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    20.     public void testLogAspect(HttpServletRequest request){
    21.         request.getRemoteAddr();//这里是获取请求IP,可以输出或者保存在某个地方及属性
    22.         request.getRemotePort();//这里是获取请求端口,可以输出或者保存在某个地方及属性
    23.         System.out.println("来自九院压力怪————刘三金的死亡凝视");
    24.  
    25.     }
    26. }

    进行代码测试，结果如下：

    然后在切面类中( MyLogAspect ) 的 before 方法进行注释，加入doAround方法，代码如下：

    1. @Around("MyValid()")
    2.     public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    3.         long startTime = System.currentTimeMillis();
    4.         System.out.println(pjp.getTarget());//获取目标方法
    5.         System.out.println(pjp.getThis());//
    6.         Object[] args = pjp.getArgs();//获取参数
    7.         System.out.println(Arrays.toString(args));//输出参数
    8.         Object ob = pjp.proceed();//获取方法返回值
    9.         System.out.println(ob);//输出返回值
    10.         logger.info("耗时 : " + (System.currentTimeMillis() - startTime));
    11.         return ob;
    12.     }

    接着进行测试，测试结果如下：

    最后SpringMVC之自定义注解就到这里，祝大家在敲代码的路上一路通畅!

    感谢大家的观看 !

  • 相关阅读:
    力扣 -- 646. 最长数对链
    git知识点
    RPA前景、要求和学习方向
    php中使用Imagick转换PDF第一页为PNG图片并且识别出二维码
    CScrollBar 滚动条
    【Spring MVC】MVC如何浏览器请求（service方法）
    0095 贪心算法，普利姆算法
    Codeforces Round 900 (Div. 3)--E. Iva & Pav(前缀和+二分)
    Java 中的 IO 和 NIO
    Orchestrator - server_id相同导致graceful-master-takeout-auto失败
  • 原文地址：https://blog.csdn.net/weixin_74263417/article/details/132888074