Таинственная и мощная аннотация @SpringBootApplication

Spring Boot Java

Введение

Большую часть конфигурации можно заменить классами Java + аннотациями, в то время как вSpringBootНаиболее заметной в проекте является аннотация @SpringBootApplication, которая отмечена на каждом классе запуска SpringBoot.

Эта аннотацияSpringBootКакое влияние оказывают запуск и автоматическая настройка? В этой статье будет проанализирован его исходный код для больших парней и раскрыта тайна аннотации @SpringBootApplication.

2. Текст

Меня очень интересует автоматическая настройка проекта SpringBoot, поэтому я изучил его исходный код и разобрал часть его содержимого.Если есть какие-то ошибки, прошу поправить меня~ Без лишних слов, сразу к исходникам;

Исходный код аннотации @SpringBootApplication выглядит следующим образом:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}

Видно, что это составная аннотация, включающая в общей сложности 7 различных аннотаций, последующий анализ этих 7 различных аннотаций.

2.1 Примечания

2.1.1 Аннотация 1: @Target({ElementType.TYPE})

Он используется для указания области действия аннотации, а TYPE указывает, что областью действия является класс или интерфейс.

2.1.2 Аннотация 2: @Retention(RetentionPolicy.RUNTIME)

2.1.3 Аннотация 3: @Документировано

Указывает, что этот комментарий задокументирован javadoc.

2.1.4 Аннотация 4: @Унаследовано

В аннотации, когда родительский класс аннотирован @SpringBootApplication, подкласс также унаследует эту аннотацию (недействительно для класса реализации интерфейса).

2.1.5 Аннотация 5: @SpringBootConfiguration

Нижний слой по-прежнему представляет собой аннотацию @Configuration, исходный код выглядит следующим образом:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

2.1.6 Аннотация 6: @ComponentScan

Аннотация @ComponentScan очень важна в Spring.Его функция, соответствующая элементу @ComponentScan в конфигурации XML, фактически состоит в автоматическом сканировании и загрузке квалифицированных компонентов (таких как @Component и @Repository и т. д.) или определений bean-компонентов и, наконец, загрузки эти определения bean-компонентов в контейнер IoC.

Область автоматического сканирования @ComponentScan может быть детализирована с помощью атрибутов, таких как basePackages.Если не указано, реализация платформы Spring по умолчанию будет сканировать из пакета, в котором объявлен класс, в котором объявлен @ComponentScan. Таким образом, класс запуска SpringBoot лучше всего размещать в корневом пакете, поскольку basePackages не указан по умолчанию.

2.2 Аннотация: @EnableAutoConfiguration

Лично я считаю, что @EnableAutoConfiguration является самой важной аннотацией, и ее роль можно резюмировать следующим образом: с помощью @Import загрузить все определения bean-компонентов, соответствующие условиям автоконфигурации, в контейнер IoC.

Его исходный код выглядит следующим образом:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
  String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
  
  Class<?>[] exclude() default {};
  
  String[] excludeName() default {};
}

Здесь нужно обратить внимание на две аннотации @AutoConfigurationPackage и @Import(AutoConfigurationImportSelector.class).

2.2.1 Аннотация: @AutoConfigurationPackage

Исходный код выглядит следующим образом:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

Можно обнаружить, что ядром этой аннотации на самом деле является аннотация Import, указывающая, что пакет класса, отмеченный этой аннотацией, должен быть зарегистрирован в AutoConfigurationPackages. Затем посмотрите на класс Registrar:

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
​
    @Override
      //metadata是我们注解所在的元信息
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            //将我们注解所在包下所有的组件进行注册
      register(registry, new PackageImport(metadata).getPackageName());
    }
​
    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
      return Collections.singleton(new PackageImport(metadata));
    }
}

Основным методом в этом классе является метод регистрации:

private static final String BEAN = AutoConfigurationPackages.class.getName();
  
  public static void register(BeanDefinitionRegistry registry, String... packageNames) {
    if (registry.containsBeanDefinition(BEAN)) {
      BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
      ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
      constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
​    }
    else {
      GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
      beanDefinition.setBeanClass(BasePackages.class);
      beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
      beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
      registry.registerBeanDefinition(BEAN, beanDefinition);
    }
}

Логика метода register очень понятна: если бин уже зарегистрирован, получить значение параметра его конструктора и добавить имя пакета, в противном случае создать новое определение бина и зарегистрировать его. С помощью аннотации @AutoConfigurationPackage можно зарегистрировать все компоненты пакета, в котором находится аннотация.

2.2.2 Примечания:@Import(AutoConfigurationImportSelector.class)

Эта аннотация импортирует класс AutoConfigurationImportSelector.Основным методом этого класса является метод selectImports, реализующий интерфейс ImportSelector. Метод импортируется на основе пакетов и компонентов jar, которые мы настроили в файле pom.xml. Таким образом, метод возвращает массив String с полным путем к классу, а возвращенный класс будет управляться контейнером Spring. Исходный код метода выглядит следующим образом:

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
  if (!isEnabled(annotationMetadata)) {
    return NO_IMPORTS;
  }
  AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
      .loadMetadata(this.beanClassLoader);
  AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
      annotationMetadata);
  return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

