Spring Bean是怎么被创建进入工厂的

搭建好自己的spring环境

测试代码

@Component
public class UserService {


	public void test() {
		System.out.println("test");
	}
}

public class Test {

	public static void main(String[] args) {

		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
		UserService userService = applicationContext.getBean("userService", UserService.class);
		userService.test();

	}
}

1.首先我们来看实例化AnnotationConfigApplicationContext做了什么

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

看new AnnotationConfigApplicationContext(AppConfig.class);的构造方法

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		// 1. 创建BeanFactory
		// 2. 生成AnnotatedBeanDefinitionReader
		// 3. 生成ClassPathBeanDefinitionScanner
		this();

		// 利用reader把componentClasses注册为一个BeanDefinition
		register(componentClasses);

		// 调用AbstractApplicationContext的refresh()方法，模板模式，会启动ApplicationContext
		// 为什么叫refresh，而不叫start?
		refresh();
	}

这里的this（）;很重要BeanFactory和一些初始的bean都是在这里面的实现的。

在进入this();(初始化AnnotationConfigApplicationContext前先初始化父类，从而初始化BeanFactory等一些类)

	public AnnotationConfigApplicationContext() {
		// 在执行这个构造方法之前，会先执行父类的构造方法，会初始化一个beanFactory = new DefaultListableBeanFactory()

		// 生成并注册5个BeanDefinition
		// 1.ConfigurationClassPostProcessor
		// 2.AutowiredAnnotationBeanPostProcessor
		// 3.CommonAnnotationBeanPostProcessor
		// 4.EventListenerMethodProcessor
		// 5.DefaultEventListenerFactory
		this.reader = new AnnotatedBeanDefinitionReader(this);

		// 注册默认的includeFilter
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

2.这里实例化AnnotatedBeanDefinitionReader

this.reader = new AnnotatedBeanDefinitionReader(this);

会生成五个初始的Bean，暂时先不用知道他们干什么的，其中一个Bean（ConfigurationClassPostProcessor）有很大的作用，注册的代码在这里：

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

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {

			// 设置beanFactory的OrderComparator，为AnnotationAwareOrderComparator
			// 它是一个Comparator，是一个比较器，可以用来进行排序，比如new ArrayList<>().sort(Comparator);
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			// 设置自动装配候选者解析式（判断某个bean是不是可以用来进行进行自动注入）
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		// 注册ConfigurationClassPostProcessor类型的BeanDefinition
		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));
		}

		// 注册AutowiredAnnotationBeanPostProcessor类型的BeanDefinition
		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));
		}

		// 注册CommonAnnotationBeanPostProcessor类型的BeanDefinition
		// 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));
		}

		// 注册PersistenceAnnotationBeanPostProcessor类型的BeanDefinition
		// 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));
		}

		// 注册EventListenerMethodProcessor类型的BeanDefinition
		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));
		}

		// 注册DefaultEventListenerFactory类型的BeanDefinition
		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;
	}

这里:

this.scanner = new ClassPathBeanDefinitionScanner(this); //注册默认的includeFilter

其实就是注册@Component注解，以后解析用到，还有一个javax.annotation.ManagedBean

 

3.继续往下走

咱们利用debug模式监听beanFactory.beanDefinitionMap

进入方法：

refresh();

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				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();
			}
		}
	}

 

当过invokeBeanFactoryPostProcessors(beanFactory); 方法时UserService在beanFactory.beanDefinitionMap出现了

所以可以知道这个方法注册了@Componet的类

继续利用此debug模式进入该方法找到注册bean的具体方法

看最后的调用的栈帧最后还是org.springframework.beans.factory.support.DefaultListableBeanFactory注册到beanFactory里面

总结一下：

首先通过AnnotationConfigApplicationContext构造方法,实例化

this.reader = new AnnotatedBeanDefinitionReader(this);

这里面生成并注册5个BeanDefinition

// 1.ConfigurationClassPostProcessor

// 2.AutowiredAnnotationBeanPostProcessor

// 3.CommonAnnotationBeanPostProcessor

// 4.EventListenerMethodProcessor

// 5.DefaultEventListenerFactory

然后到invokeBeanFactoryPostProcessors(beanFactory);执行Bean工厂的后置BeanFactoryPostProcessor（ConfigurationClassPostProcessor）的

postProcessBeanDefinitionRegistry（BeanDefinitionRegistry registry）方法

利用ConfigurationClassParser.parser(Set<BeanDefinitionHolder> configCandidates)

configCandidates：是不是配置类候选者

那么什么样的BeanDefinition符合呢：

// 1. 存在@Configuration的就是配置类，或者
// 2. 存在@Component，@ComponentScan，@Import，@ImportResource，或者
// 3. 存在@Bean标注的方法

最后扫描出@ComponentScan的bean注册到bean工厂（当然这里面会设置一些Bean初始化属性）

解析@ComponentScan时候有个BeanNameGenerator接口方法

Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");

public interface BeanNameGenerator {

	/**
	 * Generate a bean name for the given bean definition.
	 * @param definition the bean definition to generate a name for
	 * @param registry the bean definition registry that the given definition
	 * is supposed to be registered with
	 * @return the generated bean name
	 */
	String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry);

}

@ComponentScan(value = "com.luban",nameGenerator = TestBeanNameGenerator.class)

其实就是自定义BeanNam生成策略，有需要可以自己使用；

如果没有配置包则默认加载AppConfig的包下所有。

下一节咱们来看Bean的生命周期