StandardAnnotationMetadata.from具有什么功能呢?

下文笔者讲述StandardAnnotationMetadata.from方法的功能简介说明,如下所示

StandardAnnotationMetadata.from方法简介

`StandardAnnotationMetadata`是Spring框架中的一个类
   用于提供对注解元数据的访问。
 `StandardAnnotationMetadata.from`方法是该类中的一个静态工厂方法，
 用于从给定的类或注解创建`StandardAnnotationMetadata`实例 
 

`StandardAnnotationMetadata.from`方法的功能

  
  1.创建`StandardAnnotationMetadata`实例:
     从给定的类或注解创建一个`StandardAnnotationMetadata`对象
	   以便访问该类或注解上的所有注解信息
  2.提供注解元数据:
     允许开发者获取类或注解上的注解类型、
	   属性值等信息
	    用于进一步处理和配置 

StandardAnnotationMetadata.from不同方法简介

方法1:从类创建 `StandardAnnotationMetadata`
  public static StandardAnnotationMetadata from(Class<?> introspectedClass)
- 参数：
  -`introspectedClass`:
     需要获取注解元数据的类
- 返回值：
  -`StandardAnnotationMetadata`:
    包含类上注解信息
	  `StandardAnnotationMetadata`实例 

方法2:从注解创建`StandardAnnotationMetadata`
  public static StandardAnnotationMetadata from(Annotation annotation)
- 参数：
  -`annotation`：需要获取注解元数据的注解实例。
- 返回值：
  - `StandardAnnotationMetadata`: 包含注解信息的 `StandardAnnotationMetadata` 实例。

StandardAnnotationMetadata使用场景

`StandardAnnotationMetadata`主要用于以下场景:
  -注解处理:
     在Spring注解配置机制中
	   用于解析和处理类上的注解。
  -自定义注解处理器:
     在自定义注解处理器中
	   用于获取和处理注解信息。
  -元数据访问:
     在需要访问类或注解的元数据信息时
	   提供一个统一的接口。

例

1：从类创建 `StandardAnnotationMetadata`
一个类 `MyComponent`
  使用`@Component`注解
 
import org.springframework.stereotype.Component;

@Component
public class MyComponent {
    // 类内容
}
 
使用 `StandardAnnotationMetadata.from` 方法
  从`MyComponent`类
    创建`StandardAnnotationMetadata`实例
	并访问注解信息

import org.springframework.core.type.StandardAnnotationMetadata;
import org.springframework.stereotype.Component;

public class StandardAnnotationMetadataExample {
    public static void main(String[] args) {
        // 从类创建 StandardAnnotationMetadata 实例
        StandardAnnotationMetadata metadata = 
		    StandardAnnotationMetadata.from(MyComponent.class);

        // 检查是否存在 @Component 注解
        if (metadata.hasAnnotation(Component.class.getName())) {
            System.out.println("MyComponent 类上有 @Component 注解");
        }

        // 获取注解属性值
        String componentValue =
     		metadata.getAnnotationAttributes(Component.class.getName()).get("value").toString();
        System.out.println("Component 注解的 value 属性值: " + componentValue);
    }
}

===========输出=============
MyComponent 类上有 @Component 注解
Component 注解的 value 属性值: 

例2:从注解创建`StandardAnnotationMetadata`

有一个自定义注解`MyCustomAnnotation`
并有一个类`MyAnnotatedClass`使用该注解 

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.Runtime)
public @interface MyCustomAnnotation {
    String value() default "";
}
 
@MyCustomAnnotation(value = "MyValue")
public class MyAnnotatedClass {
    // 类内容
}
 
使用`StandardAnnotationMetadata.from`方法
  从`MyCustomAnnotation`注解
  创建`StandardAnnotationMetadata`实例
  并访问注解信息 
  
import org.springframework.core.type.StandardAnnotationMetadata;
import org.springframework.core.type.AnnotationMetadata;
import java.lang.annotation.Annotation;

public class StandardAnnotationMetadataExample {
    public static void main(String[] args) {
        // 获取 MyAnnotatedClass 类上的 MyCustomAnnotation 注解
        MyCustomAnnotation annotation = MyAnnotatedClass.class.getAnnotation(MyCustomAnnotation.class);

        // 从注解创建 StandardAnnotationMetadata 实例
        StandardAnnotationMetadata metadata = StandardAnnotationMetadata.from(annotation);

        // 检查是否存在 MyCustomAnnotation 注解
        if (metadata.hasAnnotation(MyCustomAnnotation.class.getName())) {
            System.out.println("MyAnnotatedClass 类上有 MyCustomAnnotation 注解");
        }

        // 获取注解属性值
        String annotationValue = metadata.getAnnotationAttributes(MyCustomAnnotation.class.getName()).get("value").toString();
        System.out.println("MyCustomAnnotation 注解的 value 属性值: " + annotationValue);
    }
}
 
==============输出===============
 
MyAnnotatedClass 类上有 MyCustomAnnotation 注解
MyCustomAnnotation 注解的 value 属性值: MyValue

StandardAnnotationMetadata中核心方法

`StandardAnnotationMetadata`
  提供许多方法来访问和操作注解元数据

以下是一些常用的方法:
(1).`hasAnnotation(String annotationName)`
-作用:检查指定的注解是否存在。
-参数:
  - `annotationName`:注解的全限定名。
