• Spring-底层架构核心概念

    Spring底层核心组件

    BeanDefinition

    BeanDefinition表示Bean定义，有很多属性用来描述Bean的特点：

    • class，表示Bean类型

    • scope，表示Bean作用域，单例或原型等

    • lazyInit：表示Bean是否是懒加载

    • initMethodName：表示Bean初始化时要执行的方法

    • destroyMethodName：表示Bean销毁时要执行的方法

    • 还有很多...

    定义Bean的方式主要分为两种：

    • 申明式定义

      1. 1、
      2. 2、@Bean
      3. 3、@Component(@Service,@Controller)

    • 编程式定义

      1. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
      2.  
      3. // 生成一个BeanDefinition对象，并设置beanClass为User.class，并注册到ApplicationContext中
      4. AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
      5. beanDefinition.setBeanClass(User.class);
      6. beanDefinition.setScope("prototype"); // 设置作用域
      7. beanDefinition.setInitMethodName("init"); // 设置初始化方法
      8. beanDefinition.setLazyInit(true); // 设置懒加载
      9.  
      10. context.registerBeanDefinition("user", beanDefinition);
      11. System.out.println(context.getBean("user"));

    BeanDefinitionReader

    BeanDefinition读取器，虽然开发中用的很少，但是源码中用得很多

    AnnotatedBeanDefinitionReader

    把某个类转换为BeanDefinition，并且解析类上的注解

    1. AnnotationConfigApplicationContext context = new
    2. AnnotationConfigApplicationContext(AppConfig.class);
    3. AnnotatedBeanDefinitionReader annotatedBeanDefinitionReader = new AnnotatedBeanDefinitionReader(context);
    4. // 将User.class解析为BeanDefinition
    5. annotatedBeanDefinitionReader.register(User.class);
    6. System.out.println(context.getBean("user"));

    可以解析的注解：@Conditional、@Scope、@Lazy、@Primary、@DependsOn、 @Role、@Description

    XmlBeanDefinitionReader

    解析标签

    1. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    2. XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(context);
    3. int i = xmlBeanDefinitionReader.loadBeanDefinitions("spring.xml");
    4. System.out.println(context.getBean("user"));

    ClassPathBeanDefinitionScanner

    扫描器，可以进行扫描，扫描某个包路径，对扫描到的类进行解析

    1. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    2. context.refresh();
    3. ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
    4. scanner.scan("com.gax");
    5. System.out.println(context.getBean("userService"));

    BeanFactory

    Bean工厂，负责创建Bean，并且提供获取Bean的 API

    ApplicationContext就是BeanFactory的一种

    1. public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory,
    2. HierarchicalBeanFactory,
    3. MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    4. ...
    5. }
    6.  
    7. HierarchicalBeanFactory: 支持父子Bean工厂，子Bean工厂获取不到时，可以到父Bean工厂去获取
    8. ListableBeanFactory: 展示Bean的名字、展示Bean的数量、统计的信息、拿某一个类型的Bean，类似列表的功能
    9. EnvironmentCapable: 获取环境变量的功能
    10. ApplicationEventPublisher: 事件发布的功能
    11. MessageSource: 国际化的功能
    12. ResourcePatternResolver: 获取某些资源、解析某些资源的功能

    Spring源码中，BeanFactory接口非常重要的实现类： DefaultListableBeanFactory

    ApplicationContext.getBean() 调用的就是 DefaultListableBeanFactory 的getBean()方法

    DefaultListableBeanFactory 可以单独使用：

    1. DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    2. AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
    3. beanDefinition.setBeanClass(User.class);
    4. beanFactory.registerBeanDefinition("user", beanDefinition);
    5. System.out.println(beanFactory.getBean("user"));

    ApplicationContext

    ApplicationContext是个接口，实际上也是一个BeanFactory，不过比BeanFactory 更加强大：

    1、HierarchicalBeanFactory：拥有获取父BeanFactory的功能

    2、ListableBeanFactory：拥有获取beanNames的功能

    3、ResourcePatternResolver：资源加载器，可以一次性获取多个资源（文件资源等等）

    4、EnvironmentCapable：可以获取运行时环境（没有设置运行时环境功能）

    5、ApplicationEventPublisher：拥有广播事件的功能（没有添加事件监听器的功能）

    6、MessageSource：拥有国际化功能

    ApplicationContext两个重要的实现类：

    1、AnnotationConfigApplicationContext

    2、ClassPathXmlApplicationContext

    国际化

    定义一个MessageSource

    1. @Bean
    2. public MessageSource messageSource() {
    3.     ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
    4.     messageSource.setBasename("messages");
    5.     return messageSource;
    6. }

    ApplicationContext拥有国际化的功能，可以直接用

    context.getMessage("test", null, new Locale("en_CN"))

    资源加载

    可以利用ApplicationContext获取某个文件的内容

    1. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    2.  
    3. Resource resource = context.getResource("file://D:\\UserService.java");
    4. System.out.println(resource.contentLength());
    5. System.out.println(resource.getFilename());
    6.  
    7. Resource resource1 = context.getResource("https://www.baidu.com");
    8. System.out.println(resource1.contentLength());
    9. System.out.println(resource1.getURL());
    10.  
    11. Resource resource2 = context.getResource("classpath:spring.xml");
    12. System.out.println(resource2.contentLength());
    13. System.out.println(resource2.getURL());
    14.                                         
    15. Resource[] resources = context.getResources("classpath:com/gax/*.class");
    16. for (Resource resource : resources) {
    17.     System.out.println(resource.contentLength());
    18.     System.out.println(resource.getFilename());
    19. }

    获取运行时环境

    1. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    2.  
    3. Map systemEnvironment = context.getEnvironment().getSystemEnvironment();
    4. System.out.println(systemEnvironment); //操作系统层面的环境变量
    5.  
    6. Map systemProperties = context.getEnvironment().getSystemProperties();
    7. System.out.println(systemProperties); //运行java通过-D指定的环境变量
    8.  
    9. MutablePropertySources propertySources = context.getEnvironment().getPropertySources();
    10. System.out.println(propertySources); //最强大的，包含上面两种和PropertySources注解的变量
    11.  
    12. System.out.println(context.getEnvironment().getProperty("NO_PROXY")); //操作系统
    13. System.out.println(context.getEnvironment().getProperty("sun.jnu.encoding")); //jvm -D指定
    14. System.out.println(context.getEnvironment().getProperty("gax")); //property里面的

    事件发布

    定义一个事件监听器

    1. @Bean
    2. public ApplicationListener applicationListener() {
    3.     return new ApplicationListener() {
    4.         @Override
    5.         public void onApplicationEvent(ApplicationEvent event) {
    6.         	System.out.println("接收到了一个事件");
    7.         }
    8.     };
    9. }

    发布一个事件

    context.publishEvent("yeah");

    类型转化

    Spring提供了一些方便类型转化的技术

    PropertyEditor

    JDK中提供的类型转化工具类，使用示例：

    1. public class StringToUserPropertyEditor extends PropertyEditorSupport implements PropertyEditor
    2. {
    3.     @Override
    4.     public void setAsText(String text) throws IllegalArgumentException
    5.     {
    6.         User user = new User();
    7.         user.setName(text);
    8.         this.setValue(user);
    9.     }
    10.     
    11.     // 单独使用示例
    12.     public static void main(String[] args)
    13.     {
    14.         StringToUserPropertyEditor propertyEditor = new StringToUserPropertyEditor();
    15.         
    16.         propertyEditor.setAsText("11");
    17.         User value = (User)propertyEditor.getValue();
    18.         System.out.println(value);
    19.         System.out.println(value.getName());
    20.     }
    21. }
    22.  
    23. 输出：
    24. com.gax.service.User@5a07e868
    25. 11

    向Spring中注册PropertyEditor：

    1. @Bean
    2. public CustomEditorConfigurer customEditorConfigurer()
    3. {
    4.     CustomEditorConfigurer customEditorConfigurer = new CustomEditorConfigurer();
    5.     Map, Class> propertyEditorMap = new HashMap<>();
    6.     // StringToUserPropertyEditor可以将String转化成User类型，
    7.     // 在Spring源码中，如果当前对象是String，而需要的类型是User，就会用该PropertyEditor做类型转化
    8.     propertyEditorMap.put(User.class, StringToUserPropertyEditor.class);
    9.     customEditorConfigurer.setCustomEditors(propertyEditorMap);
    10.     return customEditorConfigurer;
    11. }
    12.  
    13. // 示例代码
    14. @Component
    15. public class UserService
    16. {
    17.     @Value("ccc")
    18.     private User user; //这里需要类型转换
    19.     
    20.     public void test()
    21.     {
    22.         System.out.println(user);
    23.     }
    24. }
    25.  
    26. // 测试
    27. public class Test 
    28. {
    29. 	public static void main(String[] args) 
    30. 	{
    31.  
    32. 		// 创建一个Spring容器
    33. 		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    34.  
    35. 		UserService userService = (UserService) applicationContext.getBean("userService");
    36. 		userService.test();
    37. 	}
    38. }
    39.  
    40. 输出：（输出的是一个User，转换成功）
    41. com.gax.service.User@17ed40e0

    ConversionService

    Spring中提供的类型转化服务，它比PropertyEditor更强大

    1. public class StringToUserConverter implements ConditionalGenericConverter
    2. {
    3.     @Override
    4.     public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType)
    5.     {
    6.         return sourceType.getType().equals(String.class) && targetType.getType().equals(User.class);
    7.     }
    8.     
    9.     @Override
    10.     public Set getConvertibleTypes()
    11.     {
    12.         return Collections.singleton(new GenericConverter.ConvertiblePair(String.class, User.class));
    13.     }
    14.     
    15.     @Override
    16.     public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
    17.     {
    18.         User user = new User();
    19.         user.setName((String)source);
    20.         return user;
    21.     }
    22. }
    23.  
    24. // 单独使用
    25. public class Test 
    26. {
    27. 	public static void main(String[] args) 
    28. 	{
    29. 		DefaultConversionService conversionService = new DefaultConversionService();
    30. 		conversionService.addConverter(new StringToUserConverter());
    31. 		User value = conversionService.convert("1", User.class);
    32. 		System.out.println(value);
    33. 	}
    34. }

    向Spring中注册ConversionService：

    1. @Bean
    2. public ConversionServiceFactoryBean conversionService()
    3. {
    4.     ConversionServiceFactoryBean conversionServiceFactoryBean = new ConversionServiceFactoryBean();
    5.     conversionServiceFactoryBean.setConverters(Collections.singleton(new StringToUserConverter()));
    6.     return conversionServiceFactoryBean;
    7. }

    TypeConverter

    Spring提供更高级的转换类SimpleTypeConverter，可以支持上面两种

    1. public class Test 
    2. {
    3. 	public static void main(String[] args) 
    4. 	{
    5. 		SimpleTypeConverter typeConverter = new SimpleTypeConverter();
    6. 		typeConverter.registerCustomEditor(User.class, new StringToUserPropertyEditor());
    7. //		DefaultConversionService conversionService = new DefaultConversionService();
    8. //		conversionService.addConverter(new StringToUserConverter());
    9. //		typeConverter.setConversionService(conversionService);
    10. 		User value = typeConverter.convertIfNecessary("1", User.class);
    11. 		System.out.println(value);
    12. 	}
    13. }

    扩展：

    1. // getBean指定类型转换
    2. AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    3. UserService userService = applicationContext.getBean("userService", UserService.class);
    4.  
    5. // 可以对应到Spring源码：AbstractBeanFactory#adaptBeanInstance
    6.  T adaptBeanInstance(String name, Object bean, @Nullable Class requiredType) {
    7. 	// Check if required type matches the type of the actual bean instance.
    8. 	if (requiredType != null && !requiredType.isInstance(bean)) {
    9. 		try {
    10. 			// SimpleTypeConverter
    11. 			Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
    12. 			if (convertedBean == null) { // 已经转换过了返回，没转换报错
    13. 				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    14. 			}
    15. 			return (T) convertedBean;
    16. 		}
    17. 		catch (TypeMismatchException ex) {
    18. 			if (logger.isTraceEnabled()) {
    19. 				logger.trace("Failed to convert bean '" + name + "' to required type '" +
    20. 						ClassUtils.getQualifiedName(requiredType) + "'", ex);
    21. 			}
    22. 			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    23. 		}
    24. 	}
    25. 	return (T) bean;
    26. }

    OrderComparator

    Spring所提供的一种比较器，有@Order注解、实现Ordered接口两种使用方式，通过指定的值进行比较或排序。

    实现Ordered接口示例代码：

    1. public class A implements Ordered
    2. {
    3.     @Override
    4.     public int getOrder()
    5.     {
    6.         return 3;
    7.     }
    8.     
    9.     @Override
    10.     public String toString()
    11.     {
    12.         return this.getClass().getSimpleName();
    13.     }
    14. }
    15.  
    16. public class B implements Ordered
    17. {
    18.     @Override
    19.     public int getOrder()
    20.     {
    21.         return 2;
    22.     }
    23.     
    24.     @Override
    25.     public String toString()
    26.     {
    27.         return this.getClass().getSimpleName();
    28.     }
    29. }
    30.  
    31. public class Main
    32. {
    33.     public static void main(String[] args)
    34.     {
    35.         A a = new A(); // order=3
    36.         B b = new B(); // order=2
    37.         OrderComparator comparator = new OrderComparator();
    38.         System.out.println(comparator.compare(a, b)); // 1 (a>b,a
    39.         List list = new ArrayList<>();
    40.         list.add(a);
    41.         list.add(b);
    42.         // 按order值升序排序
    43.         list.sort(comparator);
    44.         System.out.println(list); // B，A
    45.     }
    46. }
    47.  
    48. 输出：
    49. 1
    50. [B, A]

    Spring还提供了一个OrderComparator的子类： AnnotationAwareOrderComparator，它支持用@Order来指定order值

    1. @Order(3)
    2. public class A
    3. {
    4.     @Override
    5.     public String toString()
    6.     {
    7.         return this.getClass().getSimpleName();
    8.     }
    9. }
    10.  
    11. @Order(2)
    12. public class B
    13. {
    14.     @Override
    15.     public String toString()
    16.     {
    17.         return this.getClass().getSimpleName();
    18.     }
    19. }
    20.  
    21. public class Main
    22. {
    23.     public static void main(String[] args)
    24.     {
    25.         A a = new A(); // order=3
    26.         B b = new B(); // order=2
    27. 		AnnotationAwareOrderComparator comparator = new AnnotationAwareOrderComparator();
    28.         System.out.println(comparator.compare(a, b)); // 1
    29.         List list = new ArrayList<>();
    30.         list.add(a);
    31.         list.add(b);
    32.         // 按order值升序排序
    33.         list.sort(comparator);
    34.         System.out.println(list); // B，A
    35.     }
    36. }
    37.  
    38. 输出：
    39. 1
    40. [B, A]
    41.  
    42.  
    43. // 关键源码：AnnotationAwareOrderComparator#findOrder
    44. protected Integer findOrder(Object obj) {
    45.     // 先获取Ordered接口中getOrder()方法返回的数值
    46.     Integer order = super.findOrder(obj);
    47.     if (order != null) {
    48.         return order;
    49.     }
    50.     // 如果没有实现Ordered接口，则获取@Order注解中指定的值
    51.     return findOrderFromAnnotation(obj);
    52. }

    BeanPostProcessor

    BeanPostProcess表示Bean的后置处理器，可以定义一个或多个BeanPostProcessor

    1. @Component
    2. public class GaxBeanPostProcessor implements BeanPostProcessor 
    3. {
    4.     @Override
    5.     public Object postProcessBeforeInitialization(Object bean, String beanName) 
    6. 	{
    7.         if ("userService".equals(beanName)) 
    8. 		{
    9.             System.out.println("初始化前");
    10.         }
    11.         return bean;
    12.     }
    13.  
    14.     @Override
    15.     public Object postProcessAfterInitialization(Object bean, String beanName) 
    16. 	{
    17.         if ("userService".equals(beanName)) 
    18. 		{
    19.             System.out.println("初始化后");
    20.         }
    21.         return bean;
    22.     }
    23. }

    BeanPostProcessor可以在任意一个Bean的初始化之前以及初始化之后去额外的做一些用户自定义的逻辑，当然还可以通过判断beanName来进行针对性处理（针对某个Bean，或某部分Bean）。

    我们可以通过定义BeanPostProcessor来干涉Spring创建Bean的过程

    BeanFactoryPostProcessor

    Bean工厂的后置处理器，和BeanPostProcessor类似。

    BeanPostProcessor是干涉Bean的创建过程，BeanFactoryPostProcessor是干涉BeanFactory的创建过程。

    1. @Component
    2. public class GaxBeanFactoryPostProcessor implements BeanFactoryPostProcessor
    3. {
    4.     @Override
    5.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
    6.     {
    7.         System.out.println("加工beanFactory");
    8.     }
    9. }

    FactoryBean

    上面提到，可以通过BeanPostPorcessor来干涉Spring创建Bean的过程。但是如果我们想一个Bean完完全全由我们来创造，也是可以的，比如通过FactoryBean：

    1. @Component
    2. public class GaxFactoryBean implements FactoryBean
    3. {
    4.     @Override
    5.     public Object getObject()
    6.     {
    7.         return new UserService();
    8.     }
    9.     
    10.     @Override
    11.     public Class getObjectType()
    12.     {
    13.         return UserService.class;
    14.     }
    15. }
    16.  
    17. // 测试
    18. public class Test
    19. {
    20.     public static void main(String[] args) throws IOException
    21.     {
    22.         // 创建一个Spring容器
    23. 		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    24. 		Object gaxFactoryBean = applicationContext.getBean("gaxFactoryBean");
    25. 		Object gaxFactoryBean2 = applicationContext.getBean("&gaxFactoryBean");
    26. 		Object gaxFactoryBean3 = applicationContext.getBean("&&&&&&gaxFactoryBean");
    27. 		System.out.println(gaxFactoryBean);
    28. 		System.out.println(gaxFactoryBean2);
    29. 		System.out.println(gaxFactoryBean3);
    30. 	}
    31. }
    32.  
    33. 输出：
    34. com.gax.service.UserService@6e3c1e69
    35. com.gax.GaxFactoryBean@5f150435
    36. com.gax.GaxFactoryBean@5f150435

    注意：通过这种方式创造出来的UserService的Bean，只会经过初始化后，其他Spring的生命周期步骤是不会经过的，比如依赖注入。

    通过@Bean也可以生成一个对象作为Bean，那么和FactoryBean的区别是什么呢？

    其实在很多场景下他俩是可以替换的，但是站在原理层面来说的，区别很明显，@Bean定义的Bean是会经过完整的Bean生命周期的。

    ExcludeFilter和IncludeFilter

    ExcludeFilter表示排除过滤器，IncludeFilter表示包含过滤器

    1. // 扫描com.gax这个包下面的所有类，但是排除UserService类
    2. // 也就是就算类上面有@Component注解也不会成为Bean
    3. @ComponentScan(value = "com.gax", excludeFilters = {
    4.     @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = UserService.class)})
    5. public class AppConfig {
    6. }
    7.  
    8. // 就算UserService类上没有@Component注解，也会被扫描成为一个Bean
    9. @ComponentScan(value = "com.gax", includeFilters = {
    10.     @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = UserService.class)})
    11. public class AppConfig {
    12. }

    FilterType分为：

    1、ANNOTATION：是否包含某个注解

    2、ASSIGNABLE_TYPE：是否是某个类

    3、ASPECTJ：是否符合某个Aspectj表达式

    4、REGEX：是否符合某个正则表达式

    5、CUSTOM：自定义

    Spring内部怎么支持@Component注解扫描的？

    在Spring的扫描逻辑中，默认会添加一个AnnotationTypeFilter给includeFilters，表示默认情况下 Spring扫描过程中会认为类上有@Component注解的就是Bean。

    1. // ClassPathScanningCandidateComponentProvider#registerDefaultFilters
    2. protected void registerDefaultFilters() {
    3.  
    4. 	// 注册@Component对应的AnnotationTypeFilter
    5. 	this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    6.  
    7. 	... ...
    8. }

    MetadataReader、ClassMetadata、 AnnotationMetadata

    在Spring中需要去解析类的信息，比如类名、类中的方法、类上的注解，这些都可以称之为类的元数 据，所以Spring中对类的元数据做了抽象，并提供了一些工具类。

    1. public interface MetadataReader {
    2.  
    3. 	/**
    4. 	 * Return the resource reference for the class file.
    5. 	 */
    6. 	Resource getResource();
    7.  
    8. 	/**
    9. 	 * Read basic class metadata for the underlying class.
    10. 	 */
    11. 	ClassMetadata getClassMetadata();
    12.  
    13. 	/**
    14. 	 * Read full annotation metadata for the underlying class,
    15. 	 * including metadata for annotated methods.
    16. 	 */
    17. 	AnnotationMetadata getAnnotationMetadata();
    18. }
    19.  
    20. // 类的元数据
    21. public interface ClassMetadata {
    22.  
    23. 	/**
    24. 	 * Return the name of the underlying class.
    25. 	 */
    26. 	String getClassName();
    27.  
    28. 	/**
    29. 	 * Return whether the underlying class represents an interface.
    30. 	 */
    31. 	boolean isInterface();
    32.  
    33. 	/**
    34. 	 * Return whether the underlying class represents an annotation.
    35. 	 * @since 4.1
    36. 	 */
    37. 	boolean isAnnotation();
    38.  
    39. 	/**
    40. 	 * Return whether the underlying class is marked as abstract.
    41. 	 */
    42. 	boolean isAbstract();
    43.  
    44. 	/**
    45. 	 * Return whether the underlying class represents a concrete class,
    46. 	 * i.e. neither an interface nor an abstract class.
    47. 	 */
    48. 	default boolean isConcrete() {
    49. 		return !(isInterface() || isAbstract());
    50. 	}
    51.  
    52. 	... ...
    53. }
    54.  
    55. // 注解元数据
    56. public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {
    57.  
    58. 	/**
    59. 	 * Get the fully qualified class names of all annotation types that
    60. 	 * are present on the underlying class.
    61. 	 * @return the annotation type names
    62. 	 */
    63. 	default Set getAnnotationTypes() {
    64. 		return getAnnotations().stream()
    65. 				.filter(MergedAnnotation::isDirectlyPresent)
    66. 				.map(annotation -> annotation.getType().getName())
    67. 				.collect(Collectors.toCollection(LinkedHashSet::new));
    68. 	}
    69.     
    70.     /**
    71. 	 * Determine whether an annotation of the given type is present on
    72. 	 * the underlying class.
    73. 	 * @param annotationName the fully qualified class name of the annotation
    74. 	 * type to look for
    75. 	 * @return {@code true} if a matching annotation is present
    76. 	 */
    77. 	default boolean hasAnnotation(String annotationName) {
    78. 		return getAnnotations().isDirectlyPresent(annotationName);
    79. 	}
    80.  
    81. 	/**
    82. 	 * 可以判断类下面有没有指定注解，比如说判断一个类下面有没有@Bean修饰的方法
    83. 	 * Determine whether the underlying class has an annotation that is itself
    84. 	 * annotated with the meta-annotation of the given type.
    85. 	 * @param metaAnnotationName the fully qualified class name of the
    86. 	 * meta-annotation type to look for
    87. 	 * @return {@code true} if a matching meta-annotation is present
    88. 	 */
    89. 	default boolean hasMetaAnnotation(String metaAnnotationName) {
    90. 		return getAnnotations().get(metaAnnotationName,
    91. 				MergedAnnotation::isMetaPresent).isPresent();
    92. 	}
    93.  
    94. 	... ...
    95. }

    MetadataReader表示类的元数据读取器，默认实现类为SimpleMetadataReader。

    1. public class Test
    2. {
    3.     public static void main(String[] args) throws IOException
    4.     {
    5.         SimpleMetadataReaderFactory simpleMetadataReaderFactory = new SimpleMetadataReaderFactory();
    6.         // 构造一个MetadataReader
    7.         MetadataReader metadataReader = simpleMetadataReaderFactory.getMetadataReader("com.gax.service.UserService");
    8.         // 得到一个ClassMetadata，并获取了类名
    9.         ClassMetadata classMetadata = metadataReader.getClassMetadata();
    10.         System.out.println(classMetadata.getClassName());
    11.         // 获取一个AnnotationMetadata，并获取类上的注解信息
    12.         AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    13.         for (String annotationType : annotationMetadata.getAnnotationTypes())
    14.         {
    15.             System.out.println(annotationType);
    16.         }
    17. 	}
    18. }
    19.  
    20. 输出：
    21. com.gax.service.UserService
    22. org.springframework.stereotype.Component

    注意：SimpleMetadataReader去解析类时，使用的ASM技术。

    ASM简述：把类当成普通文件，通过字节流读出来，如果符合字节码规范，就根据字节码的格式获取类的信息

    为什么要使用ASM技术？

    Spring启动的时候需要去扫描，如果指定的包路径比较宽泛，那么扫描的类是非常多的，那如果在Spring启动时就把这些类全部加载进JVM了，这样不太好，所以使用了 ASM技术

  • 相关阅读:
    6个步骤轻松实现 postman 接口压力测试（建议收藏）
    Android启动摄像机拍照&存储&展示
    解决计算机视觉模型中的种族和性别偏见问题，Meta开源 FACET工具
    MySQL日志
    《深入浅出OCR》第四章：OCR文字识别
    c++内存对齐
    文化融合与社交网络：Facebook的角色
    17、生成器
    利用共享台球室小程序系统提升用户体验
    IDEA本地将镜像推送到coding制品仓库
  • 原文地址：https://blog.csdn.net/weixin_58482311/article/details/134085792