【SpringMVC】自定义注解

自定义注解及其应用

前言

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

1. 什么是注解？

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

2. 注解的用处

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

提供给编译器和工具进行代码分析和处理。
在运行时动态地获取和处理注解信息。
生成文档、代码和其他资源文件。
注解的使用可以减少冗余的配置代码，提高代码的可读性和维护性，同时还能够增强程序的灵活性和可扩展性。

3. 注解的原理

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

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

1. 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 {@Testpublic 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}@Testpublic 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 {@Testpublic void test1() throws Exception {TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);System.out.println(msg1.value());System.out.println(msg1.what());}@Testpublic void test2() throws Exception{TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);System.out.println(msg2.value());System.out.println(msg2.what());}@Testpublic void test3() throws Exception{TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);System.out.println(msg3.value());System.out.println(msg3.what());}@Testpublic 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();
}

结语

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