Spring中能否根据Bean实现的接口指定其加载顺序？

Great question! Spring doesn't have a native, out-of-the-box feature to directly order bean instantiation based on the interfaces they implement, but there are a couple of solid workarounds to achieve exactly what you're asking for—prioritizing beans that implement I1 (A, B, D) before those that implement I2 (C, E).

1. 自定义BeanFactoryPostProcessor（最可靠的方式） #

The most straightforward approach is to create a custom BeanFactoryPostProcessor. This component runs before any beans are instantiated, allowing you to reorder the bean definitions based on their implemented interfaces.

Here's a complete example:

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;

@Component
public class InterfaceGroupOrderProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        List<String> i1BeanNames = new ArrayList<>();
        List<String> i2BeanNames = new ArrayList<>();
        List<String> otherBeanNames = new ArrayList<>();

        // 遍历所有Bean定义，按实现的接口分组
        for (String beanName : beanFactory.getBeanDefinitionNames()) {
            BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
            try {
                Class<?> beanClass = Class.forName(beanDef.getBeanClassName());
                if (I1.class.isAssignableFrom(beanClass)) {
                    i1BeanNames.add(beanName);
                } else if (I2.class.isAssignableFrom(beanClass)) {
                    i2BeanNames.add(beanName);
                } else {
                    otherBeanNames.add(beanName);
                }
            } catch (ClassNotFoundException e) {
                // 处理类加载异常（比如动态代理类的情况）
                otherBeanNames.add(beanName);
            }
        }

        // 合并顺序：I1优先，然后I2，最后其他Bean
        List<String> orderedBeanNames = new ArrayList<>();
        orderedBeanNames.addAll(i1BeanNames);
        orderedBeanNames.addAll(i2BeanNames);
        orderedBeanNames.addAll(otherBeanNames);

        // 更新BeanFactory中的Bean定义顺序
        if (beanFactory instanceof DefaultListableBeanFactory) {
            DefaultListableBeanFactory defaultBeanFactory = (DefaultListableBeanFactory) beanFactory;
            defaultBeanFactory.setBeanDefinitionNames(orderedBeanNames.toArray(new String[0]));
        }
    }
}

关键说明： #

• This processor runs early in the Spring lifecycle, so it directly affects the actual instantiation order of beans.
• Beans that implement both I1 and I2 will be grouped with I1 in this example—you can adjust the logic to handle edge cases like this as needed.
• Dynamic proxy beans (e.g., those created for AOP) might throw a ClassNotFoundException when loading the class directly; the example handles this by falling back to the "other" group.

2. 结合@Order注解（适用于集合注入场景） #

If your main goal is to have beans ordered correctly when injected into a collection (e.g., List<I1> or List<I2>), you can use the @Order annotation directly on your bean classes:

@Component
@Order(1) // 较小的数值优先
public class A implements I1 { /* ... */ }

@Component
@Order(2)
public class B implements I1 { /* ... */ }

@Component
@Order(100) // 较大的数值靠后
public class C implements I2 { /* ... */ }

注意： #

• @Order primarily affects the order of beans in injected collections, not necessarily their instantiation order. If you need strict instantiation order (e.g., I1 beans must be fully initialized before I2 beans), the BeanFactoryPostProcessor approach is better.

3. 使用@DependsOn（针对依赖关系明确的场景） #

If individual I2 beans have a direct dependency on I1 beans, you can use @DependsOn to enforce instantiation order:

@Component
@DependsOn({"a", "b", "d"})
public class C implements I2 { /* ... */ }

局限性： #

• This requires explicitly listing all I1 bean names, which becomes cumbersome if you have many I1 or I2 beans. It's not ideal for grouping-based ordering.

内容的提问来源于stack exchange，提问作者Khaled Ben Ahmed