spring 注解详解

最新推荐文章于 2023-09-15 19:25:26 发布
最新推荐文章于 2023-09-15 19:25:26 发布
阅读量521 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34338162/article/details/116047764
版权

https://www.cnblogs.com/youzhibing/p/11031216.html（转 @Autowired工作原理）
注解（Annotation）不是程序本身，但是可以对程序作出解释，同时注解还可以让其他程序读取。我们可以把注解加在包（package）、类（class）、方法（method）和变量（field）的上面。
    注解是一个接口，一个继承自Annotation的接口。 里面每一个属性，其实就是接口的一个抽象方法

一、内置注解


1、@Override
定义在 java.lang.Override 中 , 此注释只适用于修辞方法 , 表示一个方法声明打算 重写超类中的另一个方法声明，简单来说就是子类在重写父类方法的时候可以加上这个注解。

2、@Deprecated
定义在java.lang.Deprecated中 , 此注释可以用于修辞方法 , 属性 , 类 , 表示不 鼓励程序员使用这样的元素 , 通常是因为它很危险或者存在更好的选择 。即是此方法已经过时，不推使用。

3、@SuppressWarnings
定义在 java.lang.SuppressWarnings 中,用来抑制编译时的警告信息，与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的, 我们选择性的使用就好了 ，一般我们使用 @SuppressWarnings(“all”)

二、元注解


除了 Java 中为我们定义好的注解，我们还可以自定义注解， Java定义了4个标准的元注解（meta-annotation）类型,他们被用来 提供对其他注解类型作说明 。
  

 @Retention（标明注解被保留的阶段）
        注解@Retention可以用来修饰注解，是注解的注解，称为元注解。
        Retention注解有一个属性value，是RetentionPolicy类型的，Enum RetentionPolicy是一个枚举类型，
        这个枚举决定了Retention注解应该如何去保持，也可理解为Rentention 搭配 RententionPolicy使用。RetentionPolicy有3个值：CLASS  RUNTIME   SOURCE
        按生命周期来划分可分为3类：
            @Retention：注解的保留位置　　　　　　　　　

　　　　@Retention(RetentionPolicy.SOURCE)   //注解仅存在于源码中，在class字节码文件中不包含

　　　　@Retention(RetentionPolicy.CLASS)     // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，

　　　　@Retention(RetentionPolicy.RUNTIME)  // 注解会在class字节码文件中存在，在运行时可以通过反射获取到
            这3个生命周期分别对应于：Java源文件(.java文件) ---> .class文件 ---> 内存中的字节码。
        那怎么来选择合适的注解生命周期呢？
            首先要明确生命周期长度 SOURCE < CLASS < RUNTIME ，所以前者能作用的地方后者一定也能作用。
            一般如果需要在运行时去动态获取注解信息，那只能用 RUNTIME 注解，比如@Deprecated使用RUNTIME注解
            如果要在编译时进行一些预处理操作，比如生成一些辅助代码（如 ButterKnife），就用 CLASS注解；
            如果只是做一些检查性的操作，比如 @Override 和 @SuppressWarnings，使用SOURCE 注解。

        注解@Override用在方法上，当我们想重写一个方法时，在方法上加@Override，当我们方法的名字出错时，编译器就会报错
        注解@Deprecated，用来表示某个类或属性或方法已经过时，不想别人再用时，在属性和方法上用@Deprecated修饰
        注解@SuppressWarnings用来压制程序中出来的警告，比如在没有用泛型或是方法已经过时的时候
  

 @Target（标明注解使用的范围）
        Target说明的是Annotation所修饰的对象范围
      @Target:注解的作用目标　　　　　　　　

　　　　@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) ///包  

  

 @Inherited（标明注解可继承）
        @Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类
            当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。
            如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，
            直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。
  

 @Documented（标明是否生成javadoc文档）
        @Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员


三、自定义注解


    3.1自定义一个Log注解

package com.test.mybatisplus.aop;
import java.lang.annotation.*;

/**
 * @Description 日志注解
 * @project
 * @author：hf
 * @date：
 * @company:人生有限公司
 */
