如何在Spring Boot启动时校验单例Bean是否直接注入自定义作用域Bean并抛出异常

这个需求我之前在项目里也碰到过，Spring的扩展机制完全能帮我们实现启动时的校验，避免单例Bean直接依赖自定义作用域的Bean，下面给你一个具体的实现方案：

核心思路 #

我们可以借助Spring的BeanFactoryPostProcessor扩展点，在BeanFactory初始化完成后、所有Bean实例化之前，遍历所有单例Bean的定义，通过反射检查它们的字段和构造方法参数，判断是否存在直接注入自定义作用域Bean的情况——如果有，就直接抛出异常终止启动。

具体代码实现 #

假设你的自定义作用域名称是myCustomScope，先写一个校验处理器：

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.stereotype.Component;
import org.springframework.util.ClassUtils;
import javax.inject.Provider;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;
import java.util.Arrays;

@Component
public class CustomScopeDependencyValidator implements BeanFactoryPostProcessor {

    // 替换成你实际的自定义作用域名
    private static final String CUSTOM_SCOPE_NAME = "myCustomScope";

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 遍历容器中所有Bean的名称
        String[] allBeanNames = beanFactory.getBeanDefinitionNames();
        for (String beanName : allBeanNames) {
            BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
            // 只针对单例Bean进行校验
            if (BeanDefinition.SCOPE_SINGLETON.equals(beanDef.getScope())) {
                Class<?> beanClass;
                try {
                    // 加载当前Bean的Class对象
                    beanClass = ClassUtils.forName(beanDef.getBeanClassName(), beanFactory.getBeanClassLoader());
                } catch (ClassNotFoundException e) {
                    throw new RuntimeException("无法加载Bean对应的Class: " + beanName, e);
                }
                // 检查字段注入的依赖
                validateFieldDependencies(beanClass, beanFactory);
                // 检查构造方法注入的依赖
                validateConstructorDependencies(beanClass, beanFactory);
            }
        }
    }

    private void validateFieldDependencies(Class<?> beanClass, ConfigurableListableBeanFactory beanFactory) {
        // 遍历当前Bean的所有字段
        Field[] fields = beanClass.getDeclaredFields();
        for (Field field : fields) {
            Class<?> fieldType = field.getType();
            // 排除Provider类型的注入（如果用的是Spring的ObjectFactory，这里也要加上判断）
            if (!Provider.class.isAssignableFrom(fieldType)) {
                // 获取该字段类型对应的所有Bean名称
                String[] dependentBeanNames = beanFactory.getBeanNamesForType(fieldType);
                for (String depBeanName : dependentBeanNames) {
                    BeanDefinition depBeanDef = beanFactory.getBeanDefinition(depBeanName);
                    // 检查依赖Bean是否是自定义作用域
                    if (CUSTOM_SCOPE_NAME.equals(depBeanDef.getScope())) {
                        throw new IllegalStateException(String.format(
                                "单例Bean [%s] 直接注入了自定义作用域Bean [%s]，请改用Provider<%s>注入",
                                beanClass.getSimpleName(), depBeanName, fieldType.getSimpleName()
                        ));
                    }
                }
            }
        }
    }

    private void validateConstructorDependencies(Class<?> beanClass, ConfigurableListableBeanFactory beanFactory) {
        // 遍历当前Bean的所有构造方法
        Constructor<?>[] constructors = beanClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            Class<?>[] paramTypes = constructor.getParameterTypes();
            for (Class<?> paramType : paramTypes) {
                // 排除Provider类型的参数
                if (!Provider.class.isAssignableFrom(paramType)) {
                    String[] dependentBeanNames = beanFactory.getBeanNamesForType(paramType);
                    for (String depBeanName : dependentBeanNames) {
                        BeanDefinition depBeanDef = beanFactory.getBeanDefinition(depBeanName);
                        if (CUSTOM_SCOPE_NAME.equals(depBeanDef.getScope())) {
                            throw new IllegalStateException(String.format(
                                    "单例Bean [%s] 的构造方法直接注入了自定义作用域Bean [%s]，请改用Provider<%s>注入",
                                    beanClass.getSimpleName(), depBeanName, paramType.getSimpleName()
                            ));
                        }
                    }
                }
            }
        }
    }
}

关键说明 #

• 这个处理器会被Spring自动扫描并执行（因为加了@Component注解），在应用启动阶段完成所有校验。
• 如果你用的是Spring自带的ObjectFactory而不是JSR-330的Provider，记得在判断时加上ObjectFactory.class.isAssignableFrom(fieldType)。
• 校验会覆盖字段注入和构造方法注入两种场景，确保没有遗漏。
• 一旦发现违规的依赖，会直接抛出IllegalStateException，终止应用启动，及时发现问题。

备注：内容来源于stack exchange，提问作者Cilenco