Что выполнится первым: XML конфигурация, Java конфигурация или @Configuration

Порядок выполнения конфигураций в Spring (XML vs Java vs @Configuration)

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

Общий принцип

Конфигурации загружаются в порядке, в котором они указаны в коде инициализации ApplicationContext. Нет встроенного приоритета XML vs Java конфигурации — всё зависит от явного порядка.

// Пример 1: XML загружается первым
ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "spring-config.xml",  // 1. XML загружается первой
    "spring-java-config"  // 2. Java конфигурация загружается второй
);

// Пример 2: Java конфигурация первой
ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "spring-java-config",  // 1. Java конфигурация первой
    "spring-config.xml"    // 2. XML загружается второй
);

XML конфигурация (Spring 1.0+)

XML конфигурация — самый старый способ конфигурирования Spring:

<!-- applicationContext.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- Определение бина -->
    <bean id="userService" class="com.example.UserService">
        <constructor-arg ref="userRepository"/>
    </bean>
    
    <bean id="userRepository" class="com.example.UserRepository"/>
</beans>

Загрузка XML конфигурации:

ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "applicationContext.xml"
);
UserService userService = ctx.getBean(UserService.class);

Java конфигурация (@Configuration)

Java конфигурация была введена в Spring 3.0 и стала стандартом начиная с Spring Boot:

@Configuration
public class AppConfig {
    
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
    
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
}

Загрузка Java конфигурации:

ApplicationContext ctx = new AnnotationConfigApplicationContext(
    AppConfig.class
);
UserService userService = ctx.getBean(UserService.class);

Порядок выполнения: детальный анализ

Случай 1: Только XML конфигурация

ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "applicationContext.xml"
);

// Порядок выполнения:
// 1. Парсинг XML файла
// 2. Регистрация bean определений
// 3. Инстанцирование бинов
// 4. Вызов post-processers
// 5. Готовность контекста

Случай 2: Только Java конфигурация

ApplicationContext ctx = new AnnotationConfigApplicationContext(
    AppConfig.class
);

// Порядок выполнения:
// 1. Сканирование аннотаций @Configuration
// 2. Поиск методов @Bean
// 3. Регистрация bean определений
// 4. Инстанцирование бинов
// 5. Вызов post-processers
// 6. Готовность контекста

Случай 3: XML + Java конфигурация (важно!)

// Вариант 1: XML первой
ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "applicationContext.xml"  // 1. XML загружается и обрабатывается
);

// Если в XML указано:
// <import resource="classpath:app-config.xml"/>
// или загрузить AppConfig.class через XML:

<!-- applicationContext.xml -->
<beans xmlns="...">
    <!-- XML бины загружаются первыми -->
    <bean id="xmlBean" class="com.example.XmlBean"/>
    
    <!-- Затем загружается Java конфигурация -->
    <bean class="com.example.AppConfig"/>
</beans>

// Вариант 2: Java конфигурация импортирует XML
@Configuration
public class AppConfig {
    @ImportResource("classpath:applicationContext.xml")
    public class NestedConfig {
        // Сначала загружается AppConfig
        // Затем загружается XML из applicationContext.xml
    }
}

ApplicationContext ctx = new AnnotationConfigApplicationContext(
    AppConfig.class
);

Spring Boot и порядок загрузки

В Spring Boot порядок загрузки более предсказуем:

// Spring Boot: application.yml или application.properties
spring:
  config:
    import: classpath:additional-config.yml

Порядок загрузки в Spring Boot:

1. application.properties / application.yml загружаются
2. Сканирование @ComponentScan находит @Configuration классы
3. @Configuration классы обрабатываются
4. @ImportResource загружает XML файлы
5. @Import загружает другие конфигурационные классы
6. BeanFactoryPostProcessors выполняются

Практический пример: конфликты между конфигурациями

Проблема: переопределение одного и того же bean-а

<!-- applicationContext.xml -->
<beans>
    <bean id="userService" class="com.example.UserServiceImpl">
        <constructor-arg ref="userRepository"/>
    </bean>
</beans>

@Configuration
public class AppConfig {
    @Bean(name = "userService")
    public UserService userService() {
        // Этот bean переопределяет XML bean с тем же именем!
        return new UserService(userRepository());
    }
}

