• 【springMvc】自定义注解的使用方式

                                                    🎬 艳艳耶✌️：个人主页

                                                    🔥 个人专栏 ：《Spring与Mybatis集成整合》

                                                    ⛺️  生活的理想，为了不断更新自己 !

    1.前言

    1.1.什么是注解

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

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

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

    1.2.注解的用处

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

     1.3.注解的原理

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

    2.注解的案列：

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

                    定义一个类：

    1. package com.sy.annotation.pi;
    2.  
    3. public enum  TranscationModel {
    4.     Read, Write, ReadWrite    //定义三个实例，可以将它看作类
    5.  
    6. }

                   写三个注解：

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

    创建几个方法使用这些注解

    1. package com.sy.annotation.Demo1;
    2.  
    3. import com.sy.annotation.MyAnnotation1;
    4. import com.sy.annotation.MyAnnotation2;
    5. import com.sy.annotation.MyAnnotation3;
    6. import com.sy.annotation.TranscationModel;
    7.  
    8. /**
    9.  * @author shenyan
    10.  *
    11.  * 获取类与方法上的注解值
    12.  */
    13. @MyAnnotation1(name = "艳艳耶")
    14. public class Demo1 {
    15.  
    16.     @MyAnnotation1(name = "csdn")
    17.     private Integer age;
    18.  
    19.     @MyAnnotation2(model = TranscationModel.Read)
    20.     public void list() {
    21.         System.out.println("list");
    22.     }
    23.  
    24.     @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    25.     public void edit() {
    26.         System.out.println("edit");
    27.     }
    28. }

    最后，进行测试

     2.2  案例二（获取类属性上的注解属性值，默认值的赋予）

            自定义一个注解，并赋予默认值：

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

      建立类测试：

                    有些两个值都赋予了，有些只赋予了一个

    1. package com.sy.annotation.Demo2;
    2.  
    3. /**
    4.  * @author shenyan
    5.  *
    6.  * 获取类属性上的注解属性值
    7.  */
    8. public class Demo2 {
    9.     @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    10.     private static String msg1;
    11.  
    12.     @TestAnnotation("这就是value对应的值1")
    13.     private static String msg2;
    14.  
    15.     @TestAnnotation(value = "这就是value对应的值2")
    16.     private static String msg3;
    17.  
    18.     @TestAnnotation(what = "这就是what对应的值")
    19.     private static String msg4;
    20. }

       测试结果：

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

                    同样，先建立一个非空注解

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

     建立方法，进行测试：

    1. package com.sy.annotation.Demo3;
    2.  
    3. import com.sy.annotation.IsNotNull;
    4.  
    5. /**
    6.  * @author shenyan
    7.  *
    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. }

    测试类：

    方法1：

    方法2：

    方法3：

    3.AOP结合自定义注解案例

            配置相关AOP  pom文件

    1.         <dependency>
    2.             <groupId>org.springframework.boot</groupId>
    3.             <artifactId>spring-boot-starter-aop</artifactId>
    4.         </dependency>

           applicationContext.xml

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    5.        xmlns:aop="http://www.springframework.org/schema/aop"
    6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    7.     
    8.     
    9.     <context:annotation-config/>
    10.     
    11.     <context:component-scan base-package="com.zking"/>
    12.     
    13.     <aop:aspectj-autoproxy />
    14.  
    15. beans>

     定义一个标志日志的注解

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

    再创建一个切面类 LogAspect，用于实现日志记录的逻辑。

    1. package com.sy.annotation.aop;
    2.  
    3. import com.sy.annotation.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 shenyan
    15.  */
    16. @Component
    17. @Aspect
    18. public class MyLogAspect {
    19.     private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
    20.  
    21.     /**
    22.      * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
    23.      */
    24.     @Pointcut("@annotation(com.sy.annotation.MyLog)")
    25.     private void MyValid() {
    26.     }
    27.  
    28.     @Before("MyValid()")
    29.     public void before(JoinPoint joinPoint) {
    30.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    31.         logger.debug("[" + signature.getName() + " : start.....]");
    32.         System.out.println("[" + signature.getName() + " : start.....]");
    33.  
    34.         MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
    35.         logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
    36.         System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
    37.     }
    38.  
    39.  
    40. }

    在方法上运用日志注解

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

    运行结果： 

                                                               今日分享结束！

  • 相关阅读:
    [EI分享] 2022年第六届船舶，海洋与海事工程国际会议（NAOME 2022)
    Conda Channel 介绍与配置
    魔兽地图编辑器电脑不会主动放技能的问题
    写一篇nginx配置指南
    Android AIDEGen tools基本使用
    LQ0181 拉马车【文本处理】
    运放-电压采集采样电路设计
    CollectionUtils常用方法
    ✨✨✨if __name__ == “__main__“ 在 Python 中意味着什么？
    互补格雷码+相移码求解三维点云
  • 原文地址：https://blog.csdn.net/2301_76988707/article/details/132900886