java自定义注解

最新推荐文章于 2024-04-08 21:47:07 发布
最新推荐文章于 2024-04-08 21:47:07 发布
阅读量125 收藏 1
点赞数
分类专栏： SpringBoot 文章标签： java自定义注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43514335/article/details/102937982
版权

java自定义注解

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”属性，赋值时可以省略属性名

demo

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

Demo1

package com.li.annottation.p1;

/**
 * 
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "abc")
public class Demo1 {

    @MyAnnotation1(name = "age被调用")
    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.li.annottation.p1;

import org.junit.Test;


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



    }

    @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
        }
    }
}

MyAnnotation1

package com.li.annottation.p1;

import java.lang.annotation.*;

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

MyAnnotation2

package com.li.annottation.p1;

import java.lang.annotation.*;

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

MyAnnotation3

package com.li.annottation.p1;

import java.lang.annotation.*;

/**
 * 
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

TranscationModel

package com.li.annottation.p1;

/**
 * @author dragon
 * @site
 * @company
 * @create  2019-11-06 16:23
 */
public enum TranscationModel {
    Read, Write, ReadWrite;

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

Demo2

package com.li.annottation.p2;

/**
 *
 * 获取类属性上的注解属性值
 */
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.li.annottation.p2;

import org.junit.Test;


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());
    }
}

TestAnnotation

package com.li.annottation.p2;

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

/**
 * @author dragon
 * @site
 * @company
 * @create  2019-11-06 17:12
 */
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";

    String what() default "这里是默认的what属性对应的值";
}
案例三（获取参数修饰注解对应的属性值）：

IsNotNull

package com.li.annottation.p3;
import java.lang.annotation.*;



@Documented
@Target({ElementType.PARAMETER})//修饰参数
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

Demo3

package com.li.annottation.p3;

/**
 * 获取参数修饰注解对应的属性值
 */
public class Demo3 {

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

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

Demo3Test

package com.li.annottation.p3;

import org.junit.Test;

import java.lang.reflect.Parameter;


public class Demo3Test {

    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();//获取到类对象
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class, String.class,Integer.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
            }
        }
    }
}
Aop自定义注解的应用

MyLog

package com.li.annottation;

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


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

MyLogAspect

package com.li.aspect;

import com.li.annottation.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;


@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);

    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.li.annottation.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 com.li.annottation;

import org.springframework.stereotype.Component;