@Target({ElementType.PARAMETER,ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    /**
     * 要执行的操作类型比如：add操作
     **/
    public String operationType() default "";

    /**
     * 要执行的具体操作比如：添加用户
     **/
    public String operationName() default "";

}

 3.2注解使用   

package com.test.mybatisplus.controller;

import com.test.mybatisplus.aop.Log;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**

@Api
@RestController
@RequestMapping("aopController")
@Slf4j
@Log(operationType="aopController",operationName="aopControllerT")
public class AopController {

    @Log(operationType="aaa",operationName="aaaT")
    public String aaa="ds";

    @GetMapping("/testAOP")
    @ApiOperation(value = "testAOP",notes = "testAOP")
    @Log(operationType="testAOP",operationName="测试接口")
    public String testAOP() {

       return "测试testAOP接口...";
    }


    public static void main(String[] args) throws Exception{
        //类
        AopController.class.getAnnotation(Log.class);
        AopController.class.getAnnotations();
        AopController.class.getDeclaredAnnotations();
        AopController.class.getAnnotationsByType(Log.class);
        AopController.class.getDeclaredAnnotation(Log.class);
        AopController.class.getDeclaredAnnotationsByType(Log.class);
        //方法
        AopController.class.getMethod("testAOP").getAnnotation(Log.class);
        AopController.class.getMethod("testAOP").getAnnotations();
        AopController.class.getMethod("testAOP").getDeclaredAnnotations();
        AopController.class.getMethod("testAOP").getAnnotationsByType(Log.class);
        AopController.class.getMethod("testAOP").getDeclaredAnnotation(Log.class);
        AopController.class.getMethod("testAOP").getDeclaredAnnotationsByType(Log.class);
        //变量
        AopController.class.getField("aaa").getAnnotation(Log.class);
        AopController.class.getField("aaa").getAnnotations();
        AopController.class.getField("aaa").getDeclaredAnnotations();
        AopController.class.getField("aaa").getAnnotationsByType(Log.class);
        AopController.class.getField("aaa").getDeclaredAnnotation(Log.class);
        AopController.class.getField("aaa").getDeclaredAnnotationsByType(Log.class);

    }
}

 3.3

 AopController.class.getAnnotation(Log.class);

3.4运行方法


 

AnnotationInvocationHandler 实现InvocationHandler，而InvocationHandler是实现动态代理必须的类（自行了解jdk动态代理）


 3.5查看源码，如何生成代理类   

通过Log logTest= AopController.class.getAnnotation(Log.class); 进入到class.java getAnnotation方法

    @SuppressWarnings("unchecked")
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
        Objects.requireNonNull(annotationClass);

        return (A) annotationData().annotations.get(annotationClass);
    }
	
	    private AnnotationData annotationData() {
        while (true) { // retry loop
            AnnotationData annotationData = this.annotationData;
            int classRedefinedCount = this.classRedefinedCount;
            if (annotationData != null &&
                annotationData.redefinedCount == classRedefinedCount) {
                return annotationData;
            }
            // null or stale annotationData -> optimistically create new instance
            AnnotationData newAnnotationData = createAnnotationData(classRedefinedCount);
            // try to install it
            if (Atomic.casAnnotationData(this, annotationData, newAnnotationData)) {
                // successfully installed new AnnotationData
                return newAnnotationData;
            }
        }
    }
	
	
	 private AnnotationData createAnnotationData(int classRedefinedCount) {
        Map<Class<? extends Annotation>, Annotation> declaredAnnotations =
            AnnotationParser.parseAnnotations(getRawAnnotations(), getConstantPool(), this);
        Class<?> superClass = getSuperclass();
        ......
        return new AnnotationData(annotations, declaredAnnotations, classRedefinedCount);
    }
	
	public static Map<Class<? extends Annotation>, Annotation> parseAnnotations(byte[] var0, ConstantPool var1, Class<?> var2) {
        if (var0 == null) {
            return Collections.emptyMap();
        } else {
            try {
                return parseAnnotations2(var0, var1, var2, (Class[])null);
            } catch (BufferUnderflowException var4) {
                throw new AnnotationFormatError("Unexpected end of annotations.");
            } catch (IllegalArgumentException var5) {
                throw new AnnotationFormatError(var5);
            }
        }
    }
	
	 private static Map<Class<? extends Annotation>, Annotation> parseAnnotations2(byte[] var0, ConstantPool var1, Class<?> var2, Class<? extends Annotation>[] var3) {
        LinkedHashMap var4 = new LinkedHashMap();
        ByteBuffer var5 = ByteBuffer.wrap(var0);
        int var6 = var5.getShort() & '\uffff';

        for(int var7 = 0; var7 < var6; ++var7) {
            Annotation var8 = parseAnnotation2(var5, var1, var2, false, var3);
            if (var8 != null) {
                Class var9 = var8.annotationType();
                if (AnnotationType.getInstance(var9).retention() == RetentionPolicy.RUNTIME && var4.put(var9, var8) != null) {
                    throw new AnnotationFormatError("Duplicate annotation for class: " + var9 + ": " + var8);
                }
            }
        }
		
		
		
		 private static Annotation parseAnnotation2(ByteBuffer var0, ConstantPool var1, Class<?> var2, boolean var3, Class<? extends Annotation>[] var4) {
			......
            return annotationForMap(var6, var10);
        }
    }
	
	   public static Annotation annotationForMap(final Class<? extends Annotation> var0, final Map<String, Object> var1) {
        return (Annotation)AccessController.doPrivileged(new PrivilegedAction<Annotation>() {
            public Annotation run() {
                return (Annotation)Proxy.newProxyInstance(var0.getClassLoader(), new Class[]{var0}, new AnnotationInvocationHandler(var0, var1));
            }
        });
    }