Структура этого метода также очень понятна.Во-первых, метод isEnabled используется для определения необходимости его импорта.Если необходимо импортировать, информация о конфигурации получается через метод loadMetadata, а автоматическая сборка выполняется через получить автоконфигуратионэнтри. Исходный код метода isEnabled выглядит следующим образом:

protected boolean isEnabled(AnnotationMetadata metadata) {
  if (getClass() == AutoConfigurationImportSelector.class) {
    return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
  }
  return true;
}

Этот метод определяет, требуется ли автоматическая настройка с помощью элемента конфигурации EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, который по умолчанию имеет значение true. Исходный код метода loadMetadata выглядит следующим образом:

protected static final String PATH = "META-INF/" + "spring-autoconfigure-metadata.properties";
​
  public static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
    return loadMetadata(classLoader, PATH);
  }
​
  static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
    try {
      Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
          : ClassLoader.getSystemResources(path);
      Properties properties = new Properties();
      while (urls.hasMoreElements()) {
        properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
      }
      return loadMetadata(properties);
    }
    catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
    }
  }
  static AutoConfigurationMetadata loadMetadata(Properties properties) {
    return new PropertiesAutoConfigurationMetadata(properties);
  }

Вы можете видеть, что этот метод загрузит всю информацию о конфигурации в META-INF/spring-autoconfigure-metadata.properties и завершит ее в объект AutoConfigurationMetadata для возврата.

Примечание. Файл spring-autoconfigure-metadata.properties находится в папке spring-boot-autoconfigure-2.1.9.RELEASE.jar/META-INF.

Исходный код метода getAutoConfigurationEntry выглядит следующим образом:

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
      AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
      return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    configurations = removeDuplicates(configurations);
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
    configurations = filter(configurations, autoConfigurationMetadata);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

Этот метод является основным технологическим методом Автоконфигурации.Каждую строку этого метода можно рассматривать как шаг, тогда этапы обработки следующие:

1. Загрузите метод getAttribute значения атрибута, настроенный с помощью аннотации @EnableAutoConfiguration:

protected AnnotationAttributes getAttributes(AnnotationMetadata metadata) {
    String name = getAnnotationClass().getName();
    AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(name, true));
    Assert.notNull(attributes, () -> "No auto-configuration attributes found. Is " + metadata.getClassName()
        + " annotated with " + ClassUtils.getShortName(name) + "?");
    return attributes;
}

2. Получите значение ключа с полным именем класса @EnableAutoConfiguration в файле META-INF/spring.factories, метод getCandidateConfigurations:

​protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
        getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
        + "are using a custom packaging, make sure that file is correct.");
    return configurations;
}
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

Среди них функция метода SpringFactoriesLoader.loadFactoryNames() заключается в использовании данного загрузчика классов для загрузки полного имени класса реализации фабрики данного типа из META-INF/spring.factories;

3. Дедупликация;

4. Получить имя класса для исключения, эти классы можно настроить в аннотации @EnableAutoConfiguration;

5. Проверьте оба набора;

6. Удалите классы, которые необходимо исключить;

7. Фильтровать по OnBeanCondition, OnClassCondition и другим условиям (можете узнать больше, если интересно);

8. Транслировать события, получать все классы реализации AutoConfigurationImportListener, а затем генерировать события для трансляции;

9. Инкапсулируйте полное имя класса, который необходимо собрать и исключить, в возвращаемый объект AutoConfigurationEntry.

Следовательно, @EnableAutoConfiguration можно просто резюмировать следующим образом: поиск всех файлов конфигурации META-INF/spring.factories из пути к классам и создание экземпляров элементов конфигурации, соответствующих EnableAutoConfiguration, в соответствующих классах конфигурации контейнера IoC, помеченных @Configuration, посредством отражения и загруженных в контейнер IoC.

3. Резюме

Из приведенного выше анализа видно, что @SpringBootApplicationДействие аннотации заключается в объявлении аннотированного класса в качестве класса конфигурации через @SpringApplicationConfiguration, который сканируется AnnotationConfigApplicationContext и инициализируется контейнером Spring.

Сканируйте, фильтруйте и загружайте необходимые компоненты через @EnableAutoConfiguration; сканируйте и регистрируйте все классы, помеченные @Component и его вложенные аннотации, через @ComponentScan; совместная работа этих аннотаций реализует мощные возможности автоматической настройки проекта springboot.

Выше приведено полное содержание этого резюме, я надеюсь, что оно может быть полезно для всех. Если есть какие-либо упущения или ошибки, пожалуйста, не стесняйтесь их исправлять.

Автор: Vivo Internet Development Team - Пэн Пэн

Категории