自定义注解

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

自定义注解

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

package com.DZY.ssm.annotation;

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

/**

  • @author DZY
  • @site www.1620797557.com
  • @company xxx公司
  • @create 2019-12-27 20:08
    */
    @Retention(RetentionPolicy.RUNTIME)//比较常用
    //@Target(ElementType.TYPE)//接口、类
    //@Target({ElementType.TYPE,ElementType.FIELD})//可以加载到属性和类上面
    @Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})//可以加载到属性、类、方法上面
    public @interface Demo {
    }

DemoControer

package com.DZY.ssm.comtroller;

import com.DZY.ssm.annotation.Demo;
import com.DZY.ssm.model.Book;
import com.DZY.ssm.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:13
 *
 *   测试自定义注解(1)
 */


@Demo//接口 ，类上面
public class DemoControer {
    @Demo
    @Autowired
    private BookService bookService ;

    @Demo
    @RequestMapping("/lists")
    public  String  lists(Book book , HttpServletRequest req){
        return "测试";
    }
}

自己可以仔细看一下 Java元注解

案例操作

Test 报错解决

在这里插入图片描述

把junit里的test注释掉就不会报错了

我是在ssm 项目中搭建中测试的。如果有什么不懂的看之前博客

一切反射都是从获取类对象开始
getClass
.class
class.forname

Demo1

package com.DZY.ssm.annotation.p1;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:21
 *
 * 获取类与方法上的注解值
 */
@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");
    }
}

TestAnnotation

package com.DZY.ssm.annotation.p2;

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

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";

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

Demo2Test

package com.DZY.ssm.annotation.p2;

import org.junit.Test;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
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());
    }
}

Demo3

package com.DZY.ssm.annotation.p3;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 *
 * 获取参数修饰注解对应的属性值
 */
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);
    }
}

IsNotNull

package com.DZY.ssm.annotation.p3;

import java.lang.annotation.*;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 *
 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

Demo3Test

package com.DZY.ssm.annotation.p3;

import org.junit.Test;

import java.lang.reflect.Parameter;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
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
            }
        }
    }
}

Aop自定义注解的应用（springAop）

LogController

package com.DZY.ssm.annotation.springAop;

import org.springframework.stereotype.Component;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
@Component
public class LogController {

    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(){
        System.out.println("                                                                            有点意思，看懂一点了吗？ ");
    }
}

MyLog

package com.DZY.ssm.annotation.springAop;

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

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

MyLogAspect

package com.DZY.ssm.annotation.springAop;

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 DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);

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

BaseTestCase

package com.DZY.ssm.annotation.springAop;

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

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class BaseTestCase {

}

LogControllerTest

package com.DZY.ssm.annotation.springAop;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author DZY
 * @site www.1620797557.com
 * @company xxx公司
 * @create  2019-12-27 20:08
 */
public class LogControllerTest extends BaseTestCase {
    @Autowired
    private LogController logController;

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

在这里插入图片描述

@D-zy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
谈谈Java中自定义注解及使用场景
09-07
主要介绍了谈谈Java中自定义注解及使用场景，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Springboot中使用redisson + 自定义注解优雅的实现消息的发布订阅
qq_35716689的博客
01-18 31万+
在一些小型场景下，使用mq中间件可能会为原有项目增加不少维护成本，使用redisson实现消息的收发是个不错的选择。作者：鼠鼠我捏，要死了捏
自定义注解详细介绍
cherry的博客
07-10 14万+
1 注解的概念 1.1 注解的官方定义 首先看看官方对注解的描述： An annotation is a form of metadata, that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated. Annotations...
深入JAVA注解(Annotation)：自定义注解
热门推荐
yjclsx的博客
07-31 46万+
一、基础知识：元注解 要深入学习注解，我们就必须能定义自己的注解，并使用注解，在定义自己的注解之前，我们就必须要了解Java为我们提供的元注解和相关定义注解的语法。 元注解： 　　元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解： 　　　　1.@Targe...
JAVA自定义注解
一个喜欢诗和远方的程序媛
05-26 3167
根据注解是否包含成员变量，可以分为如下两类： 1、标记注解：没有定义成员变量的注解类型被称为标记注解。这种注解仅利用自身的存在与否来提供信息，如前面介绍的 @Override、@Test 等都是标记注解。 2、元数据注解：包含成员变量的注解，因为它们可以接受更多的元数据，所以也被称为元数据注解。
自定义注解实现
09-21
看到别的博主写的几篇接绍注解相关的东西，觉得挺好的，mark一下 ... 自定义注解：...主要就是自定义了注解，使用了自定义注解，然后利用java的反射机制根据注解生成不同的sql语句
自定义注解实现拦截sql.rar
10-08
自定义注解实现拦截sql,并在sql中增加相应的条件 。 对应博客: https://blog.csdn.net/qq_37716298/article/details/120659139
自定义注解bindview.zip
06-23
自定义注解bindview 省去findviewbyid，直接在变量前边添加@BindView即可绑定控件
jar包增量更新分析
junlaiyan的专栏
05-16 371
借助jdeps分析出jar包的增量文件
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 211
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 1001
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 337
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1071
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Spring6基础笔记
最新发布
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 675
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Android Model引入其他aar包 导致无法打包成aar
qq_27400335的博客
05-16 373
Android Model引入其他aar包 导致无法打包成aar
SpringBoot事件发布与监听，观察者模式使用
小哇
05-16 256
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。
Java基础——字符串
Kenard的博客
05-17 956
基本数据类型、包装类 转成字符串，调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换。下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。
自定义注解使用数组自定义注解使用数组
04-03
自定义注解是Java语言中的一种特性，它允许程序员自定义一些元数据，用于在程序中进行标记和描述。使用数组作为自定义注解的成员变量可以提供更灵活的功能。 要使用数组作为自定义注解的成员变量，需要在注解的定义...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值