最后进入的annotationForMap 就是实现jdk动态代理的代码

 public static Annotation annotationForMap(final Class<? extends Annotation> var0, final Map<String, Object> var1) {
        return (Annotation)AccessController.doPrivileged(new PrivilegedAction<Annotation>() {
            public Annotation run() {
                return (Annotation)Proxy.newProxyInstance(var0.getClassLoader(), new Class[]{var0}, new AnnotationInvocationHandler(var0, var1));
            }
        });
    }

 

3.6下面六个方法执行到最后都会用到动态代理

 java的反射包中获取一个元素(Class、 Method、Constructor、Field)上的注解对象主要有6个方法获取的都是运行时注解。
        getAnnotation(Class<T> annotationClass)、
        getAnnotations()、
        getAnnotationsByType(Class<T> annotationClass)、
        getDeclaredAnnotation(Class<T> annotationClass)、
        getDeclaredAnnotations()、
        getDeclaredAnnotationsByType(Class<T> annotationClass)。

千反田真的打不过我
关注
专栏目录
分分钟玩转SpringBoot自定义注解
bieber007的博客
11-14 629
在工作中，我们有时候需要将一些公共的功能封装，比如操作日志的存储，防重复提交等等。这些功能有些接口会用到，为了便于其他接口和方法的使用，做成自定义注解，侵入性更低一点。别人用的话直接注解就好。下面就来讲讲自定义注解这些事情。 一.@Target、@Retention、@Documented简介 java自定义注解的注解位于包：java.lang.annotation下。包含三个元注解@Target、@Retention、@Documented，即注解的注解。 @Target @Target:注解的作
Spring注解详解
m0_67401153的博客
06-12 1212
spring在2.5版本引入了注解配置的支持，同时从Spring 3版本开始，Spring JavaConfig项目提供的许多特性成为核心Spring框架的一部分。因此，可以使用Java而不是XML文件来定义应用程序类外部的bean。在这里面官方文档为我们提供了四个基本注解@Configuration,@Bean,@Import,@DependsOn1.1、@Configuration1.1.1、源码 1.1.2、说明作用： 它是在spring3.0版本之后加入的。此注解是spring支持注解驱动开发的一个
通过比喻来了解spring
SSSZZZBBB的专栏
01-11 649
 spring 依赖注入 为什么要用spring容器，他有什么好处呢以及如何来理解spring容器注入： 依赖注入的含义为：当某个java实例需要另一个java实例，由spring容器来完成注 入实例。 接下来讲一个比喻的例子： 在人类的原始社会中，人类对自己所需要的东西，基本得靠自己去制造。耕地用的 锄头得自己去打造。这就像java中声明一个对象，我们自己用new去创建对象。这
