import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Import({ImportTestBean.class})
@Configuration
public class ImportTest {

}



public class ImportTestBean {

}


启动类：
    @SpringBootApplication
public class MainClient {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(MainClient.class, args);
        System.out.println(Arrays.toString(applicationContext.getBeanNamesForType(ImportTestBean.class)));
        System.out.println(Arrays.toString(applicationContext.getBeanNamesForType(ImportTest.class)));
    }

}

@Configuration
public class ImportTest implements ApplicationRunner {

    @Autowired
    ApplicationContext applicationContext;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println(Arrays.toString(applicationContext.getBeanNamesForType(ImportTestBean.class)));
        System.out.println(Arrays.toString(applicationContext.getBeanNamesForType(ImportTest.class)));
        System.out.println(Arrays.toString(applicationContext.getBeanNamesForType(ImportTest.ImportTestInner.class)));
    }

    @Import({ImportTestBean.class})
    class ImportTestInner{

    }
    
}

/**
 * 处理配置类中的成员类（内部类），递归解析符合条件的内部类配置
 * 
 * @param configClass 当前正在处理的配置类
 * @param sourceClass 配置类的源类表示（用于获取成员类）
 * @param filter 类名过滤器，用于排除不需要处理的类
 * @throws IOException 如果读取类信息时发生I/O错误
 */
private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,
        Predicate<String> filter) throws IOException {

    // 获取当前配置类的所有成员类（内部类）
    Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
    
    // 如果存在成员类则进行处理
    if (!memberClasses.isEmpty()) {
        // 候选配置类列表，用于存储符合条件的成员类
        List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
        
        // 遍历所有成员类，筛选出需要处理的候选类
        for (SourceClass memberClass : memberClasses) {
           // 只要存在@Component、@ComponentScan、@Import、@ImportResource四个中的一个，就是lite配置类
            if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
                    !memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
                candidates.add(memberClass);
            }
        }
        
        // 对候选类进行排序（根据@Order注解或Ordered接口）
        OrderComparator.sort(candidates);
        
        // 处理每个候选成员类
        for (SourceClass candidate : candidates) {
            // 检查是否存在循环导入
            if (this.importStack.contains(configClass)) {
                // 如果检测到循环依赖，报告错误
                this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
            }
            else {
                // 将当前配置类压入导入栈（用于循环依赖检测）
                this.importStack.push(configClass);
                try {
                    // 递归处理成员类（将其转换为配置类并处理）
                    processConfigurationClass(candidate.asConfigClass(configClass), filter);
                }
                finally {
                    // 处理完成后从导入栈弹出当前配置类
                    this.importStack.pop();
                }
            }
        }
    }
}

ConfigurationClassUtils##
	static {
		candidateIndicators.add(Component.class.getName());
		candidateIndicators.add(ComponentScan.class.getName());
		candidateIndicators.add(Import.class.getName());
		candidateIndicators.add(ImportResource.class.getName());
	}

public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
    // Do not consider an interface or an annotation...
    if (metadata.isInterface()) {
       return false;
    }

    // Any of the typical annotations found?
    for (String indicator : candidateIndicators) {
       if (metadata.isAnnotated(indicator)) {
          return true;
       }
    }

    // Finally, let's look for @Bean methods...
    return hasBeanMethods(metadata);
}

ConfigurationClassPostProcessor#
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    //...
    this.reader.loadBeanDefinitions(configClasses);
    //...
}


ConfigurationClassBeanDefinitionReader#
/**
 * 为配置类加载相关的Bean定义
 * 
 * @param configClass 要处理的配置类
 * @param trackedConditionEvaluator 条件评估器，用于检查是否应该跳过该配置类
 */
private void loadBeanDefinitionsForConfigurationClass(
        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    // 1. 检查是否应该跳过该配置类（根据@Conditional等条件注解）
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        String beanName = configClass.getBeanName();
        
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }
        
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return; // 跳过后续处理
    }

    // 2. 前面说了导入的**关键点**，那几个注解 ，所以不只是@import 会走这里  
    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }

    // 3. 处理配置类中所有@Bean方法
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }

    // 4. 处理通过@ImportResource导入的XML配置资源
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

    // 5. 处理通过ImportBeanDefinitionRegistrar注册的Bean定义
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

ConfigurationClassParser#	
protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {	
          //...
// Process any @ComponentScan annotations
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
        //...
    }