1. Подробное описание @PostConstruct

@PostConstruct — это встроенная аннотация Java, которая применяется к методам и выполняется сразу после того, как контейнер Spring завершает инициализацию объекта. Это может быть полезно для выполнения некоторых начальных операций, таких как загрузка данных из словарей.

Синтаксис:

@PostConstruct
public void someMethod() {}

или

public @PostConstruct void someMethod() {}

Задача: Методы, помеченные аннотацией @PostConstruct, выполняются после инициализации объекта контейнером Spring. Они могут использоваться для загрузки данных, таких как данные из словарей.

Порядок выполнения:

Конструктор >> @Autowired >> @PostConstruct

Порядок выполнения и сценарии использования

Методы, помеченные аннотацией @PostConstruct, выполняются один раз при загрузке сервером Servlet. Аннотация @PostConstruct указывает, что метод будет выполнен после конструктора и перед методом init().

Аннотация @PreDestroy указывает, что метод будет выполнен после метода destroy().

Если вам нужно выполнить некоторые инициализационные действия при создании объекта, но эти действия зависят от внедрения зависимостей, вы можете использовать аннотацию @PostConstruct. Метод, помеченный этой аннотацией, будет автоматически вызван после завершения процесса внедрения зависимостей.Таким образом, порядок выполнения методов с аннотацией @PostConstruct следующий:

Статический метод >> Конструктор >> @Autowired >> @PostConstruct

2. Подробное описание аннотации @ConditionalOnMissingBean

Аннотация @ConditionalOnMissingBean используется для проверки наличия бинов определенного типа. Она позволяет зарегистрировать бин только в том случае, если еще нет бинов такого же типа. Это гарантирует, что в контейнере будет только один экземпляр бина данного типа.

Пример использования:

@Component
public class AutoConfig {
  @Bean
  public AConfig aConfig() {
    return new AConfig("lind");
  }

  @Bean
  @ConditionalOnMissingBean(AMapper.class)
  public AMapper aMapper1(AConfig aConfig) {
    return new AMapperImpl1(aConfig);
  }

  @Bean
  public AMapper aMapper2(AConfig aConfig) {
    return new AMapperImpl2(aConfig);
  }
}

Поскольку в aMapper1 был указан бин типа AMapper, который может иметь только одно представление с использованием аннотации @ConditionalOnMissingBean(AMapper.class), при регистрации aMapper2 возникает вышеупомянутая ошибка, что является нормальным поведением.

Удаление аннотации @ConditionalOnMissingBean(AMapper.class) позволяет вам регистрировать ваш бин несколько раз, но тогда вам потребуется использовать @Primary для указания того, какое из представлений вы хотите использовать. Обычно для пользовательских конфигурационных классов следует добавлять аннотацию @ConditionalOnMissingBean, чтобы избежать риска одновременного внедрения нескольких конфигураций. Метка @Primary указывает, какой бин является основным.```java @Bean public AMapper aMapper1(AConfig aConfig) { return new AMapperImpl1(aConfig); }

@Bean @Primary public AMapper aMapper2(AConfig aConfig) { return new AMapperImpl2(aConfig); }

## 3. `@ConditionalOnProperty`

Аннотация `@ConditionalOnProperty` используется для контроля над тем, когда конфигурационные классы должны быть активированы в приложении Spring Boot.

Обычно, при разработке приложений на основе Spring, может потребоваться условно создавать некоторые бины в зависимости от наличия и значений конфигурационных свойств.

Например, возможно, вам нужно зарегистрировать бин DataSource для указания на базу данных производства или тестирования в зависимости от того, установлено ли значение свойства как "prod" или "test".

К счастью, это можно сделать проще, чем кажется. Для этой цели Spring предоставляет аннотацию `@ConditionalOnProperty`.

Кратко говоря, `@ConditionalOnProperty` активирует регистрацию бина только в том случае, если указанное свойство существует и имеет определенное значение. По умолчанию, должно быть определено указанное свойство, и оно не должно быть равно false.

Теперь, когда вы знакомы с использованием аннотации `@ConditionalOnProperty`, давайте более подробно рассмотрим ее работу.


## 4. `@Pointcut` выражения для аннотаций

**`@Pointcut` выражения**

Для определения выражений, используемых для отслеживания аннотаций, используются три типа выражений: `@annotation`, `@within`, `@target`1. `@annotation`
   Соответствует методам, имеющим определенную аннотацию (аннотация применяется к методу)

   ```java
   @annotation(com.test.aop.demo.MyAnnotation)

2. @within Соответствует классам, имеющим определенную аннотацию (аннотация применяется к классу)

   @within(com.test.aop.demo.MyAnnotation)

3. @target Соответствует классам, имеющим определенную аннотацию (аннотация применяется к классу)

   @target(com.test.aop.demo.MyAnnotation)

5. Аннотации @AutoConfigureBefore и @AutoConfigureAfter

Описание:

Если вы хотите управлять порядком загрузки конфигурационных классов в проекте Spring Boot, то вам понадобятся аннотации @AutoConfigureBefore и @AutoConfigureAfter из пакета spring-boot-autoconfigure.

