Spring源码 @Import和@Configuration注解

怼烎@ 2022-10-05 06:52 173阅读 0赞

接着上回的分析

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70][]

spring会扫描我们的普通类，也就是加了@Component注解的类

下面就会解析加了@Import的类

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
    			Collection<SourceClass> importCandidates, 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 selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
    						ParserStrategyUtils.invokeAwareMethods(
    								selector, this.environment, this.resourceLoader, this.registry);
    						if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
    							this.deferredImportSelectors.add(
    									new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
    						}
    						else {
    							//回调
    							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
    							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
    							//递归，这里第二次调用processImports
    							//如果是一个普通类，会斤else
    							processImports(configClass, currentSourceClass, importSourceClasses, 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 =
    								BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
    						ParserStrategyUtils.invokeAwareMethods(
    								registrar, this.environment, this.resourceLoader, this.registry);
    						//添加到一个list当中和importselector不同
    						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
    					}
    					else {
    						// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
    						// process it as an @Configuration class
    						// 否则，加入到importStack后调用processConfigurationClass 进行处理
    						//processConfigurationClass里面主要就是把类放到configurationClasses
    						//configurationClasses是一个集合，会在后面拿出来解析成bd继而注册
    						//可以看到普通类在扫描出来的时候就被注册了
    						//如果是importSelector，会先放到configurationClasses后面进行出来注册
    						this.importStack.registerImport(
    								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
    						processConfigurationClass(candidate.asConfigClass(configClass));
    					}
    				}
    			}
    			catch (BeanDefinitionStoreException ex) {
    				throw ex;
    			}
    			catch (Throwable ex) {
    				throw new BeanDefinitionStoreException(
    						"Failed to process imports candidates for configuration class [" +
    						configClass.getMetadata().getClassName() + "]", ex);
    			}
    			finally {
    				this.importStack.pop();
    			}
    		}
    	}

我们应该知道，@Import 里面可以写三种不同 importSelect importBeanDefinitionRegistrar

spring就对这三种进行不同的解析我们来按照这个if的分支，一个个去解析

先看 ImportSelector

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 selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
    						ParserStrategyUtils.invokeAwareMethods(
    								selector, this.environment, this.resourceLoader, this.registry);
    						if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
    							this.deferredImportSelectors.add(
    									new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
    						}
    						else {
    							//回调
    							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
    							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
    							//递归，这里第二次调用processImports
    							//如果是一个普通类，会斤else
    							processImports(configClass, currentSourceClass, importSourceClasses, false);
    						}
    					}

我们看这个代码，spring处理这个ImportSelector的时候，不是获取到这个bd的时候，直接注册到register里面，而是放在了一个

private final Map<ConfigurationClass, ConfigurationClass> configurationClasses = new LinkedHashMap<>();

里面，而且放的也很巧妙，为了和@Import\{A.class\}通用，它这边会递归处理，最后一定会走到else分支

else {
    						this.importStack.registerImport(
    								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
    						processConfigurationClass(candidate.asConfigClass(configClass));
    					}

然后放到这个map里面

//把把类放在configurationClasses。后面再创建bd（loadBeanDefinitions（））
    		this.configurationClasses.put(configClass, configClass);

我们看，spring后续是什么时候把这个class转成bd

我们一步步断点走下去，会发现会回到org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader\#loadBeanDefinitions

这个方法里面

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
    		for (ConfigurationClass configClass : configurationModel) {
    			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
    		}
    	}

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;
    		}
    
    		//如果一个类是被import的，会被spring标准
    		//早这里完成注册
    		if (configClass.isImported()) {
    			registerBeanDefinitionForImportedConfigurationClass(configClass);
    		}
    		//@Bean
    		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
    			loadBeanDefinitionsForBeanMethod(beanMethod);
    		}
    
    		 //xml
    		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    
    		//注册Registrar
    		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
    	}

其中 registerBeanDefinitionForImportedConfigurationClass(configClass)

就是处理我们configurationClasses这个map里面的值，在前面已经把这个map的值拿出来了，放在一个Set集合里面

private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
    		AnnotationMetadata metadata = configClass.getMetadata();
    		AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
    
    		ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
    		configBeanDef.setScope(scopeMetadata.getScopeName());
    		String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
    		AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);
    
    		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
    		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    		this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
    		configClass.setBeanName(configBeanName);
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Registered bean definition for imported class '" + configBeanName + "'");
    		}
    	}