-返回值:
  - `boolean`:如果存在指定的注解,则返回`true`,否则返回`false`

(2).`getAnnotationAttributes(String annotationName)`
-作用:获取指定注解的所有属性值
-参数:
  -`annotationName`: 注解的全限定名
-返回值:
  - `Map<String, Object>`: 包含注解属性名称和值的映射

(3).`getAnnotationTypes()`
-作用:获取所有注解的全限定名
-返回值:
  -`Set<String>`: 包含所有注解全限定名的集合

(4).`getClassName()`
-作用:获取被注解的类的全限定名
-返回值:
  -`String`:类的全限定名

StandardAnnotationMetadata内部使用

`StandardAnnotationMetadata`
  内部使用 `AnnotationUtils` 和 `AnnotationAttributes`
   来解析和存储注解信息
  
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.type.AnnotationMetadata;

import java.lang.annotation.Annotation;
import java.util.Map;
import java.util.Set;

public class StandardAnnotationMetadata implements AnnotationMetadata {

    private final Class<?> introspectedClass;
    private final boolean nestedAnnotationsAsMap;

    public StandardAnnotationMetadata(Class<?> introspectedClass, boolean nestedAnnotationsAsMap) {
        this.introspectedClass = introspectedClass;
        this.nestedAnnotationsAsMap = nestedAnnotationsAsMap;
    }

    @Override
    public Set<String> getAnnotationTypes() {
        return AnnotationUtils.getAnnotationTypes(this.introspectedClass);
    }

    @Override
    public boolean hasAnnotation(String annotationName) {
        return AnnotationUtils.
		  findAnnotation(this.introspectedClass, annotationName) != null;
    }

    @Override
    public Map<String, Object> getAnnotationAttributes(String annotationName) {
        return AnnotationUtils.
		   getAnnotationAttributes(this.introspectedClass, annotationName, this.nestedAnnotationsAsMap, true);
    }

    @Override
    public String getClassName() {
        return this.introspectedClass.getName();
    }

    // 其他方法实现...

    public static StandardAnnotationMetadata from(Class<?> introspectedClass) {
        return new StandardAnnotationMetadata(introspectedClass, false);
    }

    public static StandardAnnotationMetadata from(Annotation annotation) {
        return new StandardAnnotationMetadata(annotation, false);
    }
}

StandardAnnotationMetadata注意事项

-性能考虑：
  -创建`StandardAnnotationMetadata`实例时
     会解析类或注解上的所有注解信息
	 因此在性能敏感的场景中需要谨慎使用
  
- 注解保留策略：
  -确保注解的保留策略(`RetentionPolicy`)设置为`RUNTIME`
    否则在运行时无法通过反射获取注解信息

-嵌套注解:
  -`StandardAnnotationMetadata`支持嵌套注解的解析
    可通过 `nestedAnnotationsAsMap`参数控制嵌套注解的处理方式

例

import org.springframework.core.type.StandardAnnotationMetadata;
import org.springframework.stereotype.Component;

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomAnnotation {
    String value() default "";
}

@Component
@MyCustomAnnotation(value = "MyValue")
public class MyAnnotatedClass {
    // 类内容
}

public class StandardAnnotationMetadataExample {
    public static void main(String[] args) {
        // 示例 1: 从类创建 StandardAnnotationMetadata 实例
        StandardAnnotationMetadata metadataFromClass =
     		StandardAnnotationMetadata.from(MyAnnotatedClass.class);

        // 检查是否存在 @Component 注解
        if (metadataFromClass.hasAnnotation(Component.class.getName())) {
            System.out.println("MyAnnotatedClass 类上有 @Component 注解");
        }

        // 获取 @Component 注解的 value 属性值
        Map<String, Object> componentAttributes = 
		   metadataFromClass.getAnnotationAttributes(Component.class.getName());
        String componentValue = componentAttributes.get("value").toString();
        System.out.println("@Component 注解的 value 属性值: " + componentValue);

        // 示例 2: 从注解创建 StandardAnnotationMetadata 实例
        MyCustomAnnotation annotation =
     		MyAnnotatedClass.class.getAnnotation(MyCustomAnnotation.class);
        StandardAnnotationMetadata metadataFromAnnotation =
    		StandardAnnotationMetadata.from(annotation);

        // 检查是否存在 MyCustomAnnotation 注解
        if (metadataFromAnnotation.hasAnnotation(MyCustomAnnotation.class.getName())) {
            System.out.println("MyAnnotatedClass 类上有 MyCustomAnnotation 注解");
        }

        // 获取 MyCustomAnnotation 注解的 value 属性值
        Map<String, Object> customAnnotationAttributes =
     		metadataFromAnnotation.getAnnotationAttributes(MyCustomAnnotation.class.getName());
        String customAnnotationValue = customAnnotationAttributes.get("value").toString();
        System.out.println("MyCustomAnnotation 注解的 value 属性值: " + customAnnotationValue);
    }
}

========================输出==============================
 
MyAnnotatedClass 类上有 @Component 注解
@Component 注解的 value 属性值: 
MyAnnotatedClass 类上有 MyCustomAnnotation 注解
MyCustomAnnotation 注解的 value 属性值: MyValue