// Результат: какой userService получим?
ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "applicationContext.xml"
);

// Если приложение было инициализировано так:
// 1. XML обработана первой
// 2. Java конфигурация обработана второй
// 3. Java конфигурация переопределит XML bean!

UserService service = ctx.getBean(UserService.class);
// Получим bean из Java конфигурации (последнюю загруженную)

Правильный способ смешивания конфигураций

Способ 1: XML импортирует Java конфигурацию

<!-- applicationContext.xml -->
<beans xmlns="...">
    <!-- Java конфигурация -->
    <bean class="com.example.AppConfig"/>
    
    <!-- Или другие XML бины -->
    <bean id="xmlSpecificBean" class="com.example.XmlSpecificBean"/>
</beans>

Порядок: XML обработана → Java конфигурация обработана → готовность контекста

Способ 2: Java конфигурация импортирует XML

@Configuration
@ImportResource("classpath:applicationContext.xml")
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

Порядок: Java конфигурация обработана → XML обработана → готовность контекста

Способ 3: Spring Boot (рекомендуется)

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Все конфигурации обрабатываются автоматически в правильном порядке.

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

Это влияет на финальный порядок инициализации бинов:

@Configuration
public class AppConfig {
    
    @Bean
    public static BeanFactoryPostProcessor beanFactoryPostProcessor() {
        return bfpp -> {
            // Выполнится ПЕРЕД инстанцированием всех бинов
            System.out.println("1. BeanFactoryPostProcessor");
        };
    }
    
    @Bean
    public UserRepository userRepository() {
        System.out.println("2. UserRepository инстанцирована");
        return new UserRepository();
    }
    
    @Bean
    public BeanPostProcessor beanPostProcessor() {
        return new BeanPostProcessor() {
            @Override
            public Object postProcessBeforeInitialization(Object bean, String name) {
                System.out.println("3. Перед инициализацией: " + name);
                return bean;
            }
            
            @Override
            public Object postProcessAfterInitialization(Object bean, String name) {
                System.out.println("4. После инициализации: " + name);
                return bean;
            }
        };
    }
    
    @Bean
    public UserService userService(UserRepository userRepository) {
        System.out.println("5. UserService инстанцирована");
        return new UserService(userRepository);
    }
}

Вывод:

1. BeanFactoryPostProcessor
3. Перед инициализацией: userRepository
2. UserRepository инстанцирована
4. После инициализации: userRepository
3. Перед инициализацией: userService
5. UserService инстанцирована
4. После инициализацией: userService

Как избежать конфликтов

Правило 1: используй только один способ конфигурации

// ХОРОШО: только Java конфигурация (современный подход)
@Configuration
public class AppConfig {
    @Bean
    public UserService userService() { }
    
    @Bean
    public UserRepository userRepository() { }
}

// ПЛОХО: смешивание XML и Java (может привести к ошибкам)

Правило 2: если нужно смешивать, используй @ImportResource явно

@Configuration
@ImportResource("classpath:legacy-config.xml")
public class ModernConfig {
    // Явно указываем зависимость от XML
    @Bean
    public NewService newService() { }
}

Правило 3: используй conditional beans чтобы избежать конфликтов

@Configuration
public class AppConfig {
    
    @Bean
    @ConditionalOnMissingBean
    public UserService userService() {
        // Инстанцируется только если нет другого UserService bean-a
        return new UserService();
    }
}

Итоговый чеклист

✓ Порядок загрузки зависит от явного порядка инициализации ✓ XML не имеет встроенного приоритета перед Java конфигурацией ✓ Java конфигурация (@Configuration) — современный стандарт ✓ Spring Boot управляет порядком конфигурации автоматически ✓ BeanFactoryPostProcessor выполняется ДО инстанцирования бинов ✓ BeanPostProcessor выполняется ДО и ПОСЛЕ инициализации бинов ✓ Избегай смешивания XML и Java конфигурации без необходимости ✓ Используй @ConditionalOnMissingBean чтобы избежать конфликтов

Основной вывод: Порядок выполнения конфигураций НЕ фиксирован. Всегда проверяй логи инициализации, если результат не совпадает с ожиданиями.