@Component
public class LogController {

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

LogControllerTest

package com.li.controller;

import com.li.SpringBaseTest;
import com.li.annottation.LogController;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;


public class LogControllerTest extends SpringBaseTest {
    @Autowired
    private LogController logController;

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

在这里插入图片描述

效果：
在这里插入图片描述
实际项目应用参考链接：http://www.javaxl.com/blog/articles/236


关注
专栏目录
Java 自定义注解
qq_44641053的博客
11-06 522
Java自定义注解Java注解简介Java元注解自定义注解代码演示 本章点知识总览： 1、Java 注解简介 2、Java 元注解（重点） 3、自定义注解 4、Aop 自定义注解的应用（重点） Java注解（Annotation） 分类 编程技术 Java注解（Annotation）又称Java标注，是JDK5.0约会的一种注释机制。 和Javadoc不同，Java标注可以通过反射获取标注内容。 ...
Java自定义注解_01
Zhangrunhong的博客
11-06 252
1、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 @De...
Java自定义注解
qq_57306534的博客
08-16 195
Java自定义注解概要
Java中自定义注解
weixin_65837469的博客
05-24 5841
注解是一种元数据，可以被添加到Java代码中的任何元素上，包括类、字段、方法、参数等。在Java中，注解以 @ 符号开头，后跟注解名称和可选的注解参数。这里我们定义了一个名为 MyAnnotation 的注解，它唯一的属性为 value，类型为字符串类型，并且设置了默认值为空字符串。参数校验：可以自定义一些参数校验的注解，例如 @NotNull、@NotBlank等，来提高代码的健壮性。总之，自定义注解可以使我们的代码更加简洁、明了、易于维护，提高了代码的可读性和可维护性。四、自定义注解的应用场景。
Java 实现自定义注解
kkkkatoq的博客
04-08 6291
在开发中一般加上注解之后会自动执行一些逻辑，大部分实现的原理是使用切面来实现注解的逻辑的。//注解用于方法//运行时使用@Component@Aspect@Slf4j/** 这是一个切入点* *///获取方法名称//日志输出log.info(methodName+"进来了");try {
java 自定义注解的实例详解
08-29
Java 自定义注解的实例详解 Java 自定义注解是 Java 语言中的一种重要特性，它可以用于创建文档，跟踪代码中的依赖性，并且可以执行编译时期检查。自定义注解可以让开发者根据需要创建自己的注解，以满足特定的需求...
java 自定义注解验证
02-23
在本案例中，作者创建了三个自定义注解，具体细节虽未详述，但我们可以深入探讨一下Java自定义注解的基本概念、创建过程以及如何进行验证。 首先，我们需要理解Java注解的基本原理。注解是一种元数据，它提供了一种...
Java自定义注解使用反射获取字段注解
10-31
Java自定义注解是Java语言中的一个重要特性，它允许我们创建自己的元数据，为代码提供额外的信息。在Java中，注解（Annotation）主要用于编译器检查、代码生成、运行时处理等方面。本文将深入探讨如何通过反射机制来...
Java自定义注解的详解
08-29
Java自定义注解的详解 Java 注解（Annotation）是一种元数据，它提供了关于代码的一些信息，但并不直接作用于它所注解的代码内容。在这个教程中，我们将学习 Java 的注解，如何定制注解，注解的使用以及如何通过...
java自定义注解接口限流demo
最新发布
06-19
java自定义注解接口限流demo； java自定义注解接口限流demo； java自定义注解接口限流demo； java自定义注解接口限流demo； java自定义注解接口限流demo； java自定义注解接口限流demo； java自定义注解接口限流demo...
自定义注解的使用
csdnbeyoung的博客
12-10 677
1.定义一个自定义注解 package xxx.xxxx.xxxx.aop; import org.springframework.core.annotation.Order; import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented @Order(value = Integer.MAX_VALUE) public @interface Pre
java中的自定义注解的使用_Java中自定义注解的使用
weixin_30536391的博客
02-26 164
import java.lang.annotation.Annotation;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.util.HashMap;import java.util.Map;p...
什么是Java注解，如何创建和使用注解？
scjrw的博客
07-11 546
简单来说，Java注解就是给代码加上一些注释，但是这些注释不是给编译器看的，而是给Java虚拟机（JVM）看的。上面的代码定义了一个MyAnnotation注解，它有一个属性value表示一个字符串，还有一个属性count表示一个默认值为0的整数。上面的代码定义了一个注解类型MyAnnotation，它有一个属性value，表示一个字符串。上面的代码获取了MyAnnotation注解中的count属性，并输出了这个属性提供的次数。在使用注解的时候，我们需要在方法名后面加上@注解名的方式来引用注解。
【java8新特性系列】重复注解
wang2leee的博客
08-21 480
Repeating Annotations是Java 8引入的新特性，允许在同一个元素上多次使用相同的注解。在Java 8之前，每个元素只能使用一次相同的注解，如果需要对一个元素应用多个相同的注解，则需要创建一个包含多个相同注解的容器注解。为了简化这种操作，并提高代码的可读性，Java 8引入了Repeating Annotations。
自定义日志注解（可获取方法名、参数等）
mail_liuxing的专栏
11-11 3419
自定义注解记录日志，可以获取方法名、参数名、参数值等；
学习笔记（五）：自定义日志注解
qq_49111986的博客
05-16 423
自定义注解
自定义日志注解
灵葱的博客
10-16 809
之前项目中有个需求是记录用户的某些操作到数据库中。基本操作就是在每个需要保存操作日志的方法中都写上一个保存日志操作，但这样实现比较笨重，且不灵活，将业务代码和系统代码耦合在了一起。 如果我们写一个注解，标注了这个注解的方法就会记录调用了这个方法的人，并将方法的参数、方法名等信息保存起来，这样实现就比较轻便优雅。 Github 源码：https://github.com/cherispanty/...
全局添加日志-自定义注解
Amos_liu的博客
09-25 1149
好久没有写博客了，最近找一些之前写过的代码，结果不知道在那个项目里面写的，已经找不到了，又得从头开始，所以记录一下本次编写过程，之后自己查看，也可给需要的朋友一个参考！ 项目为 springboot2.0+mybatisplus + mysql搭建 需求：编写一个注解，记录登录账户的操作记录，主要记录增删改操作 效果如下图所示 1.首先添加一个自定义注解，@interface ，里面的参数是需要在具体注解里面添加的 具体代码如下： package com.zdxf.server.comp.
java的多重注解（重复注解）
热门推荐
wal1314520的博客
05-10 1万+
      本来早就写这一篇的，后来一直有别的事拖住了，然后就把它给忘了。前段时间看代码时，无意中看到了当时写的多重注解，觉得还是有必要写点东西的，虽然不是很难，但是对没有接触过的来说，有一份关于它的文章总比没有强。      以前也没用到过多重注解，一次一个需求来了之后，发觉和之前的一个功能有点冲突，重新写一个方法又觉得多余，就考虑到这个多重注解上来了。但是java 7没有多重注解相关的，只有自...
Java自定义注解详解与使用示例
"Java自定义注解用于创建框架或增强代码可读性，常与拦截器、AOP结合使用。本文介绍了注解的基本概念、体系结构以及常用的元注解，帮助开发者理解如何自定义和使用注解。" 在Java编程语言中，自定义注解是一种强大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值