Spring Boot实战小技巧（七）：实现自定义注解
The Blog of Coder
04-22 683
在Spring Boot的开发中，经常会有与其他业务系统对接或封装公共API接口等需求，为了使开发过程更加便捷性，并降低系统之间的耦合性，通常会使用自定义注解来封装一些业务，在后续开发时直接使用自定义注解即可，无需再关注注解内部业务流程的实现。注解即Spring AOP，Spring AOP基于面向切面编程思想，本文将介绍如何在Spring Boot框架中实现自定义注解。
Java之道系列：Annotation实现浅析
weixin_34092370的博客
04-06 175
今天来研究研究Java的注解是如何实现的。最简单的，先来看看注解的class文件是什么样的。 class文件支持 直接看栗子， import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.Reten...
【SpringMVC】自定义注解和使用（看完它相信我）
最新发布
无法自律的人的博客
09-15 1972
定义注解：使用注解语法，在相关的注解类上定义自定义注解，可以指定注解的目标范围和属性。标记使用：在控制器类、方法或者方法参数上使用自定义注解，标识需要应用自定义逻辑的地方。处理注解：通过Spring的AOP、拦截器等机制，对标记了特定自定义注解的类、方法或者参数进行处理，实现相关的功能。注解分类（根据Annotation是否包含成员变量,可以把Annotation分为两类）标记Annotation:没有成员变量的Annotation;这种Annotation仅利用自身的存在与否来提供信息。
spring注释详解
01-02
【Spring注释详解】 在Java开发领域，Spring框架以其强大的功能和灵活性著称。自Spring 2.5版本起，Spring引入了注释驱动的配置，使得开发者可以通过在类和方法上添加注释来替代传统的XML配置文件。这种方式极大地...
Java 注解完全解析
shiyansama的博客
10-18 170
关于注解首先引入官方文档的一句话：Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。Java 注解是从 Java5 开始添加到 Java 的。看完这句话也许你还是一脸懵逼，接下我将从注解的定义、元注解、注解属性、自定义注解、注解解析JDK 提供的注解这几个方面再次了解注解（Annotation） 注解的定义 日常开发中新建Java类，我们使用class、interface比较多，而注解和它们一样，也是一种类的类型，他是用的修
springboot自定义Enable注解使非启动类包路径的注解被扫描到
qq_66986418的博客
01-17 322
三、把新建的maven工程deploy到私服，在springboot项目的启动类或能被springboot扫描到的配置类上面加上@EnableMyProject注解，com.myproject.www.**下的带注解的都能被扫描到。
java socket定长报文实现接口通信
dfBeautifulLive的博客
04-26 5112
因为要和银行方进行通信，所以接口通信传参就需要实现定长报文，小小的吐槽一下，最开始是json传参方式到改为xml，刚写好xml还没有试试就通知要改为定长报文，也就我脾气好，真想骂爹，骂娘，但是时间有限还是得实现啊，但是网上资料又不多，最终一点点摸索弄出来了。 首先定长报文是指像json格式那种key,value有字段有值的方式，定长报文就是String拼接的vlaue值，而没有key了，那么你就想了那我解析值或者取值怎么取我想要的对应的值呢，其实定长报文么，顾名思义就是没有了key就把值的长度固定了呀，.
自定义注解及使用场景
任意门的博客
09-09 3134
Java自定义注解一般使用场景为：自定义注解+拦截器或者AOP，使用自定义注解来自己设计框架，使得代码看起来非常优雅。 基本知识 在Java中，注解分为两种，元注解和自定义注解。 三. 常用元注解 Target：描述了注解修饰的对象范围，取值在java.lang.annotation.ElementType定义，常用的包括： METHOD：用于描述方法 PACKAGE：用于描述包 PARAMETER：用于描述方法变量 TYPE：用于描述类、接口或enum类型 Retention: 表示注解保
springboot项目中自定义注解的使用总结、java自定义注解实战（常用注解DEMO）
热门推荐
新林的博客
11-12 3万+
初学spring的时候使用注解总觉得使用注解很神奇，加一个注解就能实现想要的功能，很好奇，也想自己根据需要写一些自己实现的自定义注解。问题来了，自定义注解到底是什么？肯定会有人和我一样有这个疑惑，我根据自己的理解总结一下。看完下面的几个使用自定义注解的实战demo,小伙伴大概就懂怎么用了。 其实注解一点也不神奇，注解就是一种标志，单独使用注解，就相当于在类、方法、参数和包上加上一个装饰，什么功能也没有，仅仅是一个标志，然后这个标志可以加上一些自己定义的参数。
8.spring系列- java注解
qq_32062699的博客
09-24 2519
问题 注解是干什么的？ 一个注解可以使用多次吗？如何使用？ @Inherited是做什么的？ @Target中的TYPE_PARAMETER和TYPE_USER用在什么地方？ 泛型中如何使用注解？ 注解定义可以实现继承吗？ spring对注解有哪些增强？@Aliasfor注解是干什么的？ 什么是注解 代码中注释大家都熟悉吧，注释是给开发者看的，可以提升代码的可读性和可维护性，但是对于java编译器和虚拟机来说是没有意义的，编译之后的字节码文件中是没有注释信息的；而注解和注释有点类似，唯一的区别就是注释是
java自定义注解
李智龙的博客
12-05 475
注解按照运行机制分类、注解按照使用的方式和用途分类 元注解、自定义注解的创建、注解的使用、注解的获取
自定义注解和AOP在项目中的使用
weixin_46643875的博客
06-17 213
AOP配合自定义注解，在项目中的使用
再探Java中的注解--源码分析
terase梅
11-27 790
我们让它的可用范围为TYPE，保留到运行时，保留到运行时的注解才能被反射使用。}
xstreamalias注解在哪个包_spring自定义注解解析
weixin_30174223的博客
01-25 530
1：aop -自定义注解应用范围：方法+类，一般使用在方法上先来定义个注解@Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface TraceLogAnnotation { }解析注解上的注解参数：@Target：他就像标签，定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值