自定义注解

最新推荐文章于 2024-01-28 03:11:28 发布
最新推荐文章于 2024-01-28 03:11:28 发布
阅读量106 收藏
点赞数
分类专栏： 自定义注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21907023/article/details/103703955
版权

文章目录

Java注解简介

  1. Java注解(Annotation)
    Java注解是附加在代码中的一些元信息，用于一些工具在编译、
    运行时进行解析和使用，起到说明、配置的功能。

    注解相关类都包含在java.lang.annotation包中。

  2. Java注解分类
    2.1 JDK基本注解
    2.2 JDK元注解
    2.3 自定义注解

  3. JDK基本注解
    3.1 @Override
    重写
    3.2 @Deprecated
    已过时
    3.3 @SuppressWarnings(value = “unchecked”)
    压制编辑器警告

Java元注解

作用：元注解用于修饰其他的注解

@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关键字为这个成员变量设定默认值；

注意：只有名字为“value”属性，赋值时可以省略属性名

获取类与方法上的注解值

TranscationModel

package annotation;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 18:58
 * 一个枚举类 定义常量
 */
public enum  TranscationModel {
    Read, Write, ReadWrite
}

MyAnnotation1

package annotation;

import java.lang.annotation.*;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:02
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
@Documented
public @interface MyAnnotation1 {
    String name();
}

MyAnnotation2

package annotation;

import java.lang.annotation.*;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:06
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

MyAnnotation3

package annotation;

import java.lang.annotation.*;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:09
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

Demo1

package annotation;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:14
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "获取类上注解值")
public class Demo1 {
    @MyAnnotation1(name = "属性上注解值")
    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 annotation;

import org.junit.Test;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:18
 */
public class Demo1Test {
    @Test
    public void list() throws Exception{
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//获取类上注解值

//        获取方法上的注解
        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
        System.out.println(myAnnotation2.model());//Read

    }

    @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
        }
    }
}
获取类属性上的注解属性值

TestAnnotation

package annotation;

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

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:29
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";

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

Demo2

package annotation;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:31
 * 获取类属性上的注解属性值
 */
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 annotation;

import org.junit.Test;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:31
 */
public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());//这就是value对应的值_msg1
        System.out.println(msg1.what());//这就是what对应的值_msg1
    }

    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());//这就是value对应的值1
        System.out.println(msg2.what());//这里是默认的what属性对应的值
    }

    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());//这就是value对应的值2
        System.out.println(msg3.what());//这里是默认的what属性对应的值
    }

    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());//默认value值
        System.out.println(msg4.what());//这就是what对应的值
    }
}
获取参数修饰注解对应的属性值

IsNotNull

package annotation;

import java.lang.annotation.*;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:39
 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

Demo3

package annotation;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:39
 * 获取参数修饰注解对应的属性值
 */
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);
    }

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

Demo3Test

package annotation;

import org.junit.Test;

import java.lang.reflect.Parameter;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:40
 */
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 {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello3", String.class,String.class,String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//false true false
            }
        }
    }

}
Aop自定义注解的应用

MyLog

package annotation;

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

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:49
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

MyLogAspect

package annotation;

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 Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 19:52
 * 一个切面类 切的就是使用了MyLog这个注解
 * 只要用到了annotation.MyLog这个注解的，就是目标类
 */
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
    @Pointcut("@annotation(annotation.MyLog)")
    private void MyValid() {
    }

    @Before("MyValid()")
    public void before(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        logger.debug("[" + signature.getName() + " : start.....]");

        MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
        logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
    }
}

LogController

package annotation;

import org.springframework.stereotype.Component;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 20:00
 */
@Component
public class LogController {
    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用")
    public void testLogAspect(){
        System.out.println("这个方法有MyLog注解，所以会被MyLogAspect切面类所切");
    }
}

BaseTestCase

package annotation;

import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 20:06
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class BaseTestCase {
}

LogControllerTest

package annotation;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * @author Songwanxi
 * @site www.lentter.club
 * @company
 * @create  2019-12-25 20:07
 */
public class LogControllerTest extends  BaseTestCase {
    @Autowired
    private LogController logController;

    @Test
    public void testLogAspect(){
        logController.testLogAspect();
    }
}

在这里插入图片描述

