快速了解Spring源码 - refresh( )

GeekInk失控
95 阅读7分钟

  1. 面试常见问题：

    1. bean生命周期
    2. 循环依赖
    3. 三级缓存
    4. FactoryBean 和 beanFactory
    5. ApplicationContext 和 BeanFactory 的区别
    6. 设计模式

  2. bean定义信息BeanDefinition读取xml配置文件，通过抽象接口BeanDefinitionReader读取配置文件规范，源码当中的ConfigurableListableBeanFactory部分内容就是读取.xml配置文件

  3. 实例化：在堆中开辟一块空间，属性都是默认值。

初始化：给属性完成赋值操作，调用具体的初始化方法

  1. BeanFactory对应源码当中的prepareRefresh( )和prepareBeanFactory( )，**BeanFactoryPostProcessor是对beanDefinition的扩展 **，可以set很多扩展信息，BeanFactoryPostProcessor对应源码当中的invokeBeanFactoryPostProcessors( )和registerBeanPostProcessors( )

  1. Environment：环境，包含 env 和 properties， 为了方便使用，在容器创建的时候会提前将系统的相关属性加载到StandardEnvironment对象当中，方便后续的使用

  2. 源码AbstractApplicationContext当中的refresh( )方法，通过调用refresh( )方法了解IOC容器创建原理（执行顺序从上到下），refresh( )方法是spring启动的核心，在其中完成了容器的刷新、beanFactory标准初始化、bean的初始化

BeanFactoryPostProcessor接口用于在Bean工厂实例化Bean之前对Bean的定义进行修改,它可以读取和修改Bean的定义元数据,例如修改Bean的属性值,添加额外的配置信息等
BeanFactoryPostProcessor在Bean实例化之前执行,用于对Bean的定义进行预处理

BeanPostProcessor接口用于在Bean实例化后对Bean进行增强或修改,可以在Bean初始化过程中对Bean进行处理

一言带过,BeanFactoryPostProcessor主要用于修改Bean的定义,而BeanPostProcessor主要用于增强或修改Bean的实例

prepareRefresh( )：程序启动标志位，准备刷新上下文方法，用于设置准备刷新前的一些参数
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()：刷新并获取刷新后的BeanFactory，读取.xml配置文件，通过配置文件读取Bean，内部调用refreshBeanFactory( )和getBeanFactory( )
prepareBeanFactory(beanFactory)：初始化BeanFactory，设置各种基础属性,比如classLoader
postProcessBeanFactory(beanFactory)：BeanFactory准备工作完成后进行的后置处理工作
invokeBeanFactoryPostProcessors(beanFactory)：实例化并调用所有已经注册的BeanFactoryPostProcessor
registerBeanPostProcessors(beanFactory)：实例化并注册BeanPostProcessors到BeanFacotry中并排序,Bean的后置处理器
initMessageSource( ) 国际化处理,消息绑定,消息解析
initApplicationEventMulticaster( ) 初始化上下文事件的广播/多播器，方便后续发布监听事件
onRefresh( )：子类实现，在此创建web容器，并提前生成容器所需的bean及其对应的生命周期
registerListeners()：给广播器中注册监听器
finishBeanFactoryInitialization(beanFactory)：初始化所有非懒加载单实例Bean
finishRefresh( )：完成刷新，发布上下文刷新完毕事件

	protected void prepareRefresh() {
        // 设置context容器的启动时间
		this.startupDate = System.currentTimeMillis();
		// 设置当前状态为活跃/启动
		this.closed.set(false);
		this.active.set(true);
        // log打印

		// 交由子类实现,用于加载初始化资源属性.
		initPropertySources();

		// 校验所需要的环境变量是否已经加载进来
		getEnvironment().validateRequiredProperties();

		// 保留未生成Context时加载的Linsteners监听器,用LinkedHashSet保存
		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);
		}

		// 创建ApplicationEvent监听事件容器
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}


protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		//初始化beanFactory，并执行加载和解析配置操作
		refreshBeanFactory();
		//返回beanFactory实例
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 设置BeanFactory的ClassLoader
	beanFactory.setBeanClassLoader(getClassLoader());
	// 判断是否需要加载Spring-Spel表达式解析器.默认加载
	if (!shouldIgnoreSpel) {
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	}
	// 添加属性编辑器用于自定义属性设置覆盖
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// 添加默认注册Bean前加入BeanPostProcessor用于Bean初始化前进行操作: 如果Bean实现了某个Aware则调用对应方法.可查看ApplicationContextAwareProcessor.ApplicationContextAwareProcessor方法,自定义Bean可进行拓展
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	// 忽略一些系统级接口依赖,这些方法在上面的Processor中检查回调中会执行.
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationStartup.class);

	// 设置注册不能自动创建的Bean依赖
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	// 添加Bean初始化后操作,如果有该单例监听器Bean就加入到上下文监听器容器中
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// 加入AspectJ支持(静态代理,启动时会改变被代理类字节码进行增强https://blog.csdn.net/crazyzhb2012/article/details/53827540 | https://developer.aliyun.com/article/574571)
	if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		// Set a temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// 检查并加入一些默认的初始化环境Bean
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
	if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
		beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
	}
}


// ServletWebServerApplicationContext中的方法
// 作为BeanFactory设置好之后Bean加载初始化前拓展扫描的后置操作
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	//添加一个ServletContextAwareProcessor到beanFactory中
	beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
	//在beanFactory自动装配的时候忽略一些接口
	beanFactory.ignoreDependencyInterface(ServletContextAware.class);
	// 最主要是最后这步,为BeanFactory注册了request、session的web域
	// 并注册了ServletRequest、ServletResponse、HttpSession、WebRequest到容器中
	registerWebApplicationScopes();
}


protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 调用执行默认的和自定义的BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor类方法
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	//···其他
}


public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}


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 + "]");
		}
	}
}


//事件广播器用于Spring事件通知机制,监听器通过指定监听事件,当广播器广播该事件时会执行对应监听器方法.
//该方法表示如果有自定义广播器则使用自定义广播器没有则创建一个SimpleApplicationEventMulticaster.可自定义拓展让广播器监听事件异步执行
//保存事件和对应监听器列表映射,发布事件后会找到该事件的所有监听器.如果由线程池则异步执行.没有则同步执行
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 如果用户手动新建了一个名为applicationEventMulticaster类型为ApplicationEventMulticaster的bean，则将这个bean作为事件广播器
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    }
    else {
        // 否则新建一个SimpleApplicationEventMulticaster作为默认的事件广播器
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
}


//在AbstractApplicationContext的子类中初始化其他特殊的bean,其实就是初始化ThemeSource接口的实例,这个方法需要在所有单例bean初始化之前调用
protected void onRefresh() throws BeansException {
	// For subclasses: do nothing by default.
}

//给广播器中注册监听器，发布广播器未初始化时加载的事件
protected void registerListeners() {
	// 将Application启动时加载的Linsteners加入广播器中
	for (ApplicationListener<?> listener : getApplicationListeners()) {
		getApplicationEventMulticaster().addApplicationListener(listener);
	}

	// 先将常规的监听器Bean名称放入,后续再创建
	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
	for (String listenerBeanName : listenerBeanNames) {
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	}

	// 早期Application事件发布
	Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
	this.earlyApplicationEvents = null;
	if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
			getApplicationEventMulticaster().multicastEvent(earlyEvent);
		}
	}
}


protected void finishRefresh() {
	// 清除为上下文创建初始化准备的资源文件数据信息缓存.比如ASM的元数据信息
	clearResourceCaches();

	// 一般是加载DefaultLifecycleProcessor
	initLifecycleProcessor();

	// 执行生命周期处理器的onRefresh方法.会调用实现了SmartLifecycle接口的start方法启动对应Bean生命周期(随着Application启动启动,关闭而关闭)
	getLifecycleProcessor().onRefresh();

	// 发布上下文刷新完毕事件
	publishEvent(new ContextRefreshedEvent(this));

	// 设置JMX则执行
	if (!NativeDetector.inNativeImage()) {
		LiveBeansView.registerApplicationContext(this);
	}
}

protected void initLifecycleProcessor() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	// 我们自己没定义就一定是走下面默认的LifecycleProcssor上.我们自己定义的话最好也是继承下面那个默认的来定义,下面那个默认的是让Bean生命周期随上下文一致的保证.
	if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
		this.lifecycleProcessor =
				beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
		if (logger.isTraceEnabled()) {
			logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
		}
	}
	else {
		DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
		defaultProcessor.setBeanFactory(beanFactory);
		this.lifecycleProcessor = defaultProcessor;
		beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
		if (logger.isTraceEnabled()) {
			logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
					"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
		}
	}
}
avatar
文章
阅读
粉丝