Java自定义注解

注解分类（根据Annotation是否包含成员变量,可以把Annotation分为两类）:标记Annotation:没有成员变量的Annotation;这种Annotation仅利用自身的存在与否来提供信息元数据Annotation:包含成员变量的Annotation;它们可以接受(和提供)更多的元数据;

文章共4,353字 · 阅读需要大约15分钟

一键AI生成摘要，助你高效阅读

问答

七月472

13297人浏览 · 2022-11-05 17:14:09

七月472 · 2022-11-05 17:14:09 发布

一、什么是自定义注解

1）Java注解简介

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

2）Java注解分类

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

JDK基本注解

@Override
重写

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

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工具提取成文档.

自定义注解

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

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

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

如何自定义注解？

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

二、自定义注解

常见的自定义注解有四种：注解用在类上面、注解用在方法上面、注解用在属性上面、注解用在参数上面

@Target

@Target里面标记的属性，决定了你自定义注解能放在哪里使用，将METHOD改为TEPY或者使用逗号分隔在后面添加也行，这样方法，类，属性都可以使用这个注解类了

如果不知道该注解是干嘛用的，可以点进去查看，Ctrl+鼠标键

@Retention一共有三种：source、class、runtime

如果属性是value的话，可以省略value=

1）获取类上注解值

使用自定义注解就是为了拿这上面的数据的

MyAnnotation1.java

package com.xiaokun.ssm.annotation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * @author 小坤
 * @create  2022-10-28 20:09
 */
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation1 {
 
//    指的是注解中的属性
    public String desc() default "desc可以修饰符、方法、属性";
    public String value() default "value可以修饰符、方法、属性";
}

MyAnnotation2.java

package com.xiaokun.ssm.annotation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * @author 小坤
 * @create  2022-10-28 20:09
 */
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation2 {
 
//    指的是注解中的属性
    public String desc() default "desc可以修饰符、方法、属性";
    public String value() default "value可以修饰符、方法、属性";
}

Studentcontroller.java

package com.xiaokun.ssm.annotation;
 
/**
 * @author 小坤
 * @create  2022-10-28 20:11
 */
@MyAnnotation1(desc = "标记在类上面")
public class Studentcontroller {
 
    @MyAnnotation1("标记在属性id上面")
    private String id;
    @MyAnnotation1("标记在属性name上面")
    private String name;
    @MyAnnotation1
    public void test1(@MyAnnotation2("用来修饰id参数") String id,@MyAnnotation2("用来修饰name参数") String name){
        System.out.println("测试...");
    }
 
 
 
}

Demo1.java

package com.jwj.ssm.annotation.demo;
 
import com.xiaokun.ssm.annotation.MyAnnotation1;
import com.xiaokun.ssm.annotation.Studentcontroller;
 
/**
 * @author 小坤
 * @create  2022-10-28 22:10
 *
 * 目标：
 * 1.获取studentController 类上自定义注解 中的内容
 * 2.获取studentController 方法上自定义注解 中的内容
 * 3.获取studentController 属性上自定义注解 中的内容
 * 4.获取studentController 参数上自定义注解 中的内容
 * * *..*Service.*pager(..)
 * com.zking.service.BookService.queryPager(..);
 * com.zking.service.OrderService.queryPager(..);
 */
public class Demo1 {
    public static void main(String[] args) {
//        拿到类、拿注解
        MyAnnotation1 annotation = Studentcontroller.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation.value());
        System.out.println(annotation.desc());
    }
}

这个时候我们运行main方法时，程序会报错，图中详讲，看图😜

2）获取类属性上的注解属性值

Demo1.java

package com.xiaokun.ssm.annotation.demo;
 
import com.xiaokun.ssm.annotation.MyAnnotation1;
import com.xiaokun.ssm.annotation.MyAnnotation2;
import com.xiaokun.ssm.annotation.Studentcontroller;
 
import java.lang.reflect.Field;
 
/**
 * @author 小坤
 * @create  2022-10-28 22:10
 *
 * 目标：
 * 1.获取studentController 类上自定义注解 中的内容
 * 2.获取studentController 方法上自定义注解 中的内容
 * 3.获取studentController 属性上自定义注解 中的内容
 * 4.获取studentController 参数上自定义注解 中的内容
 * * *..*Service.*pager(..)
 * com.zking.service.BookService.queryPager(..);
 * com.zking.service.OrderService.queryPager(..);
 */
