• 自定义注解

    目录

    1.java注解简介

    1.1.java注解分类

    1.2.JDK基本注解

    1.3.JDK元注解

    1.4.自定义注解

    1.5.如何自定义注解？

    2.自定义注解

    3.aop应用自定义注解

    3.1.自定义注解日志的使用

    3.2自定义注解数据字典的使用 

    1.java注解简介

    Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。 注解相关类都包含在java.lang.annotation包中。

    1.1.java注解分类

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

    1.2.JDK基本注解

    @Override
    重写

    @SuppressWarnings(value = "unchecked")
    压制编辑器警告

    1.3.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.4.自定义注解

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

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

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

    1.5.如何自定义注解？

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

    2.自定义注解

     @interface注解修饰符

     如果属性是value的话可以不写，如果是其他就必须要写。

    MyAnnotation
    1. package com.xbb.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冰冰
    10.  * @create  2022-11-03 14:38
    11.  */
    12. @Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
    13. @Retention(RetentionPolicy.RUNTIME)
    14. public @interface MyAnnotation {
    15.     //指的是注解里面的属性
    16.     public String desc() default "desc可以修饰符、方法、属性";
    17.     public String value() default "value可以修饰符、方法、属性";
    18.  
    19.  
    20. }
    MyAnnotation2
    1. package com.xbb.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冰冰
    10.  * @create  2022-11-03 15:18
    11.  */
    12. @Target({ElementType.PARAMETER})
    13. @Retention(RetentionPolicy.RUNTIME)
    14. public @interface MyAnnotation2 {
    15.  
    16.     //    指的是注解中的属性
    17.     public String desc() default "desc可以修饰符、方法、属性";
    18.     public String value() default "value可以修饰符、方法、属性";
    19.  
    20. }

    StudentController
    1. package com.xbb.annotation;
    2.  
    3. /**
    4.  * @author冰冰
    5.  * @create  2022-11-03 14:44
    6.  */
    7. @MyAnnotation(desc = "标记在类上面")
    8. public class StudentController {
    9.     @MyAnnotation("标记在属性id上面")
    10.     private String id;
    11.     @MyAnnotation("标记在属性name上面")
    12.     private String name;
    13.     @MyAnnotation
    14.     public void test1(@MyAnnotation2("用来修饰id参数") String id,@MyAnnotation2("用来修饰name参数") String name){
    15.         System.out.println("测试...");
    16.     }
    17.  
    18. }
    Demo1
    1. package com.xbb.demo;
    2.  
    3. import com.xbb.annotation.MyAnnotation;
    4. import com.xbb.annotation.MyAnnotation2;
    5. import com.xbb.annotation.StudentController;
    6.  
    7. import java.lang.reflect.Field;
    8. import java.lang.reflect.Method;
    9.  
    10. /**
    11.  * @author冰冰
    12.  * @create  2022-11-03 15:11
    13.  *
    14.  * 目标：
    15.  * 1.获取studentController 类上自定义注解 中的内容
    16.  * 2.获取studentController 方法上自定义注解 中的内容
    17.  * 3.获取studentController 属性上自定义注解 中的内容
    18.  * 4.获取studentController 参数上自定义注解 中的内容
    19.  **/
    20. public class Demo1 {
    21.     public static void main(String[] args) throws Exception {
    22. //        拿到类、拿注解
    23.         MyAnnotation annotation = StudentController.class.getAnnotation(MyAnnotation.class);
    24.         System.out.println(annotation.value());
    25.         System.out.println(annotation.desc());
    26.  
    27. //        获取属性上的
    28.         Field id = StudentController.class.getDeclaredField("id");
    29.         Field name = StudentController.class.getDeclaredField("name");
    30.         System.out.println(id.getAnnotation(MyAnnotation.class).value());
    31.         System.out.println(name.getAnnotation(MyAnnotation.class).value());
    32.  
    33. //        获取到方法上的
    34.         Method m1 = StudentController.class.getDeclaredMethod("test1", String.class, String.class);
    35.         System.out.println(m1.getAnnotation(MyAnnotation.class).value());
    36.  
    37. //        获取参数上的标识
    38.         for (Parameter p : m1.getParameters()) {
    39.             System.out.println(p.getAnnotation(MyAnnotation2.class).value());
    40.  
    41.  
    42.     }
    43. }

    3.aop应用自定义注解

    在我们做的系统中，有时需要记录操作日志，方便找到某个操作是谁进行的，这个可以用spring的aop来实现，本篇博客记录用自定义注解+aop应用于springboot项目中实现操作日志的记录

    1、aop相关术语介绍

    连接点（Joinpoint)： 程序执行的某个特定位置，如某个方法调用前，调用后，方法抛出异常后，这些代码中的特定点称为连接点；简单来说，就是在哪加入你的逻辑增强，连接点表示具体要拦截的方法，切点是定义一个范围，而连接点是具体到某个方法
    切点（PointCut）：每个程序的连接点有多个，如何定位到某个感兴趣的连接点，就需要通过切点来定位。比如，连接点是数据库的记录，切点是查询条件；切点用于来限定Spring-AOP启动的范围，通常我们采用表达式的方式来设置，所以关键词是范围
    增强（Advice）：增强是织入到目标类连接点上的一段程序代码；在Spring中，像BeforeAdvice等还带有方位信息；通知是直译过来的结果，我个人感觉叫做“业务增强”更合适，对照代码就是拦截器定义的相关方法，通知分为如下几种：
           前置通知（before）：在执行业务代码前做些操作，比如获取连接对象
           后置通知（after）：在执行业务代码后做些操作，无论是否发生异常，它都会执行，比如关闭连接对象
           异常通知（afterThrowing）：在执行业务代码后出现异常，需要做的操作，比如回滚事务
           返回通知（afterReturning）：在执行业务代码后无异常，会执行的操作
           环绕通知（around）：环绕通知可以在方法调用前后完成自定义的行为，它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行

    目标对象（Target）：需要被加强的业务对象
    织入（Weaving）：织入就是将增强添加到对目标类具体连接点上的过程；织入是一个形象的说法，具体来说，就是生成代理对象并将切面内容融入到业务流程的过程。
    代理类（Proxy）：一个类被AOP织入增强后，就产生了一个代理类
    切面（Aspect）：切面由切点和增强组成，它既包括了横切逻辑的定义，也包括了连接点的定义，SpringAOP就是将切面所定义的横切逻辑织入到切面所制定的连接点中。SpringAOP将切面定义的内容织入到我们的代码中，从而实现前后的控制逻辑。 比如我们常写的拦截器Interceptor，就是一个切面类
     

    3.1.自定义注解日志的使用

    DeomController
    1. package com.xbb.aop;
    2.  
    3. import org.springframework.stereotype.Controller;
    4.  
    5. /**
    6.  * @author冰冰
    7.  * @create  2022-11-03 15:49
    8.  */
    9. @Controller
    10. public class DeomController {
    11.     @MyLog(desc = "测试类的方法")
    12.     public void  test(){
    13.         System.out.println("测试方法");
    14.  
    15.     }
    16. }
    MyLog
    1. package com.xbb.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冰冰
    10.  * @create  2022-11-03 15:48
    11.  */
    12. @Target(ElementType.METHOD)
    13. @Retention(RetentionPolicy.RUNTIME)
    14. public @interface MyLog {
    15.     String desc();
    16. }
    MyLogAspect
    1. package com.xbb.aop;
    2.  
    3. import org.aspectj.lang.JoinPoint;
    4. import org.aspectj.lang.annotation.Aspect;
    5. import org.aspectj.lang.annotation.Before;
    6. import org.aspectj.lang.annotation.Pointcut;
    7. import org.aspectj.lang.reflect.MethodSignature;
    8. import org.slf4j.Logger;
    9. import org.slf4j.LoggerFactory;
    10. import org.springframework.stereotype.Component;
    11.  
    12. /**
    13.  * @author冰冰
    14.  * @create  2022-11-03 15:52
    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.xbb.aop.MyLog)")
    25.     private void MyValid() {
    26.     }
    27.  
    28.     @Before("MyValid()")
    29.     public void before(JoinPoint joinPoint) {
    30.  
    31.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    32.         logger.debug("[" + signature.getName() + " : start.....]");
    33.         System.out.println("[" + signature.getName() + " : start.....]");
    34.  
    35.         MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
    36.         logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
    37.         System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
    38.     }
    39. }

    测试类：

    1. @RunWith(SpringJUnit4ClassRunner.class)
    2. @ContextConfiguration(locations={"classpath:applicationContext.xml"})
    3. public class AnnotationTest {
    4.     @Autowired
    5.     private DemoController demoController;
    6.  
    7.     @Test
    8.     public void test1(){
    9.         demoController.test();
    10.     }
    11. }

    3.2自定义注解数据字典的使用 

    学习网址：

    http://47.100.191.44/index

  • 相关阅读:
    累计-同比
    Debezium系列之：Debezium技术专栏第300篇系列文章之打通Debezium实时采集Oracle数据库数据到Kafka集群的技术
    linux 设备树的由来与使用
    Jmeter接口测试 —— jmeter对图片验证码的处理
    发现流程任务的提交时间不对，@JsonFormat时间格式及时区问题
    SpringBoot整合Swagger详解
    Linux设置用户密码过期时间或永不过期
    Android Jetpack系列（一）起始篇：Jetpack 的前世今生
    R语言使用table1包绘制（生成）三线表、使用单变量分列构建三线表、自定义为指定的分列因子添加分组标签、编写自定义函数指定统计量的呈现方式
    使用ASP.NET Core封装接口请求参数格式
  • 原文地址：https://blog.csdn.net/m0_68211831/article/details/127669648