Spring IOC容器源碼解析之擴展原理
知識點：spring源碼解析之擴展原理BeanFactoryPostProcessor和BeanDefinitionPostProcessor和ApplicationListenerjava
1、Spring 是如何發佈事件？ApplicationListener
一、 本身寫一個NiuhApplicationListener 實現 ApplicationListener，而且把該組件加到容器中
@Configuration
@ComponentScan("com.niuh")
public class MainConfig {
}
@Component
public class NiuhApplicationListener implements ApplicationListener {
// 接收到消息，回調該方法
@Override
public void onApplicationEvent(ApplicationEvent applicationEvent) {
System.out.println("NiuhApplicationListener 接收到一個事件：" + applicationEvent);
}
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
// 手動發佈一個事件
context.publishEvent(new ApplicationEvent("我手動發佈了一個事件") {
@Override
public Object getSource() {
return super.getSource();
}
});
// 容器關閉也發佈事件
context.close();
}
複製代碼
測試結果：spring
NiuhApplicationListener 接收到一個事件：org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@7bfcd12c: startup date [Fri Jul 05 12:58:12 CST 2019]; root of context hierarchy]
NiuhApplicationListener 接收到一個事件：com.niuh.SpringTest$1[source=我手動發佈了一個事件]
NiuhApplicationListener 接收到一個事件：org.springframework.context.event.ContextClosedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@7bfcd12c: startup date [Fri Jul 05 12:58:12 CST 2019]; root of context hierarchy]
複製代碼
源碼解析：bash
i1>org.springframework.context.support.AbstractApplicationContext#refresh
i2 >org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster （初始化事件多播器）
i3 >org.springframework.context.support.AbstractApplicationContext#registerListeners （把事件監聽器註冊到多播器）
複製代碼
- i2 ：初始化事件多播器 源碼解析
/**
* Initialize the ApplicationEventMulticaster.
* Uses SimpleApplicationEventMulticaster if none defined in the context.
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判斷IOC容器中包含applicationEventMulticaster事件多播器的Bean的name
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 建立一個applicationEventMulticaster 的bean放在IOC容器中，bean的name爲applicationEventMulticaster
this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isDebugEnabled()) {
logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
// 容器中不包含一個beanName 爲applicationEventMulticaster的多播器組件
else {
// 建立一個 SimpleApplicationEventMulticaster 多播器
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 註冊到容器中
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
"': using default [" + this.applicationEventMulticaster + "]");
}
}
}
複製代碼
- i3： 把容器中的監聽器註冊到多播器上去 源碼解析
/**
* Add beans that implement ApplicationListener as listeners.
* Doesn't affect other listeners, which can be added without being beans. */ protected void registerListeners() { // Register statically specified listeners first. // 去容器中把applicationListener撈取出來註冊到多播器上去 （系統的） for (ApplicationListener<?> listener : getApplicationListeners()) { getApplicationEventMulticaster().addApplicationListener(listener); } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let post-processors apply to them! // 咱們本身實現了ApplicationListener的組件 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false); for (String listenerBeanName : listenerBeanNames) { getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } // Publish early application events now that we finally have a multicaster... // 在這裏以前，咱們早期想發佈的事件因爲沒有多播器沒有發佈，在這裏咱們總算有了本身的多播器，能夠在這裏發佈早期堆積的事件了 Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents; this.earlyApplicationEvents = null; if (earlyEventsToProcess != null) { for (ApplicationEvent earlyEvent : earlyEventsToProcess) { getApplicationEventMulticaster().multicastEvent(earlyEvent); } } } -------------------------------如何發佈事件的-------------------------------- public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) { ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event)); // 獲取到全部的監聽器 for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) { // 看spring容器中是否支持線程池，異步發送事件 Executor executor = getTaskExecutor(); if (executor != null) { executor.execute(() -> invokeListener(listener, event)); } else { // 同步發送事件 invokeListener(listener, event); } } } private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) { try { // 調用對於listener的onApplicationEvent事件 listener.onApplicationEvent(event); } catch (ClassCastException ex) { String msg = ex.getMessage(); if (msg == null || matchesClassCastMessage(msg, event.getClass())) { // Possibly a lambda-defined listener which we could not resolve the generic event type for // -> let's suppress the exception and just log a debug message.
Log logger = LogFactory.getLog(getClass());
if (logger.isDebugEnabled()) {
logger.debug("Non-matching event type for listener: " + listener, ex);
}
}
else {
throw ex;
}
}
}
複製代碼
2、BeanDefinitionRegistryPostProcessor 的處理源碼流程
執行時機：全部的bean定義信息將要被加載到容器中，Bean實例尚未被初始化。app
@Component
public class NiuhBeanDefinationRegisterPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
System.out.println("NiuhBeanDefinationRegisterPostProcessor的postProcessBeanDefinitionRegistry方法");
System.out.println("bean定義的數量：" + beanDefinitionRegistry.getBeanDefinitionCount());
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(NiuhLog.class);
beanDefinitionRegistry.registerBeanDefinition("niuhLog",rootBeanDefinition);
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
System.out.println("NiuhBeanDefinationRegisterPostProcessor的postProcessBeanFactory方法");
System.out.println(configurableListableBeanFactory.getBeanDefinitionCount());
}
}
複製代碼
3、BeanFactoryPostProcessor 處理流程
執行時間：全部的Bean定義信息已經加載到容器中，可是Bean實例尚未被初始化。異步
@Component
public class NiuhBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("IOC容器調用了NiuhBeanFactoryPostProcessor的postProcessBeanFactory方法");
for(String name:beanFactory.getBeanDefinitionNames()) {
if("niuhLog".equals(name)) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(name);
beanDefinition.setLazyInit(true);
}
}
}
}
複製代碼
調用鏈：ide
i1:org.springframework.context.support.AbstractApplicationContext#refresh
>i2:org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors
>i3:org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
>i4:org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
>i5:org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions
>i6:org.springframework.context.annotation.ConfigurationClassParser#parse
>i7:org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
>i8:org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass
複製代碼
- i3標記處源碼解析 org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
// 判斷IOC容器是否是BeanDefinitionRegistry
if (beanFactory instanceof BeanDefinitionRegistry) {
// 把IOC容器強制轉爲BeanDefinitionRegistry類型的
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 建立一個普通的PostProcessors的list組件
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 建立一個BeanDefinitionRegistryPostProcessor類型的list
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 處理容器硬編碼（new 出來的）帶入的beanFactoryProcessor
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
//判斷是否是BeanDefinitionRegistryPostProcessor
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
//調用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry
registryProcessor.postProcessBeanDefinitionRegistry(registry);
//加入到list集合中ConfigurationClassPostProcessor
registryProcessors.add(registryProcessor);
}
else {//判斷不是BeanDefinitionRegistryPostProcessor
//加入到集合中
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
//建立一個當前註冊的RegistryProcessors的集合
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 第一步:去容器中查詢是否有BeanDefinitionRegistryPostProcessor類型的
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//判斷是否是實現了PriorityOrdered接口的
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//添加到currentRegistryProcessors的集合中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//添加到processedBeans的集合中
processedBeans.add(ppName);
}
}
//進行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//調用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 第二步:去容器中查詢是否有BeanDefinitionRegistryPostProcessor類型的
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//排除被處理過的，而且實現了Ordered接口的
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//加到以處理的list中
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//調用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
//調用普通的BeanDefinitionRegistryPostProcessors沒用實現 PriorithOrdered和Ordered接口
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
//調用上訴實現了也實現了BeanFactoryPostProcessors的接口
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
//去IOC 容器中獲取BeanFactoryPostProcessor 類型的
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
//分離實現了PriorityOrdered接口的 Ordered 接口的 普通的
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 調用 PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
//調用 Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
//調用普通的
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
複製代碼
- i5標記處源碼解析，org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
//沒有解析以前，系統候選的bean定義配置(有本身的 有系統自帶的)
String[] candidateNames = registry.getBeanDefinitionNames();
//循環Bean定義的名稱 找出本身的傳入的主配置類的bean定義信息 configCandidates
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//檢查該bean定義對象是否是用來描述配置類
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
//檢查配置類排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// Detect any custom bean name generation strategy supplied through the enclosing application context
// bean的名稱生成策略
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
/***建立一個配置類解析器
1)元數據讀取器工廠
this.metadataReaderFactory = metadataReaderFactory;
2)問題報告器
this.problemReporter = problemReporter;
//設置環境
this.environment = environment;
3)資源加載器
this.resourceLoader = resourceLoader;
4）建立了一個組件掃描器
this.componentScanParser = new ComponentScanAnnotationParser(
environment, resourceLoader, componentScanBeanNameGenerator, registry);
this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
****/
// Parse each @Configuration class
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
//將要被解析的配置類(把本身的configCandidates加入到 候選的)
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
//已經被解析的配置類(因爲do while 那麼mainclass就必定會被解析,被解析的size爲1)
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//經過配置解析器真正的解析配置類
parser.parse(candidates);
//進行校驗
parser.validate();
//獲取ConfigClass (把解析過的配置bean定義信息獲取出來)
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
//@CompentScan是直接註冊Bean定義信息的 可是經過獲取@Import,@Bean這種的註解尚未註冊的bean定義,
this.reader.loadBeanDefinitions(configClasses);
//把系統解析過咱們本身的組件放在alreadyParsed
alreadyParsed.addAll(configClasses);
//清除解析過的 配置文件
candidates.clear();
//已經註冊的bean定義個數大於最新 開始系統+主配置類的(發生過解析)
if (registry.getBeanDefinitionCount() > candidateNames.length) {
//獲取系統+本身解析的+mainconfig的bean定義信息
String[] newCandidateNames = registry.getBeanDefinitionNames();
//系統的+mainconfig的bean定義信息
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
//已經解析過的本身的組件
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
//老的（系統+mainconfig） 不包含解析的
if (!oldCandidateNames.contains(candidateName)) {
//把當前bean定義獲取出來
BeanDefinition bd = registry.getBeanDefinition(candidateName);
//檢查是否爲解析過的
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
//若不是解析過且經過檢查的 把當前的bean定義 加入到candidates中
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
// 把解析過的賦值給原來的
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty()); //還存主沒有解析過的 再次解析
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext. ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache(); } } 複製代碼
- i6標記處源碼解析 org.springframework.context.annotation.ConfigurationClassParser#parse
public void parse(Set<BeanDefinitionHolder> configCandidates) {
this.deferredImportSelectors = new LinkedList<>();
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
//註解形式的bean定義信息
if (bd instanceof AnnotatedBeanDefinition) {
//解析配置類的bean定義
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
processDeferredImportSelectors();
}
===================================================================
>org.springframework.context.annotation.ConfigurationClassParser#parse
>org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
// Otherwise ignore new imported config class; existing non-imported class overrides it.
return;
}
else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one. this.configurationClasses.remove(configClass); this.knownSuperclasses.values().removeIf(configClass::equals); } } // Recursively process the configuration class and its superclass hierarchy. // 遞歸處理配置類及其超類層次結構。 SourceClass sourceClass = asSourceClass(configClass); do { sourceClass = doProcessConfigurationClass(configClass, sourceClass); } while (sourceClass != null); this.configurationClasses.put(configClass, configClass); } =================================================================== >org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException { // Recursively process any member (nested) classes first processMemberClasses(configClass, sourceClass); // Process any @PropertySource annotations //處理@PropertySource註解 for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) { if (this.environment instanceof ConfigurableEnvironment) { processPropertySource(propertySource); } else { logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() + "]. Reason: Environment must implement ConfigurableEnvironment"); } } //處理@ComponentScan註解 //解析@ComponentScans註解的屬性 封裝成一個一個的componentscan對象 // 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)) { //循環componentScans的set 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) { //獲取原始的bean定義信息 BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition(); if (bdCand == null) { bdCand = holder.getBeanDefinition(); } //檢查當前的bean定義信息是否是配置類 好比MainConfig的bean定義信息 if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) { //遞歸調用來解析MainConfig,解析出來配置類的中導入的bean定義信息 parse(bdCand.getBeanClassName(), holder.getBeanName()); } } } } //處理@Import註解 解析Import 註解的ImportSelector ImportBeanDefinitionRegister,@Bean這種 //存放在ConfigClass中 // Process any @Import annotations processImports(configClass, sourceClass, getImports(sourceClass), true); //處理 @ImportResource annotations // Process any @ImportResource annotations AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class); if (importResource != null) { String[] resources = importResource.getStringArray("locations"); Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader"); for (String resource : resources) { String resolvedResource = this.environment.resolveRequiredPlaceholders(resource); configClass.addImportedResource(resolvedResource, readerClass); } } // 處理 @Bean methods // Process individual @Bean methods Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass); for (MethodMetadata methodMetadata : beanMethods) { configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass)); } //處理接口 // Process default methods on interfaces processInterfaces(configClass, sourceClass); // 處理超類的 // Process superclass, if any if (sourceClass.getMetadata().hasSuperClass()) { String superclass = sourceClass.getMetadata().getSuperClassName(); if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) { this.knownSuperclasses.put(superclass, configClass); // Superclass found, return its annotation metadata and recurse return sourceClass.getSuperClass(); } } // No superclass -> processing is complete return null; } ========================================================= //經過組件掃描器進行真正的解析 >org.springframework.context.annotation.ComponentScanAnnotationParser#parse public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) { //建立一個類路徑下的bean定義掃描器 ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader); //爲掃描器設置一個bean 名稱的生成器 Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator"); boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass); scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator : BeanUtils.instantiateClass(generatorClass)); ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy"); if (scopedProxyMode != ScopedProxyMode.DEFAULT) { scanner.setScopedProxyMode(scopedProxyMode); } else { Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver"); scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass)); } scanner.setResourcePattern(componentScan.getString("resourcePattern")); for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) { for (TypeFilter typeFilter : typeFiltersFor(filter)) { scanner.addIncludeFilter(typeFilter); } } for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) { for (TypeFilter typeFilter : typeFiltersFor(filter)) { scanner.addExcludeFilter(typeFilter); } } boolean lazyInit = componentScan.getBoolean("lazyInit"); if (lazyInit) { scanner.getBeanDefinitionDefaults().setLazyInit(true); } Set<String> basePackages = new LinkedHashSet<>(); String[] basePackagesArray = componentScan.getStringArray("basePackages"); for (String pkg : basePackagesArray) { String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg), ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS); Collections.addAll(basePackages, tokenized); } for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) { basePackages.add(ClassUtils.getPackageName(clazz)); } if (basePackages.isEmpty()) { basePackages.add(ClassUtils.getPackageName(declaringClass)); } scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) { @Override protected boolean matchClassName(String className) { return declaringClass.equals(className); } }); //真正掃描器掃描指定路徑 return scanner.doScan(StringUtils.toStringArray(basePackages)); } =========================================================== >org.springframework.context.annotation.ClassPathBeanDefinitionScanner#ClassPathBeanDefinitionScanner public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); this.registry = registry; //使用默認的掃描規則 if (useDefaultFilters) { registerDefaultFilters(); } //設置環境變量 setEnvironment(environment); //設置資源加載器 setResourceLoader(resourceLoader); } ===================================== //默認的掃描規則 protected void registerDefaultFilters() { //添加了Componet的解析，這就是咱們爲啥@Componet @Respository @Service @Controller的 @AspectJ this.includeFilters.add(new AnnotationTypeFilter(Component.class)); ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader(); try { //添加Jsr 250規範的註解 this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false)); logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning"); } catch (ClassNotFoundException ex) { // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip. } try { //JSR330的註解 this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false)); logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning"); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. } } =================================================== 使用掃描器去真正的掃描類,返回Set<BeanDefinitionHolder> >org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan protected Set<BeanDefinitionHolder> doScan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); ////建立一個Bean定義 holder的 set Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>(); //循環掃描路徑 for (String basePackage : basePackages) { //找到候選的組件集合 Set<BeanDefinition> candidates = findCandidateComponents(basePackage); //循環候選組件集合 for (BeanDefinition candidate : candidates) { ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate); candidate.setScope(scopeMetadata.getScopeName()); //生成bean的名稱 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); //判斷是否是抽象的bean定義 if (candidate instanceof AbstractBeanDefinition) { postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } //註解的bean定義 if (candidate instanceof AnnotatedBeanDefinition) { AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } if (checkCandidate(beanName, candidate)) { //檢查當前的和存主的bean定義是否有衝突 //把候選的組件封裝成BeanDefinitionHolder BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); //加入到bean定義的集合中 beanDefinitions.add(definitionHolder); //註冊當前的bean定義信息 registerBeanDefinition(definitionHolder, this.registry); } } } return beanDefinitions; } ========================================================= >org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents 找到候選的組件 返回Set<BeanDefinition>的集合 >org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents private Set<BeanDefinition> scanCandidateComponents(String basePackage) { // //候選的bean定義信息 Set<BeanDefinition> candidates = new LinkedHashSet<>(); try { //拼接須要掃描包下面的類的路徑 classpath*:com/niuh/testapplicationlistener/**/*.class String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + this.resourcePattern; //把路徑解析成一個個.class文件 Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath); boolean traceEnabled = logger.isTraceEnabled(); boolean debugEnabled = logger.isDebugEnabled(); //循環.class文件的resource對象 for (Resource resource : resources) { if (traceEnabled) { logger.trace("Scanning " + resource); } //判斷class文件是否可讀 if (resource.isReadable()) { try { //把resource對象 變爲一個類的原信息讀取器 MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource); //判斷類的源信息讀取器是否爲候選的組件 if (isCandidateComponent(metadataReader)) { //是候選的組件 //把類元信息讀取器封裝成一個ScannedGenericBeanDefinition ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setResource(resource); sbd.setSource(resource); //是候選的組件 if (isCandidateComponent(sbd)) { if (debugEnabled) { logger.debug("Identified candidate component class: " + resource); } //把當前解析出來的定義的加入到 BeanDefinition的集合中 candidates.add(sbd); } else { if (debugEnabled) { logger.debug("Ignored because not a concrete top-level class: " + resource); } } } else { if (traceEnabled) { logger.trace("Ignored because not matching any filter: " + resource); } } } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to read candidate component class: " + resource, ex); } } else { if (traceEnabled) { logger.trace("Ignored because not readable: " + resource); } } } } catch (IOException ex) { throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex); } return candidates; } =========================================== 是否是須要掃描的組件 org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isCandidateComponent protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { //是否是被排除的 for (TypeFilter tf : this.excludeFilters) { if (tf.match(metadataReader, this.metadataReaderFactory)) { return false; } } //在被包含的組件 for (TypeFilter tf : this.includeFilters) { if (tf.match(metadataReader, this.metadataReaderFactory)) { return isConditionMatch(metadataReader); } } return false; } ============================================================== 是否可以進行@Conditional判斷 org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isConditionMatch private boolean isConditionMatch(MetadataReader metadataReader) { if (this.conditionEvaluator == null) { this.conditionEvaluator = new ConditionEvaluator(getRegistry(), getEnvironment(), getResourceLoader()); } return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata()); } 複製代碼
相關文章
- 1. spring源碼解析之IOC容器（一）
- 2. Spring IoC 容器的擴展
- 3. Spring源碼分析（一）——AOP、DI、IOC和IOC容器原理
- 4. Spring源碼閱讀-IOC 容器解析
- 5. Spring源碼閱讀-IoC容器解析
- 6. Spring源碼-IOC容器(十)-@Autowired解析
- 7. Spring IOC 容器源碼分析圖解
- 8. Spring4.x源碼解析：IOC容器底層原理解析
- 9. Spring 源碼分析（二）之 Spring IOC 容器源碼分析
- 10. Spring源碼之IoC原理
- 更多相關文章...
- • Spring IoC容器：BeanFactory和ApplicationContext - Spring教程
- • Thymeleaf擴展 - Thymeleaf 教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
- • Docker容器實戰(七) - 容器眼光下的文件系統
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
