Spring IOC源码

1. Spring 设计模式

• 工厂模式
• 单例模式
• 观察者模式

2. Spring Ioc 源码分析

AbstractApplicationContext 抽象类

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 1、创建bean工厂前的一些准备工作，设置启动日期、初始化属性值
			prepareRefresh();

			// 2、创建bean工程并且告诉所有的之类刷新bean工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 3、使用bean工厂
			prepareBeanFactory(beanFactory);

			try {
				// 4、对上下文中的bean进行后处理.
				postProcessBeanFactory(beanFactory);

				// 5、执行bean工厂
				invokeBeanFactoryPostProcessors(beanFactory);

				// 6、创建并且注入多个bean处理器
				registerBeanPostProcessors(beanFactory);

				// 7、初始化消息
				initMessageSource();

				// 8、初始化多播器
				initApplicationEventMulticaster();

				// 9、加载特殊的bean
				onRefresh();

				// 10、注册多个监听器，内部使用观察者模式，在整个过程中都适用
				registerListeners();

				// 11、初始化所有非懒惰的bean，并且加载到IOC容器中
				finishBeanFactoryInitialization(beanFactory);

				// 12、完成刷线
				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();
			}
		}
	}

2.1. 预加载信息，设置启动日期和实例化属性 prepareRefresh()

/**
	 * Prepare this context for refreshing, setting its startup date and
	 * active flag as well as performing any initialization of property sources.
	 */
	// 准备启动日期、初始化属性的值
	protected void prepareRefresh() {
		// Switch to active.
		this.startupDate = System.currentTimeMillis(); // 启动日期
		this.closed.set(false);
		this.active.set(true);

		if (logger.isDebugEnabled()) {
			if (logger.isTraceEnabled()) {
				logger.trace("Refreshing " + this);
			}
			else {
				logger.debug("Refreshing " + getDisplayName());
			}
		}

		// Initialize any placeholder property sources in the context environment.
        // 初始化一些环境信息
		initPropertySources();

		// Validate that all properties marked as required are resolvable:
		// see ConfigurablePropertyResolver#setRequiredProperties
        // 验证所有的必输属性是否可解析的
		getEnvironment().validateRequiredProperties();

		// Store pre-refresh ApplicationListeners...
        // 转载预加载的监听信息
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
            // 充值所有的预加载信息
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

2.2. 创建bean工厂，并告知子类刷新bean工厂

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

// 通知子类刷新内部工厂	   
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory(); // 刷新bean工厂
		return getBeanFactory(); // 返回新的bean工厂
	}

2.2.1 refreshBeanFactory 刷新bean工厂

/*
* 刷新bean工厂，如果先前存在bean工厂，销毁bean工厂，然后创建一个新的bean工厂
*/
@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) { // 判断是否存在bean工厂
			destroyBeans(); // 销毁所有的bean对象
			closeBeanFactory(); // 关闭bean工厂
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory(); // 创建一个新的bean工厂
			beanFactory.setSerializationId(getId()); // 初始化bean工厂的ID
			customizeBeanFactory(beanFactory); // 自定义bean工厂
			loadBeanDefinitions(beanFactory); // 加载beanDefinitions的信息  （loader bean 信息）
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

2.2.1.1 创建一个bean工厂

    // 创建bean工厂
    protected DefaultListableBeanFactory createBeanFactory() {
		return new DefaultListableBeanFactory(getInternalParentBeanFactory());
	}

	// 调用父类的方法创建一个DefaultListableBeanFactory
    public DefaultListableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
		super(parentBeanFactory);
	}

	// 父类set
    @Override
        public void setParentBeanFactory(@Nullable BeanFactory parentBeanFactory) {
            if (this.parentBeanFactory != null && this.parentBeanFactory != parentBeanFactory) {
                throw new IllegalStateException("Already associated with parent BeanFactory: " + this.parentBeanFactory);
            }
            if (this == parentBeanFactory) {
                throw new IllegalStateException("Cannot set parent bean factory to self");
            }
            // 创建好了bean
            this.parentBeanFactory = parentBeanFactory;
        }

2.2.1.2. 读取bean定义信息，加载到bean工厂中 AbstractBeanDefinitionReader

// 为bean工厂创建一个新的AbstractBeanDefinitionReader（抽象bean信息）
protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		// Determine ResourceLoader to use.
		if (this.registry instanceof ResourceLoader) {
			this.resourceLoader = (ResourceLoader) this.registry;
		}
		else {
            // 设置一个资源加载的类
			this.resourceLoader = new PathMatchingResourcePatternResolver();
		}

		// 继承环境信息
		if (this.registry instanceof EnvironmentCapable) {
			this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
		}
		else {
            // 设置一个新的环境信息
			this.environment = new StandardEnvironment();
		}
	}

读取xml中被抽象的bean信息

// 通过xml加载bean定义的的信息	
@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 为给定的一个bean工厂创建一个新的xml读取bean定义信息的方法.
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		beanDefinitionReader.setEnvironment(this.getEnvironment()); // 设置环境
		beanDefinitionReader.setResourceLoader(this); // 加载当前资源
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // 设置实体处理器

		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
		initBeanDefinitionReader(beanDefinitionReader); // 实例化bean信息
		loadBeanDefinitions(beanDefinitionReader); // 加载bean信息
	}

2.3. invokeBeanFactoryPostProcessors 执行bean工厂

/**
* 实例化并且调用所有的beanFactoryPostProcessors
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // 添加bean处理器
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

2.4. registerBeanPostProcessors 注册bean处理器

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

2.5. initMessageSource 初始化消息源

protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			// Make MessageSource aware of parent MessageSource.
			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
				if (hms.getParentMessageSource() == null) {
					// Only set parent context as parent MessageSource if no parent MessageSource
					// registered already.
					hms.setParentMessageSource(getInternalParentMessageSource());
				}
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			// Use empty MessageSource to be able to accept getMessage calls.
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
			}
		}
	}

2.6. initApplicationEventMulticaster 初始化多播器

/**
* 如果上下文中没有多播器，则使用这个多播器
*/
protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
						"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
			}
		}
	}

2.7. 在上下文中初始化特殊的bean onRefresh()

/**
* 可扩展该方法，实现初始特殊的bean
*/
protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
	}

2.8. 注册监听器 registerListeners

protected void registerListeners() {
		// Register statically specified listeners first.
		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!
		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);
			}
		}
	}

2.9. 实例化所有剩余的Bean finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 初始化服务.
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// 如果没有设置bean后置处理器，则使用默认的解析器
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// 实例化bean
		beanFactory.preInstantiateSingletons();
	}

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// 注册定义新的bean
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// 把所有的非惰性的bean进行初始化
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		// 初始化所有的bean.
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}