SpringMVC之自定义注解（这期博客带你领略自定义注解的魅力）

        Java注解是Java语言的一种特殊语法元素，它可以用来为代码添加额外的元数据信息。注解可以用于类、方法、变量、参数等各种程序元素上。注解的作用是为程序的其他部分提供额外的信息，以便编译器、解析器或者运行时环境在处理这些程序元素时能够根据注解的信息进行相应的处理。

        Java注解通常使用自定义注解或者内置的预定义注解，例如@Override、@Deprecated等。你也可以根据需要自定义注解。

        使用Java注解的好处是可以通过注解为代码添加更多的语义信息，提高代码的可读性和可维护性。注解还可以用于实现一些框架、库或者工具的功能，例如JUnit测试框架、Spring框架等。

2. Java注解分类

2.1 JDK基本注解

JDK提供的一些基本注解，它们提供了编译器级别的信息和指导，可以帮助开发者编写更准确、更高效的代码。

**JDK基本注解**
注解	注解说明
@Override	用于标注方法，表示该方法是覆盖父类的方法。当方法标记了`@Override`注解但实际没有覆盖父类方法时，编译器会给出警告。
@Deprecated	用于标注过时的方法、类、字段等。表示该项已不推荐使用，可能会在未来的版本中删除或替换。
@SuppressWarnings	用于抑制某些特定警告，可以应用于类、方法、变量等。此注解可以接受一个或多个参数，用于指定要抑制的警告类型。
@SafeVarargs	用于标记方法，表示方法是类型安全的可变参数方法。在使用可变参数的方法时，编译器会给出警告，但在使用`@SafeVarargs`注解后，可以抑制这种警告。
@FunctionalInterface	用于标记接口，表示该接口是函数式接口。函数式接口是只包含一个抽象方法的接口，常用于Lambda表达式和函数式编程。
@SuppressWarnings("serial")	用于抑制未序列化警告。在自定义的可序列化类中，如果没有指定`serialVersionUID`字段，编译器会给出警告，通过使用`@SuppressWarnings("serial")`注解可以抑制此警告。

2.2 JDK元注解

JDK元注解是指Java开发工具包（JDK）中提供的一组用于标记和定义其他注解的注解。它们是Java语言提供的预定义注解，用于在编写和使用自定义注解时提供更多的控制和附加信息。

**JDK云注解**
注解	注解说明
@Retention	用于指定注解的保留策略，有三种保留策略可选，分别是RetentionPolicy.SOURCE、RetentionPolicy.CLASS和RetentionPolicy.RUNTIME。默认为RetentionPolicy.CLASS。（定义注解的保留策略）
@Documented	用于指定被该注解修饰的元素是否需要包含在Java文档中。（指定被修饰的该Annotation可以被javadoc工具提取成文档.）
@Target	用于指定注解适用的目标元素类型，可以是类、方法、字段等。常见的取值有ElementType.TYPE、ElementType.METHOD、ElementType.FIELD等。
@Inherited	用于指定被该注解修饰的类是否可以被子类继承，默认不会被子类继承。（指定被修饰的Annotation将具有继承性）
@Repeatable	用于指定注解是否可以重复应用于同一元素上，以便实现多次注解该元素的效果。

注：

@Retention：

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

@Target：

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

2.3 自定义注解

        自定义注解是指在Java中使用开发者自己定义的注解（Annotation）。注解是一种元数据，它提供了程序额外的信息，可以用于在代码中添加标记、配置和动态行为。

        通过自定义注解，开发者可以根据自己的需求，给类、方法、字段等元素添加额外的信息和语义。自定义注解需要使用Java提供的注解元编程机制，使用特定的注解元素和注解处理器来实现。

        自定义注解的定义方式和普通接口类似，使用关键字@interface定义注解，然后在其中定义注解元素。

案例：

import java.lang.annotation.*;

@Target(ElementType.TYPE) // 指定注解应用的目标类型（这里是类）
@Retention(RetentionPolicy.RUNTIME) // 指定注解保留的策略（这里是运行时）
public @interface MyAnnotation {
    String value() default ""; // 定义注解元素
}

