【Spring源码】IOC容器实现-AnnotationConfigApplicationContext(注解方式)初始化

前言

Github:https://github.com/yihonglei/thinking-in-spring

IOC容器XML方式实现源码:

IOC容器结构体系

BeanDefinition的Resource定位

BeanDefinition的载入和解析

BeanDefinition的注册

Bean对象的创建

Bean依赖注入

一 IOC容器注解方式实现概述

Spring注解方式减少了大量XML配置工作和代码复杂性,降低开发和维护成本。

常用的Spring注解@ComponentScan,@Service,@Autowired等,

Spring对这些注解都是怎么运行工作的,对应注解一放,功能轻飘飘实现了,有没有感觉很神奇?

二 注解使用实例

先简单来个Demo,根据这个Demo去探索注解背后的代码。

1、Bean1

HelloService

package com.jpeony.spring.annotation;

/**
 * @author yihonglei
 */
public interface HelloService {
    void sayHello();
}

HelloServiceImpl

package com.jpeony.spring.annotation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author yihonglei
 */
@Service(value = "helloService")
public class HelloServiceImpl implements HelloService {
    @Autowired
    private TomService tomService;

    @Override
    public void sayHello() {
        String nameTmp = tomService.createName();
        System.out.println("Name is " + nameTmp);
    }
}

HeloServiceImpl内部依赖对应TomServiceImpl。

2、Bean2

TomService

package com.jpeony.spring.annotation;

/**
 * @author yihonglei
 */
public interface TomService {
    String createName();
}

TomServiceImpl 

package com.jpeony.spring.annotation;

import org.springframework.stereotype.Service;

/**
 * @author yihonglei
 */
@Service(value = "tomService")
public class TomServiceImpl implements TomService {

    @Override
    public String createName() {
        return "Tom";
    }
}

3、AppConfig

package com.jpeony.spring.annotation;

import org.springframework.context.annotation.ComponentScan;

/**
 * @author yihonglei
 */
@ComponentScan(value = "com.jpeony.spring.annotation")
public class AppConfig {

}

应用启动注解类。 

4、Test

package com.jpeony.spring;

import com.jpeony.spring.annotation.AppConfig;
import com.jpeony.spring.annotation.HelloService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author yihonglei
 */
public class AnnotationTest {
    @Test
    public void testAnnotation() {
        // IOC容器(传入@ComponentScan对应的注解类AppConfig)
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // IOC容器(直接传入需要扫描的包路径)
        // AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.jpeony.spring.annotation");
        // 获取bean
        HelloService helloService = (HelloService) context.getBean("helloService");

        // 调用方法
        helloService.sayHello();
    }
}

运行结果

从容器获取HelloService对象,同时在HelloService#sayHello()中调用了TomService#createName()方法。

我们在这里提出几个凝问,带着这几个问题去分析源码。

1、@ComponentScan去扫描东西,扫描的是啥,把什么东西变成IOC容器需要的东西,然后注册到IOC容器?

2、@Service注解的类,如何注册到IOC容器的?

3、@Autowired是怎么像XML方式一样处理依赖关系的?

这里分析AnnotationConfigApplicationContext实现原理,理解了这个注解容器关于IOC的实现原理,

以及@ComponentScan注解实现原理,等你去看SpringBoot启动源码的时候,感觉相对比较容易些。

AnnotationConfigApplicationContext类图。

三IOC后置处理器注入

在上面的测试代码里面,AnnotationConfigApplicationContext有两种用法。

一种是传入@ComponentScan注解的类,另外一种是直接传入要扫描的包。

直接传入扫描包相对比较简单,上来就开始扫描。

传入@ComponentScan注解类相对比较麻烦些,需要绕一圈,才能调到scan()方法。

这里挑传入@ComponentScan注解类分析,因为我们基本都是使用@ComponentScan,

直接传入扫描包只是@ComponentScan注解类实现方式一个子集,理解了@ComponentScan,

自然就理解了直接传入扫描包的方式。

从构造器看起!

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
	this();
	register(annotatedClasses);
	refresh();
}

上来看到了一个醒目的refresh()方法,莫慌,等会再看他,先去找水。