秃头使我变强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java自定义注解
weixin_39827856的博客
06-19 1293
System.out.println("年龄可空校验通过：可以为空");System.out.println("名字可空校验通过：可以为空");System.out.println("年龄最小长度校验通过");System.out.println("年龄最大长度校验通过");System.out.println("名字最小长度校验通过");System.out.println("名字最大长度校验通过");
java注解-自定义注解的实现
胡云峰的博客
10-07 4039
注解浅解
【Java】自定义注解详解及使用案例
weixin_38538285的博客
10-24 626
自定义注解使用 场景一：方法入参校验 场景二：对Controller层的接口入参进行一些合法性校验 场景三：强大的自定义注解加Aop
JAVA注解的创建和使用（简单理解）
qqzhengwei的专栏
02-02 255
目录 1.自定义注解只有一个属性时，且属性名为value时，赋值时value可省略。 2. 自定义注解只有一个属性时，且属性名不为value时，赋值时应与属性名保持一致。 1.自定义注解只有一个属性时，且属性名为value时，赋值时value可省略。 注解定义: public @interface ValueConfig { public String value(); } 注解使用: //默认使用的是注解的value属性 @ValueConfig("student") pu.
谈谈Java中自定义注解及使用场景
09-07
Java中的自定义注解是一种强大的工具，允许程序员在代码中添加元数据，这些元数据可以在编译时或运行时被解析和使用。自定义注解是Java 5引入的新特性，它增强了代码的可读性和可维护性，同时也简化了框架和库的开发...
java 自定义注解的实例详解
08-29
Java 自定义注解的实例详解 Java 自定义注解是 Java 语言中的一种重要特性，它可以用于创建文档，跟踪代码中的依赖性，并且可以执行编译时期检查。自定义注解可以让开发者根据需要创建自己的注解，以满足特定的需求...
自定义注解实现
09-21
看到别的博主写的几篇接绍注解相关的东西，觉得挺好的，mark一下 ... 自定义注解：...主要就是自定义了注解，使用了自定义注解，然后利用java的反射机制根据注解生成不同的sql语句
java自定义注解接口实现方案
09-05
Java自定义注解是一种强大的工具，允许开发者在代码中添加元信息，这些信息可以在编译时或运行时被解析和利用。本文将深入探讨如何在Java中实现自定义注解以及如何解析和利用这些注解。 首先，了解Java中的元注解是...
自定义注解实现@NotNull注解
热门推荐
树欲静而风不止
06-17 1万+
先了解一下基本的自定义注解的时候，常用的注解含义 @Documented // 代表这个注解，可以被javadoc 处理的（加不加都行） @Retention(RetentionPolicy.RUNTIME) // RetentionPolicy 生命周期，一共有三个 // SOURCE 只留在源码，编译好后的代码是不有该注解的，该注解一旦编译就不存在了 ； // class 只停留在字节码，...
自定义@NotNull注解
weixin_42930033的博客
05-07 970
自定义@NotNull注解 /* 配合hasNullOrEmpty使用 */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @Documented //javadoc public @inteface NotNull{ } /* 如果 arg为String类型:空或者null返回true 否则 当arg...
【intellij】External and inferred annotations
harbor_lee的博客
11-27 1029
背景     Effective Java 中文版（原书第3版）的163页用到Stream.iterate(TWO, BigInteger::nextProbablePrime)用于生成素数流，引起我对这个函数的兴趣，一方面是它如何使用参数一来生成大于参数一的素数，另一方法是好奇BigInteger竟可以提供素数生成，再也不用手写素数判定方法了。     打开Intellij查看Stream.iterate源码，发现灰色的@Co
Java中如何获取自定义注解并获取其值
m0_71355126的博客
06-26 9369
Java中如何获取自定义注解并获取其值
This is not a valid Java qualified name
weixin_54048131的博客
01-28 215
今天在敲代码的时候，遇到了一个问题，这不是有效的Java限定名，这里发生错误的原因是包名不能为package。
Java实现自定义注解
阿king的博客
11-18 209
前言 java自定义注解实现及如何使用 正文 注解是一种能被添加到java源代码中的元数据，方法、类、参数和包都可以用注解来修饰。注解可以看作是一种特殊的标记，可以用在方法、类、参数和包上，程序在编译或者运行时可以检测到这些标记而进行一些特殊的处理 JDK中有一些元注解，主要有@Target，@Retention,@Document,@Inherited用来修饰注解。 @Target 表明该注解可以应用的java元素类型 Target类型 描述 ElementType.TYPE 应用于类、接口（包括注解
Rose name is not a valid Java identifier图解及简单例子
z28126308的专栏
12-16 7524
买的书中rose的操作太少，配套视频又跟资源不太搭，学起来有点难，故遇此困难~ WARNING: Logical package Logical View - name is not a valid Java identifier.导致无法生成代码 解决方法：Options->Tools->Notation,Default选择默认语言(如我的是Java则选Java) 设置默认语言后右
【Java注解系列】内置注解与AOP实现自定义注解
qq_35789269的博客
03-27 4175
1、深入理解Java注解类型(@Annotation)_zejian_的博客-CSDN博客_java注解 2、java之aop使用及自定义注解 - 沦陷 - 博客园 3、SpringAOP中的JointPoint和ProceedingJoinPoint使用详解（附带详细示例）_如何在5年薪百万的博客-CSDN博客_proceedingjoinpoint有什么用 ...
自定义注解使用数组自定义注解使用数组
最新发布
04-03
自定义注解是Java语言中的一种特性，它允许程序员自定义一些元数据，用于在程序中进行标记和描述。使用数组作为自定义注解的成员变量可以提供更灵活的功能。 要使用数组作为自定义注解的成员变量，需要在注解的定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值