• SpringMVC之自定义注解

    一.什么是SpringMVC之自定义注解

    二.Java注解简介

    Java注解分类

    JDK元注解

    三.自定义注解简介

    自定义注解的分类

    四.自定义注解的基本案例

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

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

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

    五.Aop自定义注解的应用

    Mylog前置通知

    一.什么是SpringMVC之自定义注解

    在SpringMVC中，我们可以使用自定义注解来增强代码的可读性和可维护性。通过自定义注解，我们可以在控制器类、方法或参数上添加自己定义的元数据，来标记一些特殊的行为或属性。

    使用自定义注解，我们可以为SpringMVC添加一些额外的功能或限制。例如，我们可以定义一个@LoginRequired注解，用于标记需要登录才能访问的控制器方法。在SpringMVC的拦截器中，我们可以根据该注解判断用户是否已登录，从而决定是否允许继续执行该方法。

    另外，自定义注解还可以用于参数校验、请求参数绑定、权限控制等方面。通过定义合适的注解，我们可以让SpringMVC自动进行参数校验，从而减少手动编写校验代码的工作量。

    要自定义注解，我们需要使用Java的注解定义语法，结合SpringMVC的相关功能，实现自己所需的功能。首先，我们需要定义一个注解类型，使用@interface关键字声明。然后，在注解中定义需要的元数据，并设置相应的默认值。

    接下来，我们可以在控制器类、方法或参数上使用自定义注解，来标记需要增强的行为或属性。我们还可以通过AOP等方式，根据自定义注解的类型，在程序运行时动态地对标记的代码进行处理。

    总而言之，通过自定义注解，我们可以在SpringMVC中扩展自己的功能和特性，使得代码更加灵活可扩展。

    二.Java注解简介

    Java注解分类

    JDK基本注解
    JDK元注解
    自定义注解

    JDK元注解

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

    @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})，也就是此注解可以在方法和类上面使用

    @Inherited：指定被修饰的Annotation将具有继承性

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

    三.自定义注解简介

    自定义注解的分类

    自定义注解可分为三类：元注解、标记注解和单值注解。

    1. 元注解（Meta-Annotation）：元注解用于注解其他注解，可以对注解本身进行描述和限制。Java提供了四种元注解，分别是：

      • @Retention：指定注解的生命周期，可以是源代码级别（SOURCE）、编译时（CLASS）或运行时（RUNTIME）。
      • @Target：指定注解的使用范围，可以是类、方法、字段等。
      • @Documented：指定注解是否包含在JavaDoc中。
      • @Inherited：指定注解是否可被继承。

    2. 标记注解（Marker Annotation）：标记注解也称为无成员注解，它没有定义任何成员变量。标记注解的存在本身就代表一种信息，可以被用于标识目标对象的特殊性或属性。例如，JUnit中的@Test注解就是一个标记注解。

    3. 单值注解（Single Value Annotation）：单值注解是最简单的一种注解，它只包含一个成员变量。我们可以为注解定义一个成员变量，并为其赋予默认值。在使用注解时，可以根据需要给成员变量赋值。例如，Spring中的@Autowired注解就是一个单值注解，它用于自动注入依赖对象。

    需要注意的是，以上分类是一种常见的方式，实际上可以根据需求和设计的需要进行灵活扩展和组合。通过合理使用自定义注解，可以提高代码的可读性、可维护性和扩展性。

    四.自定义注解的基本案例

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

    编写定义常量TranscationModel类

    1. package com.xy.annotation.demo1;
    2.  
    3. public enum  TranscationModel {
    4.     //定义常量
    5.     Read, Write, ReadWrite
    6. }

    编写MyAnnotation1

    1. package com.xy.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.xy.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.xy.annotation.demo1;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * @author xy集团
    7.  * @site www.javaxl.com
    8.  *
    9.  * MyAnnotation3注解可以用在方法上
    10.  * 注解运行期也保留
    11.  * 可继承
    12.  */
    13. @Target(ElementType.METHOD)
    14. @Retention(RetentionPolicy.RUNTIME)
    15. @Inherited
    16. @Documented
    17. public @interface MyAnnotation3 {
    18.     TranscationModel[] models() default TranscationModel.ReadWrite;
    19. }

    编写测试类Demo1

    1. package com.xy.annotation.demo1;
    2.  
    3. /**
    4.  * @author xy集团
    5.  * @site www.javaxl.com
    6.  *
    7.  * 获取类与方法上的注解值
    8.  */
    9. @MyAnnotation1(name = "abc")
    10. public class Demo1 {
    11.  
    12.     @MyAnnotation1(name = "xyz")
    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.xy.annotation.demo1;
    2.  
    3. import org.junit.Test;
    4.  
    5. /**
    6.  * @author xy集团
    7.  * @site www.javaxl.com
    8.  */
    9. public class Demo1Test {
    10.     @Test
    11.     public void list() throws Exception {
    12. //        获取类上的注解
    13.         MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
    14.         System.out.println(annotation1.name());//abc
    15.  
    16. //        获取方法上的注解
    17.         MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
    18.         System.out.println(myAnnotation2.model());//Read
    19.  
    20. //        获取属性上的注解
    21.         MyAnnotation1 myAnnotation1 = Demo1.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
    22.         System.out.println(myAnnotation1.name());// xyz
    23.     }
    24.  
    25.     @Test
    26.     public void edit() throws Exception {
    27.         MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
    28.         for (TranscationModel model : myAnnotation3.models()) {
    29.             System.out.println(model);//Read,Write
    30.         }
    31.     }
    32. }

    测试list结果

     测试edit结果

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

    编写TestAnnotation类

    1. package com.xy.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 xy集团
    10.  * @site www.javaxl.com
    11.  */
    12. //@Retention(RetentionPolicy.SOURCE)
    13. @Retention(RetentionPolicy.RUNTIME)
    14. @Target(ElementType.FIELD)
    15. public @interface TestAnnotation {
    16.     String value() default "默认value值";
    17.  
    18.     String what() default "这里是默认的what属性对应的值";
    19. }

    编写Demo2测试类

    1. package com.xy.annotation.demo2;
    2.  
    3. /**
    4.  * @author xy集团
    5.  * @site www.javaxl.com
    6.  *
    7.  * 获取类属性上的注解属性值
    8.  */
    9. public class Demo2 {
    10.     @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    11.     private static String msg1;
    12.  
    13.     //当没有在注解中指定属性名，那么就是value
    14.     @TestAnnotation("这就是value对应的值1")
    15.     private static String msg2;
    16.  
    17.     @TestAnnotation(value = "这就是value对应的值2")
    18.     private static String msg3;
    19.  
    20.     @TestAnnotation(what = "这就是what对应的值")
    21.     private static String msg4;
    22. }

    编写Demo2Tes测试类

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

    测试test1结果

    测试test2结果

    测试test3结果

    测试test4结果

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

    编写IsNotNull类

    1. package com.xy.annotation.Demo3;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * @author xy集团
    7.  * @site www.javaxl.com
    8.  *
    9.  * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
    10.  */
    11. @Documented
    12. @Target({ElementType.PARAMETER})
    13. @Retention(RetentionPolicy.RUNTIME)
    14. public @interface IsNotNull {
    15.     boolean value() default false;
    16. }

     编写Demo3测试类

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

     编写Demo3Test测试类

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

    测试hello1结果

    测试hello2结果

    测试hello3结果

    五.Aop自定义注解的应用

    Mylog前置通知

    编写Mylog前置通知类

    1. package com.xy.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 xy集团
    10.  * @site www.javaxl.com
    11.  */
    12. @Target(ElementType.METHOD)
    13. @Retention(RetentionPolicy.RUNTIME)
    14. public @interface MyLog {
    15.     String desc();
    16. }

    编写MyLogAspect切面类

    1. package com.xy.aspect;
    2.  
    3. import com.xy.annotation.aop.MyLog;
    4. import org.aspectj.lang.JoinPoint;
    5. import org.aspectj.lang.ProceedingJoinPoint;
    6. import org.aspectj.lang.annotation.Around;
    7. import org.aspectj.lang.annotation.Aspect;
    8. import org.aspectj.lang.annotation.Before;
    9. import org.aspectj.lang.annotation.Pointcut;
    10. import org.aspectj.lang.reflect.MethodSignature;
    11. import org.slf4j.Logger;
    12. import org.slf4j.LoggerFactory;
    13. import org.springframework.stereotype.Component;
    14.  
    15. import java.util.Arrays;
    16.  
    17. /**
    18.  * @author xy集团
    19.  * @site www.javaxl.com
    20.  */
    21. @Component
    22. @Aspect
    23. public class MyLogAspect {
    24.     private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
    25.  
    26.     /**
    27.      * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
    28.      */
    29.     @Pointcut("@annotation(com.xy.annotation.aop.MyLog)")
    30.     private void MyValid() {
    31.     }
    32.  
    33. //    @Before("MyValid()")
    34. //    public void before(JoinPoint joinPoint) {
    35. //        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    36. //        logger.debug("[" + signature.getName() + " : start.....]");
    37. //        System.out.println("[" + signature.getName() + " : start.....]");
    38. //
    39. //        MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
    40. //        logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
    41. //        System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
    42. //    }
    43.  
    44.  
    45.     @Around("MyValid()")
    46.     public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    47.         long startTime = System.currentTimeMillis();
    48.         System.out.println(pjp.getTarget());//获取目标方法
    49.         System.out.println(pjp.getThis());//
    50.         Object[] args = pjp.getArgs();//获取参数
    51.         System.out.println(Arrays.toString(args));//输出参数
    52.         Object ob = pjp.proceed();//获取方法返回值
    53.         System.out.println(ob);//输出返回值
    54.         logger.info("耗时 : " + (System.currentTimeMillis() - startTime));
    55.         return ob;
    56.     }
    57.  
    58. }

     编写LogController类

    1. package com.xy.web;
    2.  
    3. import com.xy.annotation.aop.MyLog;
    4. import org.springframework.stereotype.Component;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7.  
    8. /**
    9.  * @author xy集团
    10.  * @site www.javaxl.com
    11.  */
    12. @Controller
    13. public class LogController {
    14.  
    15.     @RequestMapping("/mylog")
    16.     @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    17.     public void testLogAspect(){
    18.         System.out.println("这里随便来点啥");
    19.     }
    20. }

    测试结果（先走前置通知）

      测试结果

  • 相关阅读:
    Qt学习04 Hello Qt
    面向城市巡防的多无人机协同航迹规划
    SpringMVC学习笔记（三）
    进程状态
    打造硬核敲门砖——简历
    Springboot毕设项目绿色生鲜5954z（java+VUE+Mybatis+Maven+Mysql）
    仿热血江湖游戏类45method_3、method_4
    前端面试常见问题总结
    电力系统规划学习笔记（长期更新）
    基于HTML+CSS+JavaScript制作简单的大学生网页设计——关于我的家乡湖南网页设计主题
  • 原文地址：https://blog.csdn.net/2201_75455485/article/details/132887991