上述代码示例定义了一个名为MyAnnotation的自定义注解。该注解可以被应用于类（ElementType.TYPE），并且在运行时（RetentionPolicy.RUNTIME）保留注解信息。注解中定义了一个名为value的注解元素。

二、自定义注解（SpringMVC中运用）

案例讲解

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

部署测试（定义三个常量）

创建一个annotation文件夹，在文件下创建一个TranscationModel.java类及测试类

TranscationModel.java

package com.yx.annotation;

public enum  TranscationModel {
    Read, Write, ReadWrite
}

对应的测试类

package com.yx.annotation;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 测试类
 *
 */
public class Test01 {


    public static void main(String[] args) {
        System.out.println(TranscationModel.Read);
        System.out.println(TranscationModel.Write);
        System.out.println(TranscationModel.ReadWrite);
    }
}

运行结果

定义编写三个自定义标签类

自定义标签01（MyAnnotation1.java）

package com.yx.annotation.demo01;

import java.lang.annotation.*;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 注解1
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation1 {
    String name();
}

自定义标签02（MyAnnotation2.java）

package com.yx.annotation.demo01;

import java.lang.annotation.*;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 注解02
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

自定义标签03（MyAnnotation3.java）

package com.yx.annotation.demo01;

import java.lang.annotation.*;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * @create  2023-09-15 16:42
 * 注解03
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

测试结果

list()方法测试结果

edit()方法测试结果

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

测试的是value的默认值和default默认值的赋予。

编写的自定义标签类

package com.yx.annotation.demo02;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";

    String what() default "这里是默认的what属性对应的值";
}

测试案例

package com.yx.annotation.demo02;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * 获取类属性上的注解属性值
 */
public class Demo2 {
    @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    private static String msg1;

    @TestAnnotation("这就是value对应的值1")
    private static String msg2;

    @TestAnnotation(value = "这就是value对应的值2")
    private static String msg3;

    @TestAnnotation(what = "这就是what对应的值")
    private static String msg4;
}

测试卷类代码

package com.yx.annotation.demo02;

import org.junit.Test;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());
        System.out.println(msg1.what());
    }

    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());
        System.out.println(msg2.what());
    }

    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());
        System.out.println(msg3.what());
    }

    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());
        System.out.println(msg4.what());
    }
}

测试结果

test()02测试结果

test()03测试结果

test()04测试结果

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

编写的自定义标签类

package com.yx.annotation.demo03;

import java.lang.annotation.*;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

测试案例

package com.yx.annotation.demo03;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 * 获取参数修饰注解对应的属性值
 */
public class Demo3 {

    public void hello1(@IsNotNull(true) String name) {
        System.out.println("hello:" + name);
    }

    public void hello2(@IsNotNull String name) {
        System.out.println("hello:" + name);
    }
}

测试卷类代码

package com.yx.annotation.demo03;

import org.junit.Test;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;


/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
public class Demo3Test {

    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
            }
        }
    }

    @Test
    public void hello2() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//false
            }
        }
    }

    @Test
    public void hello3() throws Exception {
//        模拟浏览器传递到后台的参数 解读@requestParam
        String name = "zs";
        Demo3 demo3 = new Demo3();
        Method method = demo3.getClass().getMethod("hello1", String.class);
        for (Parameter parameter : method.getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
                if (annotation.value() && !"".equals(name)){
                    method.invoke(demo3,name);
                }
            }
        }
    }
}

测试结果

hello1()方法测试结果

hello2()方法测试结果

hello3()方法测试结果

hello1()方法测试结果（name属性为空）

不给name属性值则不调用方法

三、Aop自定义注解案例（重点）

测试案例

MyLog.java

package com.yx.annotation.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

切面类

MyLogAspect.java

package com.yx.aspect;

import com.yx.annotation.aop.MyLog;
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;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);

    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.yx.annotation.aop.MyLog)")
    private void MyValid() {
    }

    @Before("MyValid()")
    public void before(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());
    }
}

控制器类

LogController.java

package com.yx.web;

import com.yx.annotation.aop.MyLog;
import org.springframework.stereotype.Controller;

/**
 * @author 君易--鑨
 * @site www.yangxin.com
 * @company 木易
 */
@Controller
public class LogController {

    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(){
        System.out.println("这里随便来点啥");
    }
}