【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】自定义注解

前言

1. 什么是注解？

2. 注解的用处

3. 注解的原理

1.1. @Override

1.2. @SuppressWarnings

2. JDK元注解

2.1. @Retention

2.2. @Target

2.3. @Inherited

2.4. @Documented

3. 自定义注解

3.1. 自定义注解的分类

注解类

结语

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【SpringMVC】自定义注解

前言

1. 什么是注解？

2. 注解的用处

3. 注解的原理

1.1. @Override

1.2. @SuppressWarnings

2. JDK元注解

2.1. @Retention

2.2. @Target

2.3. @Inherited

2.4. @Documented

3. 自定义注解

3.1. 自定义注解的分类

注解类

结语

热门文章

最新文章

相关电子书