如何用ArchUnit验证Spring组件类的字段仅为Spring Bean？

一、ArchUnit实现规则 #

ArchUnit可以通过自定义规则实现该验证，核心思路是：先收集所有Spring管理的Bean类型，再检查目标组件类的实例变量是否属于Bean类型或被注入注解标记。

具体测试代码 #

import com.tngtech.archunit.core.domain.JavaClass;
import com.tngtech.archunit.core.domain.JavaField;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.lang.ArchRule;
import com.tngtech.archunit.lang.ConditionEvents;
import com.tngtech.archunit.lang.SimpleConditionEvent;
import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RestController;

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class SpringComponentFieldValidationTest {

    // 收集项目中所有Spring Bean的类型（包括@Component/@Service/@RestController类，以及@Bean方法返回类型）
    private final Set<JavaClass> allSpringBeanTypes = new ClassFileImporter()
            .importPackages("com.yourproject.base") // 替换为你的项目基础包路径
            .stream()
            .flatMap(this::extractBeanTypes)
            .collect(Collectors.toSet());

    private Stream<JavaClass> extractBeanTypes(JavaClass clazz) {
        // 处理@Configuration类中的@Bean方法返回类型
        if (clazz.isAnnotatedWith(Configuration.class)) {
            return clazz.getMethods().stream()
                    .filter(method -> method.isAnnotatedWith(Bean.class))
                    .map(method -> method.getRawReturnType());
        }
        // 处理直接标注Spring组件注解的类
        else if (clazz.isAnnotatedWith(Component.class)
                || clazz.isAnnotatedWith(Service.class)
                || clazz.isAnnotatedWith(RestController.class)) {
            return Stream.of(clazz);
        }
        return Stream.empty();
    }

    @Test
    void allInstanceFieldsInSpringComponentsMustBeSpringBeans() {
        ArchRule rule = ArchRuleDefinition.classes()
                .that().areAnnotatedWith(Component.class)
                .or().areAnnotatedWith(Service.class)
                .or().areAnnotatedWith(RestController.class)
                .should((clazz, events) -> {
                    // 遍历所有非静态实例变量
                    clazz.getFields().stream()
                            .filter(field -> !field.isStatic())
                            .forEach(field -> validateField(field, clazz, events));
                });

        rule.check(new ClassFileImporter().importPackages("com.yourproject.base"));
    }

    private void validateField(JavaField field, JavaClass clazz, ConditionEvents events) {
        // 检查变量是否被注入注解标记
        boolean isInjected = field.isAnnotatedWith(Autowired.class)
                || field.isAnnotatedWith(javax.inject.Inject.class)
                || field.isAnnotatedWith(javax.annotation.Resource.class);

        // 检查变量类型是否属于Spring Bean类型（支持父类/接口匹配）
        boolean isBeanType = allSpringBeanTypes.stream()
                .anyMatch(beanType -> beanType.isAssignableFrom(field.getType())
                        || field.getType().isAssignableFrom(beanType));

        if (!isInjected && !isBeanType) {
            events.add(SimpleConditionEvent.violated(field,
                    String.format("字段[%s]在类[%s]中既不是Spring Bean，也没有被注入注解标记",
                            field.getName(), clazz.getFullName())));
        }
    }
}

代码说明 #

1. 收集Bean类型：通过ClassFileImporter扫描项目包，收集两类Bean类型：
   • 直接被@Component/@Service/@RestController标记的类；
   • @Configuration类中@Bean方法返回的类型。
2. 规则验证逻辑：
   • 筛选出目标组件类；
   • 遍历每个类的非静态实例变量，检查两个条件：要么被@Autowired等注入注解标记，要么类型属于已收集的Bean类型（支持父类/接口匹配，适配多态场景）；
   • 不满足条件的变量会触发违规事件，导致测试失败。

二、编译时验证的可行性 #

严格意义上的编译时验证可以实现，但存在明显局限性：

• 需要自定义Java注解处理器（Annotation Processor），在编译阶段扫描类文件进行检查；
• 无法完全覆盖所有场景：比如跨模块的@Bean声明、动态生成的Bean（如FactoryBean），编译阶段无法获取完整的Bean上下文；
• 实现复杂度高，需要处理编译时类依赖、未编译类等问题。

因此，更实用的选择是用ArchUnit在单元测试阶段做验证：既能覆盖绝大多数业务场景，又能集成到CI/CD流程中，在代码提交时自动拦截不符合规则的代码，实现成本远低于编译时处理器。

三、扩展说明 #

• 如果项目使用构造函数注入（无@Autowired注解），可以扩展规则：检查类的构造函数参数是否均为Bean类型，且实例变量通过构造函数初始化；
• 对于原生类型（如String、int）或通用集合类（如Map），只有当它们被显式声明为@Bean时，才会被判定为合法，完全符合你的需求。

内容的提问来源于stack exchange，提问作者Arun