public class Demo1 {
    public static void main(String[] args) throws NoSuchFieldException {
//        拿到类、拿注解
        MyAnnotation1 annotation = Studentcontroller.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation.value());
        System.out.println(annotation.desc());
 
//        获取属性上的
        Field id = Studentcontroller.class.getDeclaredField("id");
        Field name = Studentcontroller.class.getDeclaredField("name");
        System.out.println(id.getAnnotation(MyAnnotation1.class).value());
        System.out.println(name.getAnnotation(MyAnnotation1.class).value());
 


    }
}

运行结果如图：

3）获取方法上的注解值

//        获取到方法上的
        Method m1 = Studentcontroller.class.getDeclaredMethod("test1", String.class, String.class);
        System.out.println(m1.getAnnotation(MyAnnotation1.class).value());

4）获取参数修饰注解对应的属性值

//        获取参数上的标识
        for (Parameter p : m1.getParameters()) {
            System.out.println(p.getAnnotation(MyAnnotation2.class).value());
 
        }

三、aop应用自定义注解

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

aop相关术语介绍

连接点（Joinpoint)：程序执行的某个特定位置，如某个方法调用前，调用后，方法抛出异常后，这些代码中的特定点称为连接点；简单来说，就是在哪加入你的逻辑增强，连接点表示具体要拦截的方法，切点是定义一个范围，而连接点是具体到某个方法
切点（PointCut）：每个程序的连接点有多个，如何定位到某个感兴趣的连接点，就需要通过切点来定位。比如，连接点是数据库的记录，切点是查询条件；切点用于来限定Spring-AOP启动的范围，通常我们采用表达式的方式来设置，所以关键词是范围
增强（Advice）：增强是织入到目标类连接点上的一段程序代码；在Spring中，像BeforeAdvice等还带有方位信息；通知是直译过来的结果，我个人感觉叫做“业务增强”更合适，对照代码就是拦截器定义的相关方法，通知分为如下几种：

前置通知（before）：在执行业务代码前做些操作，比如获取连接对象
后置通知（after）：在执行业务代码后做些操作，无论是否发生异常，它都会执行，比如关闭连接对象
异常通知（afterThrowing）：在执行业务代码后出现异常，需要做的操作，比如回滚事务
返回通知（afterReturning）：在执行业务代码后无异常，会执行的操作
环绕通知（around）：环绕通知可以在方法调用前后完成自定义的行为，它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行

目标对象（Target）：需要被加强的业务对象

织入（Weaving）：织入就是将增强添加到对目标类具体连接点上的过程；织入是一个形象的说法，具体来说，就是生成代理对象并将切面内容融入到业务流程的过程。

代理类（Proxy）：一个类被AOP织入增强后，就产生了一个代理类

切面（Aspect）：切面由切点和增强组成，它既包括了横切逻辑的定义，也包括了连接点的定义，SpringAOP就是将切面所定义的横切逻辑织入到切面所制定的连接点中。SpringAOP将切面定义的内容织入到我们的代码中，从而实现前后的控制逻辑。比如我们常写的拦截器Interceptor，就是一个切面类

自定义注解日志的使用

DemoController.java

package com.xiaokun.ssm.annotation.aop;
 
import org.springframework.stereotype.Controller;
 
/**
 * @author 小坤
 * @create  2022-10-29 14:19
 */
@Controller
public class DemoController {
    @MyLog(desc = "这是一个测试类的方法")
    public void test(){
        System.out.println("测试方法");
    }
}

MyLog.java

package com.xiaokun.ssm.annotation.aop;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

MyLogAspect .java

package com.xiaokun.ssm.annotation.aop;
 
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;
 
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
 
    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.jwj.ssm.annotation.aop.MyLog)")
//    这是以前的写法 @Around("execution"(* *..*Service.*Pager(..))")
//   上面这个已经把这个替代掉了 @Pointcut("@execution(* *.*Controller.add())")
    private void MyValid() {
    }
 
    @Before("MyValid()")
    public void before(JoinPoint 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());
    }
}

添加测试方法

AnnotationTest.java

package com.xiaokun.shiro;
 
import com.xiaokun.ssm.annotation.aop.DemoController;
import com.xiaokun.ssm.biz.ClazzBiz;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * @author 小坤
 * @create  2022-10-27 22:21
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class AnnotationTest {
    @Autowired
    private DemoController demoController;
 
    @Test
    public void test1(){
        demoController.test();
    }
}