这里跟XML方式有区别,XML方式的BeanFactory是在refresh()#obtainFreshBeanFactory()方法里面去获取的,

而注解方式则是通过父类构造器直接构建的,一上来就创建容器,默认用的DefaultListableBeanFactory。

到这里,IOC容器有了,接着往下看 ,this():

public AnnotationConfigApplicationContext() {
    // 注解BeanDefinition读取器
	this.reader = new AnnotatedBeanDefinitionReader(this);
    // ClassPath扫描器
	this.scanner = new ClassPathBeanDefinitionScanner(this);
}

1、AnnotatedBeanDefinitionReader

追踪到AnnotationConfigUtils#registerAnnotationConfigProcessors():

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, Object source) {

	// 获取BeanFactory
	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}

	// BeanDefinitionHolder包装类集合,在后续注入应用bean的时候,需要返回给调用方,调用方有逻辑处理
	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);

	// 注册Bean的后置处理器,这里Spring 4.X主要有7个
	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition();
		try {
			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
					AnnotationConfigUtils.class.getClassLoader()));
		}
		catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
		}
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
	}
	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
	}

	return beanDefs;
}

AnnotationConfigUtils#registerPostProcessor()源码:

注入后置处理器Bean。

private static BeanDefinitionHolder registerPostProcessor(
		BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

	definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	// 向容器注入IOC后置处理器Bean
	registry.registerBeanDefinition(beanName, definition);
	return new BeanDefinitionHolder(definition, beanName);
}

RootBeanDefinition是个啥?

是BeanDefinition的其中一个实现,是Bean元数据存储的数据结构,存入Bean的相关信息。

BeanDefinitionHolder是个啥?

对Bean进行包装,主要存bean名字,别名,还有BeanDefinition数据结构信息。

DefaultListableBeanFactory#registerBeanDefinition():

往IOC容器注入BeanDefinition数据结构。

DefaultListableBeanFactory是IOC容器的具体实现,关于XML实现方式的源码里面有详细分析。

BeanDefinition数据结构信息注入到容器,本质上是存储到HashMap中,key是beanName,value是Bean的数据结构,

存入这些东西,就相当于往桶里面装水,之后getBean的时候,才能根据相应beanName等来获取对应的对象。