Использование:

@AutoConfigureBefore(A.class) или AutoConfigureBefore({A.class, B.class})

@AutoConfigureBefore(A.class)
public class C {
}

Пояснение:

Класс C будет загружен до класса A.

Использование:

@AutoConfigureAfter(A.class) или AutoConfigureAfter({A.class, B.class})

@AutoConfigureAfter(A.class)
public class C {
}

Описание:

Класс C будет загружен после класса A.

6. Три способа использования аннотации @Import в Spring

Три основных способа использования аннотации @Import включают:

1. Прямое заполнение массивом классов
2. Способ с использованием ImportSelector [важно]
3. Способ с использованием ImportBeanDefinitionRegistrar

Первый способ: прямое заполнение массивом классов

Прямое заполнение массивом соответствующих классов, где массив может содержать от OnClickListener 0 до любого количества классов. Синтаксис представлен ниже:```java @Import({ Класс1.class, Класс2.class... }) public class TestDemo { }

Все импортированные бины будут добавлены в контейнер Spring, и их имена будут полными именами классов. Например, `com.yc.Класс`.

### Второй способ: способ с использованием ImportSelector [важно]

Этот способ требует реализации интерфейса ImportSelector. Предположим, что мы хотим использовать этот метод для класса `MyClass`. Анализ представлен ниже:

Создание класса `MyClass` и реализация интерфейса `ImportSelector`

```java
public class MyClass implements ImportSelector {
    // Так как это интерфейс, нам нужно реализовать его метод
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[0];
    }
}

Анализ метода selectImports:

1. Возвращаемое значение: полные имена классов, которые мы хотим импортировать в контейнер [важно]
2. Параметр: AnnotationMetadata представляет все аннотации, примененные к текущему классу с помощью @Import [не важно]

Важно отметить, что метод selectImports может вернуть пустой массив, но не null, иначе произойдет NullPointerException!

После анализа, шаги использования представлены ниже:

Первый шаг: создание класса MyClass и реализация интерфейса ImportSelector, здесь мы добавляем одно полное имя класса в качестве возвращаемого значения для демонстрации

public class MyClass implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.yc.Test.TestDemo3"};
    }
}
```Второй шаг: создание класса TestDemo и использование класса Myclass с аннотацией @Import

```java
@Import({TestDemo2.class, Myclass.class})
public class TestDemo {
    @Bean
    public AccountDao2 accountDao2() {
        return new AccountDao2();
    }
}

Как видно, используется аннотация @Bean, если вы не уверены в её использовании, можно обратиться к простому объяснению Spring @bean аннотации. Третий шаг: Написание тестового класса для печати компонентов контейнера

/**
 * Тестовый класс для печати компонентов контейнера
 */
public class AnnotationTestDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestDemo.class);  // Здесь указывается класс, над которым будут выполняться операции

        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String name : beanDefinitionNames) {
            System.out.println(name);
        }

    }
}

Четвертый шаг: Результат выполнения

Третий способ использования: через интерфейс ImportBeanDefinitionRegistrar

Это также интерфейс, аналогичный второму способу использования ImportSelector, схожесть составляет около 80%, но этот способ более специфичен и связан с регистрацией. Подробнее:

Первый шаг: Создание класса Myclass2 и реализация интерфейса ImportBeanDefinitionRegistrar```java public class Myclass2 implements ImportBeanDefinitionRegistrar { // Реализация метода по умолчанию пустая @Override public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
} }

Анализ параметров:

Первый параметр: `annotationMetadata`, как и в случае с `ImportSelector`, представляет собой все аннотации, примененные к текущему классу с помощью `@Import`.
Второй параметр используется для регистрации определения бина.

Второй шаг: Написание кода для специфической регистрации бина

```java
public class Myclass2 implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        // Указание информации о бине (включая тип бина, область видимости...)
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TestDemo4.class);
        // Регистрация бина с указанием имени бина (id)
        beanDefinitionRegistry.registerBeanDefinition("TestDemo4444", rootBeanDefinition);
    }
}

Третий шаг: Написание класса TestDemo и аннотация его использованием класса Myclass2, реализующего интерфейс ImportBeanDefinitionRegistrar.

Три способа использования аннотации @Import

Первый способ: @Import({Компоненты, которые нужно импортировать})

Контейнер автоматически регистрирует эти компоненты, а id по умолчанию — это полное имя класса.#### Второй способ: ImportSelector Возвращает массив полных имен классов, которые нужно импортировать. Этот метод используется очень часто в Spring Boot.

Третий способ: ImportBeanDefinitionRegistrar

Ручная регистрация bean в контейнере.

Все три способа могут использоваться вместе в одной аннотации @Import. Обратите внимание, что первый и второй способы используют полное имя класса для регистрации, а третий позволяет использовать произвольный способ регистрации.

Аннотация @Import сама по себе используется очень часто в Spring Boot, особенно второй способ с использованием ImportSelector. Это важно знать!

Создание исходного кода Spring Boot вечером действительно занимает много времени. В следующий раз стоит сразу приступить к изучению исходного кода Spring Boot.