@Import、ImportSelector、ImportBeanDefinitionRegistrar的使用与源码分析

亦凉 2022-11-05 11:47 140阅读 0赞

@Import是一个注解，专门用来导入实现了ImportSelector和ImportBeanDefinitionRegistrar接口的类，当然也可以用来导入普通的Bean。

# ImportSelector、ImportBeanDefinitionRegistrar的使用 #

## ImportSelector的使用 ##

package com.morris.spring.entity;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ImportSelector;
    import org.springframework.core.type.AnnotationMetadata;
    
    import java.util.Map;
    
    public class GdImportSelect implements ImportSelector { 
    	/** * * importingClassMetadata为导入GdImportSelect的类上面的注解信息，这里是com.morris.spring.config.ImportConfig * @param importingClassMetadata * @return * @see com.morris.spring.config.ImportConfig */
    	@Override
    	public String[] selectImports(AnnotationMetadata importingClassMetadata) { 
    		
    		Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(ComponentScan.class.getName());
    		Object basePackages = annotationAttributes.get("basePackages");
    		if(basePackages instanceof String[]) { 
    			String[] bps = (String[]) basePackages;
    			Arrays.stream(bps).forEach(System.out::println);
    		}
    		return new String[]{ Gd.class.getName()};
    	}
    }

返回的字符串需要为类的全限定名。

package com.morris.spring.config;
    
    import com.morris.spring.entity.GdImportSelect;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Import;
    import org.springframework.stereotype.Component;
    
    @Component
    @ComponentScan("com.xxx")
    @Import(GdImportSelect.class)
     // 导入
    public class ImportConfig { 
    }

## ImportBeanDefinitionRegistrar的使用 ##

package com.morris.spring.entity;
    
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.BeanNameGenerator;
    import org.springframework.beans.factory.support.GenericBeanDefinition;
    import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
    import org.springframework.core.type.AnnotationMetadata;
    
    public class ImportBeanDefinitionRegistrarDemo implements ImportBeanDefinitionRegistrar { 
    
    	/** * * @param importingClassMetadata 为导入本类上面的注解信息，这里是com.morris.spring.config.ImportConfig * @param registry 可以向容器中注入BeanDefinition * @param importBeanNameGenerator 可以为导入的Bean生成beanName */
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) { 
    
    		GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
    		genericBeanDefinition.setBeanClass(Hn.class);
    
    		String beanName = importBeanNameGenerator.generateBeanName(genericBeanDefinition, registry);
    		registry.registerBeanDefinition(beanName, genericBeanDefinition);
    	}
    }

使用方式与ImportSelect一样，需要使用@Import注解要导入。

# 源码分析 #

带着下面两个问题进行分析：

*  ImportSelector和ImportBeanDefinitionRegistrar都是通过@Import注解导入，那么@Import注解所在的类是何时被扫描的？
 *  ImportSelector和ImportBeanDefinitionRegistrar接口的方法是何时被调用的？

## @Import的扫描 ##

首先会从容器中取出所有被@Import注解修饰的BeanDefinition：

org.springframework.context.annotation.ConfigurationClassPostProcessor\#processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { 
    	List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    	String[] candidateNames = registry.getBeanDefinitionNames();
    
    	// 先收集有@Configuration、@Component、@ComponentScan、@Import、@ImportResource、@Bean的BD
    	for (String beanName : candidateNames) { 
    		BeanDefinition beanDef = registry.getBeanDefinition(beanName);
    		if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) { 
    			if (logger.isDebugEnabled()) { 
    				logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
    			}
    		}
    		else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) { 
    			// 进来需要@Component、@ComponentScan、@Import、@ImportResource、@Bean
    			configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
    		}
    	}
    ... ...

然后遍历所有被@Import注解修饰的BeanDefinition，挨个处理：

org.springframework.context.annotation.ConfigurationClassParser\#processImports

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
    		Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
    		boolean checkForCircularImports) { 
    
    	if (importCandidates.isEmpty()) { 
    		return;
    	}
    
    	if (checkForCircularImports && isChainedImportOnStack(configClass)) { 
    		this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
    	}
    	else { 
    		this.importStack.push(configClass);
    		try { 
    			for (SourceClass candidate : importCandidates) { 
    				if (candidate.isAssignable(ImportSelector.class)) { 
    					// Candidate class is an ImportSelector -> delegate to it to determine imports
    					Class<?> candidateClass = candidate.loadClass(); // 加载ImportSelector
    					ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
    							this.environment, this.resourceLoader, this.registry); // 反射实例化ImportSelector
    					Predicate<String> selectorFilter = selector.getExclusionFilter();
    					if (selectorFilter != null) { 
    						exclusionFilter = exclusionFilter.or(selectorFilter);
    					}
    					if (selector instanceof DeferredImportSelector) { 
    						this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
    					}
    					else { 
    						// 调用selectImports方法
    						String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
    						Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
    						// 又递归，实际上会进入下面的else
    						processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
    					}
    				}
    				else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { 
    					// Candidate class is an ImportBeanDefinitionRegistrar ->
    					// delegate to it to register additional bean definitions
    					Class<?> candidateClass = candidate.loadClass();
    					ImportBeanDefinitionRegistrar registrar =
    							ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
    									this.environment, this.resourceLoader, this.registry);
    					configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
    				}
    				else { 
    					// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
    					// process it as an @Configuration class
    					// 通过ImportSelector导入的类会从这里加入到importStack
    					this.importStack.registerImport(
    							currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
    					processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
    				}
    			}
    		}
    		catch (BeanDefinitionStoreException ex) { 
    			throw ex;
    		}
    		catch (Throwable ex) { 
    			throw new BeanDefinitionStoreException(
    					"Failed to process import candidates for configuration class [" +
    					configClass.getMetadata().getClassName() + "]", ex);
    		}
    		finally { 
    			this.importStack.pop();
    		}
    	}
    }

从上面的源码可以看出：

1.  ImportSelector会被直接反射实例化，然后调用selectImports()方法，将返回值放入到importStack中，注意ImportSelector本身没有被Spring容器所管理。
2.  ImportBeanDefinitionRegistrar也会被直接反射实例化，然后加入到ConfigClass.importBeanDefinitionRegistrars属性中，ImportBeanDefinitionRegistrar.registerBeanDefinitions()此时并没有被调用。

## ImportBeanDefinitionRegistrar.registerBeanDefinitions()方法的调用 ##

org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader\#loadBeanDefinitionsForConfigurationClass

private void loadBeanDefinitionsForConfigurationClass(
    		ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) { 
    
    	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;
    	}
    
    	if (configClass.isImported()) { 
    		registerBeanDefinitionForImportedConfigurationClass(configClass);
    	}
    	for (BeanMethod beanMethod : configClass.getBeanMethods()) { 
    		loadBeanDefinitionsForBeanMethod(beanMethod);
    	}
    
    	loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    	// ImportBeanDefinitionRegistrar.registerBeanDefinitions的调用
    	loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
    }
    
    private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) { 
    	// 调用ImportBeanDefinitionRegistrar.registerBeanDefinitions()
    	registrars.forEach((registrar, metadata) ->
    			registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
    }