/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
      throws BeanDefinitionStoreException {
  // BeanName和BeanDefinition不能为空,否则停止注册
   Assert.hasText(beanName, "Bean name must not be empty");
   Assert.notNull(beanDefinition, "BeanDefinition must not be null");

   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Validation of bean definition failed", ex);
      }
   }

   BeanDefinition oldBeanDefinition;
  // 检查是否有相同名字的BeanDefinition已经在IOC容器中注册了,如果有同名的BeanDefinition,
   // 但又不允许覆盖,就会抛出异常,否则覆盖BeanDefinition。
   oldBeanDefinition = this.beanDefinitionMap.get(beanName);
   if (oldBeanDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
               "': There is already [" + oldBeanDefinition + "] bound.");
      }
      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
         if (this.logger.isWarnEnabled()) {
            this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                  "' with a framework-generated bean definition: replacing [" +
                  oldBeanDefinition + "] with [" + beanDefinition + "]");
         }
      }
      else if (!beanDefinition.equals(oldBeanDefinition)) {
         if (this.logger.isInfoEnabled()) {
            this.logger.info("Overriding bean definition for bean '" + beanName +
                  "' with a different definition: replacing [" + oldBeanDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      else {
         if (this.logger.isDebugEnabled()) {
            this.logger.debug("Overriding bean definition for bean '" + beanName +
                  "' with an equivalent definition: replacing [" + oldBeanDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      // 检查下容器是否进入了Bean的创建阶段,即是否同时创建了任何bean
      if (hasBeanCreationStarted()) { // 已经创建了Bean,容器中已经有Bean了,是在启动注册阶段创建的。
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         // 注册过程中需要线程同步,以保证数据一致性
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            if (this.manualSingletonNames.contains(beanName)) {
               Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
               updatedSingletons.remove(beanName);
               this.manualSingletonNames = updatedSingletons;
            }
         }
      }
      else {// 正在启动注册阶段,容器这个时候还是空的。
         // Still in startup registration phase
         this.beanDefinitionMap.put(beanName, beanDefinition);
         this.beanDefinitionNames.add(beanName);
         this.manualSingletonNames.remove(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }
  // 重置所有已经注册过的BeanDefinition或单例模式的BeanDefinition的缓存
   if (oldBeanDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
   }
}

this.beanDefinitionMap.put(beanName, beanDefinition);完成bean的注册。

后置处理器注册完成后效果,可以看到有6个后置处理器,具体数据结构是RootBeanDefinition。

2、ClassPathBeanDefinitionScanner

getOrCreateEnvironment()创建Spring运行环境StandardEnvironment。

registerDefaultFilters()需要拦截的注解进行过滤。

有没有发现,搞了半天,好像跟咱们刚才说的@Service,@Auworied没有半毛钱关系。

上面的这些分析,只是Spring本身对Bean后置处理器的注册,应用程序的注册还得继续。

四 AppConfig启动类的注册

在上面AnnotationConfigApplicationContext分析了this()构造器,下面分析register(annotatedClasses)注册启动类。

 

这里通过for循环取注册bean,支持@ComponentScan配置多个路径。

public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
	// 获取注解类路径上的所有注解基本信息
	AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
	if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
		return;
	}
	// AppConfig启动类注册
	ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
	abd.setScope(scopeMetadata.getScopeName());
	String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
	if (qualifiers != null) {
		for (Class<? extends Annotation> qualifier : qualifiers) {
			if (Primary.class == qualifier) {
				abd.setPrimary(true);
			}
			else if (Lazy.class == qualifier) {
				abd.setLazyInit(true);
			}
			else {
				abd.addQualifier(new AutowireCandidateQualifier(qualifier));
			}
		}
	}
	// 注册启动类的Bean
	BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
	definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

AppConfig启动类也注册到IOC容器后,这个时候容器有7个Bean,6个后置处理器和1个启动Bean,

具体数据结构用AnnotatedGenericBeanDefinition存储。

 

五 应用程序BeanDefinition的Resource定位、载入、解析、注册

真正应用程序Bean的注册在refresh()方法中,看了半天,终于到refresh()了。

refresh()源码:

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		// 调用容器准备刷新的方法,设置容器的启动时间为当前时间,容器关闭状态为false,同时给容器设置同步标识
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		// 告诉子类启动refreshBeanFactory()方法,
		// Bean定义资源文件的载入从子类的refreshBeanFactory()方法启动[***重点***]
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		// 为BeanFactory配置容器特性,例如类加载器、事件处理器等
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			// 为容器的某些子类指定特殊的BeanPost事件处理器,进行后置处理
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			// 调用BeanFactory的后置处理器,这些后置处理器是在Bean定义中向容器注册的
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			// 为BeanFactory注册BeanPost事件处理器,BeanPostProcessor是Bean后置处理器,用于监听容器触发的事件
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			// 初始化信息源,和国际化相关
			initMessageSource();

			// Initialize event multicaster for this context.
			// 初始化容器事件传播器
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			// 调用子类的某些特殊Bean初始化方法
			onRefresh();

			// Check for listener beans and register them.
			// 检查监听Bean并且将这些Bean向容器注册
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			// 初始化所有剩余的(non-lazy-init)单态Bean
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			// 初始化容器的生命周期事件处理器,并发布容器的生命周期事件,结束refresh过程
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}

这里有12大步,咱们看关键的即可。

1、obtainFreshBeanFactory()

AbstractApplicationContext#()obtainFreshBeanFactory源码:

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	refreshBeanFactory();
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}

refreshBeanFactory()为AbstractApplicationContext抽象方法,有两个实现。

AnnotationConfigApplicationContext容器继承于GenericApplicationContext,

所以调用GenericApplicationContext#refreshBeanFactory()方法,这里跟XML实现方式不一样,

XML调用的是AbstractRefreshableApplicationContext,并且在这里创建的BeanFactory,

注解方式则在一开始的时候就创建了。

GenericApplicationContext#refreshBeanFactory()源码:

@Override
protected final void refreshBeanFactory() throws IllegalStateException {
	if (!this.refreshed.compareAndSet(false, true)) {
		throw new IllegalStateException(
				"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
	}
	// 注解方式beanFactory在一开始就创建了,这里只是设置容器id
	this.beanFactory.setSerializationId(getId());
}

GenericApplicationContext#getBeanFactory()源码:

返回DefaultListableBeanFactory容器。

2、invokeBeanFactoryPostProcessors()

执行Spring相关后置处理器,代码追踪到应用程序资源读取的位置。

ConfigurationClassParser#doProcessConfigurationClass()源码:

处理@ComponentScan注解,获取扫描文件路径。

ClassPathBeanDefinitionScanner#doScan()源码:

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	Assert.notEmpty(basePackages, "At least one base package must be specified");
	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
	for (String basePackage : basePackages) {
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
		for (BeanDefinition candidate : candidates) {
			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
			candidate.setScope(scopeMetadata.getScopeName());
			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
			if (candidate instanceof AbstractBeanDefinition) {
				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
			}
			if (candidate instanceof AnnotatedBeanDefinition) {
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			if (checkCandidate(beanName, candidate)) {
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				beanDefinitions.add(definitionHolder);
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

ClassPathScanningCandidateComponentProvider#findCandidateComponents()源码:

 查找所有的带@Component注解的对象,因为@Service子注解含有@Component注解,所以也会被匹配到。

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
	Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
	try {
		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
				resolveBasePackage(basePackage) + '/' + this.resourcePattern;
		Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
		boolean traceEnabled = logger.isTraceEnabled();
		boolean debugEnabled = logger.isDebugEnabled();
		for (Resource resource : resources) {
			if (traceEnabled) {
				logger.trace("Scanning " + resource);
			}
			if (resource.isReadable()) {
				try {
					MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
					if (isCandidateComponent(metadataReader)) {
						ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
						sbd.setResource(resource);
						sbd.setSource(resource);
						if (isCandidateComponent(sbd)) {
							if (debugEnabled) {
								logger.debug("Identified candidate component class: " + resource);
							}
							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;
}

扫描的内容就是classpath下的@ComponentScan定义的文件包下所有的.class字节码文件。

文件通过InputStream IO文件流读取,并解析为Resource。

根据读取的字节码元数据,能判断每个类是不是接口,以及每个类上的注解名称,比如HelloServiceImpl上的@Service注解。

根据类上的注解名称和注解类型匹配,能够匹配上的,才能创建BeanDefinition注册到IOC容器中。 

比如HelloServiceImpl,含有@Service注解,而@Service注解含@Component注解,即HelloServiceImpl含有@Component注解,

跟includeFilters规范要求的注解Component匹配,则HelloServiceImpl可以注册为IOC容器的Bean。

匹配成功的Bean都会通过registerBeanDefinition()注册到IOC容器中,这个方法最后追踪到

DefaultListableBeanFactory#registerBeanDefinition(),完成Bean的注册。

分析到这里,终于看到了@ComponentScan注解扫描是根据文件路径读取classpath下的.class字节码文件解析资源,

@Service注解或@Component通过.class字节码文件解析的资源,进行匹配并注册到DefaultListableBeanFactory容器中。

到这里BeanDefinition已经注册到容器了,还差一步就是@Autowired注解怎么解析的依赖注入到容器中?

3、registerBeanPostProcessors()

@Autowired在后置处理器这里处理。

追踪到AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors():  

后置处理器执行会对元数据进行初始化。

关于@Autowired可以参考这个文章:https://blog.csdn.net/f641385712/article/details/93529274

六 Bean对象的创建,Bean依赖注入

getBean()时,进行bean对象的创建和bean依赖注入,跟xml方式类似,只是对于依赖注入@Autowired处理依赖有区别。

Bean对象的创建

Bean依赖注入

七 总结

1、注解方式@ComponentScan定义要扫描的文件包,IOC解析@ComponentScan注解,

对classpath下改包的.class(字节码)文件进行解析,通过IO读取,解析为元数据对象。

2、根据元数据对象是否有注解,进行判断是否创建Bean注册到IOC容器中。

3、@Autowired注解依赖在Autowired后置处理器进行元数据解析,在bean创建是也还会处理一次依赖注入。

 

相关推荐
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页