这里面我们能看到会把这个bd注册到我们的BeanFactory

我们再分析下 ImportBeanDefinitionRegistrar 这种类型的

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 =
    								BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
    						ParserStrategyUtils.invokeAwareMethods(
    								registrar, this.environment, this.resourceLoader, this.registry);
    						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
    					}
    					else {
    						this.importStack.registerImport(
    								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
    						processConfigurationClass(candidate.asConfigClass(configClass));
    					}

我们可以看到，Registrar这个会放在另外一个map中

private final Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars =
          new LinkedHashMap<>();

然后也会在上面那个代码里面执行

private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
    		registrars.forEach((registrar, metadata) ->
    				registrar.registerBeanDefinitions(metadata, this.registry));
    	}

那我们就明白了，@Import的三种类型，spring是怎样把它弄成bd的

后面我们来看下我们@Configuration这个注解

我们知道，我们的appconfig家里这个注解

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 1][]

我们把这个注解去掉，可以看看效果

发现根本不影响程序运行，结果一逼样

我们可以断点看下，这个appconfig，从bd拿出来，到底是个什么样子

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 2][]

我们把这个注解加上去再看下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 3][]

变成了一个代理类，是不是很奇怪?我们去spring底层去看一看，这个是怎样处理的

我就不一点点去找这个代码了，这个代码就是处理org.springframework.context.annotation.ConfigurationClassPostProcessor\#postProcessBeanFactory

@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    		int factoryId = System.identityHashCode(beanFactory);
    		if (this.factoriesPostProcessed.contains(factoryId)) {
    			throw new IllegalStateException(
    					"postProcessBeanFactory already called on this post-processor against " + beanFactory);
    		}
    		this.factoriesPostProcessed.add(factoryId);
    		if (!this.registriesPostProcessed.contains(factoryId)) {
    			// BeanDefinitionRegistryPostProcessor hook apparently not supported...
    			// Simply call processConfigurationClasses lazily at this point then.
    			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
    		}
    		//给配置类产生cglib代理
    		//为什么需要产生cglib代理？
    		enhanceConfigurationClasses(beanFactory);
    		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
    	}

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
    		Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
    		for (String beanName : beanFactory.getBeanDefinitionNames()) {
    			BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
    			//判断是否是一个全注解类
    			//扫描是全注解类？full和lite的关系
    			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
    				if (!(beanDef instanceof AbstractBeanDefinition)) {
    					throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
    							beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
    				}
    				else if (logger.isWarnEnabled() && beanFactory.containsSingleton(beanName)) {
    					logger.warn("Cannot enhance @Configuration bean definition '" + beanName +
    							"' since its singleton instance has been created too early. The typical cause " +
    							"is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
    							"return type: Consider declaring such methods as 'static'.");
    				}
    				configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
    			}
    		}
    		if (configBeanDefs.isEmpty()) {
    			// nothing to enhance -> return immediately
    			return;
    		}
    
    		ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
    		for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
    			AbstractBeanDefinition beanDef = entry.getValue();
    			// If a @Configuration class gets proxied, always proxy the target class
    			beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
    			try {
    				// Set enhanced subclass of the user-specified bean class
    				Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
    				if (configClass != null) {
    					//完成对全注解类的cglib代理
    					Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
    					if (configClass != enhancedClass) {
    						if (logger.isDebugEnabled()) {
    							logger.debug(String.format("Replacing bean definition '%s' existing class '%s' with " +
    									"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
    						}
    						beanDef.setBeanClass(enhancedClass);
    					}
    				}
    			}
    			catch (Throwable ex) {
    				throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
    			}
    		}
    	}

这个就是我们之前说的，full和lite，spring会给是full的加上cglib的动态代理,详细代码就不进去分析了，也没太大必要，暂时知道就行

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70]: /images/20221005/fe6b815d0e944993902a5ebdce8265dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 1]: /images/20221005/fbf336352a9e45528e999ccaf0de402a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 2]: /images/20221005/6eac2f68fff449d4a9457a0b1588cb87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 3]: /images/20221005/f39bfc9a7581415abfd987410c139569.png