【SpringMVC】自定义注解-阿里云开发者社区

自定义注解及其应用

前言

在Java编程中，注解（Annotation）是一种用来向程序中添加元数据的方式，它可以在不改变代码逻辑的情况下对程序进行补充说明和配置。本文将介绍注解的定义、分类以及在实际开发中的应用。

1. 什么是注解？

注解是一种特殊的接口类型，它以@符号开头，可以附加在类、方法、字段等程序元素上，为这些元素添加额外的信息和属性。通过使用注解，我们可以在编译时或运行时对程序进行检查、配置和生成相应的代码。

2. 注解的用处

注解具有以下几个主要用途：

提供给编译器和工具进行代码分析和处理。

在运行时动态地获取和处理注解信息。

生成文档、代码和其他资源文件。

注解的使用可以减少冗余的配置代码，提高代码的可读性和维护性，同时还能够增强程序的灵活性和可扩展性。

3. 注解的原理

注解的原理主要基于Java的反射机制。在程序运行时，可以通过反射API获取被注解元素的相关信息，并根据注解定义的规则进行相应的处理。这使得开发者可以在运行时对程序进行动态配置和扩展。

注解的分类

Java中的注解可以分为三类：JDK基本注解、JDK元注解和自定义注解。接下来分别介绍它们的特点和用途。

JDK基本注解

1.1. @Override

@Override注解用于标识方法覆盖父类或实现接口中的方法，可以帮助我们检查方法是否正确地覆盖了父类或接口中的方法。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

1.2. @SuppressWarnings

@SuppressWarnings注解用于抑制编译器警告信息，可以指定忽略某些特定类型的警告。

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

2. JDK元注解

JDK元注解是用来注解其他注解的注解，它们主要用于控制注解的行为和作用范围。

2.1. @Retention

@Retention注解用于指定注解的生命周期，即注解在什么时候丢弃。常用的值包括SOURCE（编译时丢弃）、CLASS（编译时保留，运行时丢弃）和RUNTIME（运行时保留）。

@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE)
@java.lang.annotation.Target({java.lang.annotation.ElementType.TYPE})
public @interface Slf4j {
    java.lang.String topic() default "";
}

2.2. @Target

@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) //包

2.3. @Inherited

@Inherited注解用于指示某个注解是否可以被继承，默认情况下注解是不可继承的。

2.4. @Documented

@Documented注解用于指定注解是否会出现在生成的Java文档中。

3. 自定义注解

3.1. 自定义注解的分类

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

标记Annotation:

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

元数据Annotation:

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

注解类

MyAnnotation1

package com.niyin.annotation.demo1;
import java.lang.annotation.*;
/**
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation1 {
    String name();
}

MyAnnotation2

package com.niyin.annotation.demo1;
import com.niyin.annotation.TranscationModel;
import java.lang.annotation.*;
/**
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}
MyAnnotation3

package com.niyin.annotation.demo1;

import com.niyin.annotation.TranscationModel;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default  TranscationModel.ReadWrite;
}

TestAnnotation

package com.niyin.annotation.demo2;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface   TestAnnotation {
    String value() default "默认value值";
    String what() default "这里是默认的what属性对应的值";
}

IsNotNull

package com.niyin.annotation.demo3;
import java.lang.annotation.*;
 //非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

demo1

package com.niyin.annotation.demo1;
import com.niyin.annotation.TranscationModel;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "abc")
public class Demo1 {
    @MyAnnotation1(name = "xyz")
    private Integer age;
    @MyAnnotation2(model = TranscationModel.Read)
    public void list() {
        System.out.println("list");
    }
    @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    public void edit() {
        System.out.println("edit");
    }
}

demo1Test

package com.niyin.annotation.demo1;
import com.niyin.annotation.TranscationModel;
import org.junit.Test;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//abc
//        获取方法上的注解
        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
        System.out.println(myAnnotation2.model());//Read
//        获取属性上的注解
        MyAnnotation1 myAnnotation1 = Demo1.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
        System.out.println(myAnnotation1.name());// xyz
    }
    @Test
    public void edit() throws Exception {
        MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
        for (TranscationModel model : myAnnotation3.models()) {
            System.out.println(model);//Read,Write
        }
    }
}

demo2

package com.niyin.annotation.demo2;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 获取类属性上的注解属性值
 */
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;
}

demo2Test

package com.niyin.annotation.demo2;
import org.junit.Test;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
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());
    }
}

总结：如果我们注解上没有指定是value还是what默认就是value,如果只想转递一个参数又不想默认是value那就需要指定what=""即可。

demo3

package com.niyin.annotation.demo3;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 *
 * 获取参数修饰注解对应的属性值
 */
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);
    }
}

四、自定义注解案例

1.MyLogAspect切面类

package com.niyin.aspect;
import com.niyin.annotation.aop.MyLog;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
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;
import java.nio.channels.Pipe;
import java.util.Arrays;
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.niyin.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());
//    }
@Around("MyValid()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    long startTime = System.currentTimeMillis();
    System.out.println(pjp.getTarget());
    System.out.println(pjp.getThis());
    Object[] args = pjp.getArgs();
    System.out.println(Arrays.toString(args));
    Object ob = pjp.proceed();// ob 为方法的返回值
    System.out.println(ob);
    logger.info("耗时 : " + (System.currentTimeMillis() - startTime));
    return ob;
}
}

LogController

package com.niyin.web;
import com.niyin.annotation.aop.MyLog;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
/**
 * @author 小李飞刀
 * @site www.javaxl.com
 */
@Controller
public class LogController {
@RequestMapping("/mylog")
    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(HttpServletRequest request){
    request.getRemoteAddr();
    request.getRemotePort();
    System.out.println("这里随便来点啥");
    }
}

mylog

package com.niyin.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.javaxl.com
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

结语

本文介绍了注解

的定义、分类以及在实际开发中的应用。通过学习和使用注解，我们可以提高代码的可读性和维护性，减少冗余的配置代码，并增强程序的灵活性和可扩展性。希望本文能对大家理解和运用注解有所帮助。如有疑问或错误之处，欢迎指正。

【SpringMVC】自定义注解

前言