Spring IOC容器初始化源码剖析（三）

最新推荐文章于 2023-01-07 20:00:00 发布
最新推荐文章于 2023-01-07 20:00:00 发布
阅读量429 收藏
点赞数 1
分类专栏： Spring 5.x 文章标签： spring 容器 java 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WODESHENNI/article/details/120986054
版权

文章目录

  1. Spring IOC容器初始化源码剖析（一）
  2. Spring IOC容器初始化源码剖析（二）

前言

上一章，我们已经了解了refresh()核心方法的前两个prepareRefresh()和obtainFreshBeanFactory()方法，从初始化并校验环境配置，初始化应用监听与事件，到解析资源配置文件，将文件中关于bean定义加载到beanFactory并返回beanFactory的过程。

本文我们继续阅读refresh()的其它方法：

  1. prepareBeanFactory(beanFactory)
  2. postProcessBeanFactory(beanFactory)
  3. invokeBeanFactoryPostProcessors(beanFactory)
  4. registerBeanPostProcessors(beanFactory)
  5. initMessageSource
  6. initApplicationEventMulticaster()
  7. onRefresh()
  8. registerListeners()

prepareBeanFactory(beanFactory);

// AbstractApplicationContext#prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// beanFactory设置this的类加载器
	beanFactory.setBeanClassLoader(getClassLoader());
	
	// shouldIgnoreSpel = SpringProperties.getFlag("spring.spel.ignore")
	// shouldIgnoreSpel默认为false即不忽略SpEL表达式，设置SpEL解析器
	if (!shouldIgnoreSpel) {
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	}
	// 添加属性编辑器
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// 添加BeanPostProcessor
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	
	// 设置自动装配时忽略指定接口的实现类的外部依赖注入
	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);

	// 为指定接口设置指定注入对象
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	// 添加BeanPostProcessor
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// 检测是否存在名为“LoadTimeWeaver ”的bean存在，存在则准备织入
	if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		// 匹配一个临时加载器
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// 检测相应bean是否存在，不存在则手动注册默认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());
	}
}

postProcessBeanFactory(beanFactory)

空方法，可以重写postProcessBeanFactory()，在所有bean未被加载实例化前做一些前置处理或其他动作进行额外扩展。

例如（在原示例基础上进行修改）：

import com.zt.processor.MyBeanPostProcessor;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyApplicationContext extends ClassPathXmlApplicationContext {

    public MyApplicationContext(String configLocation) throws BeansException {
        super(configLocation);
    }

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    	// 添加自定义BeanPostProcessor
    	// 在bean的初始化前后做一些拓展
        beanFactory.addBeanPostProcessor(new MyBeanPostProcessor());
    }
}

import com.zt.bean.Car;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
	
	/**
	 * bean初始化前调用
	 * @Param bean		bean
	 * @Param beanName	bean名称
	 */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("constructorCar".equals(beanName)) {
            ((Car) bean).setPrice(66666d);
        }
        System.out.println("before : " + beanName);
        return bean;
    }

	/**
	 * bean初始化后调用
	 * @Param bean		bean
	 * @Param beanName	bean名称
	 */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("after : " + beanName);
        return bean;
    }
}

before : constructorCar
after : constructorCar
before : secConstructorCar
after : secConstructorCar
Car(brand=Benz, price=200.0, color=white)
Car(brand=Benz, price=66666.0, color=white)

invokeBeanFactoryPostProcessors(beanFactory)

由于篇幅原因下面几个方法我们不在此文探究该方法的内部处理逻辑，可以简单了解一下BeanFactoryPostProcessor。

@FunctionalInterface
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

postProcessBeanFactory(beanFactory)的执行时机在bean初始化后，实例化前执行。

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

	Set<String> processedBeans = new HashSet<>();
	// 若BeanDefinitionRegistryPostProcessors存在，则首先调用

	// 有印象的同学还记得beanFactory的默认实现是DefaultListableBeanFactory，
	// DefaultListableBeanFactory实现了BeanDefinitionRegistry接口。
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		// 常规BeanFactoryPostProcessor列表
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		// 实现了BeanDefinitionRegistryPostProcessor接口的BeanFactoryPostProcessor 
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				// 执行postProcessBeanDefinitionRegistry
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}

		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// 根据BeanDefinitionRegistryPostProcessor.class类型获取所有注册的beanNames，
		// 首先调用实现了PriorityOrdered的BeanFactoryPostProcessor
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 根据ppName获取bean实例添加到当前要注册currentRegistryProcessors列表中（getBean后面讲）
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				// 添加将要被执行的ppName
				processedBeans.add(ppName);
			}
		}
		// 排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		// 调用currentRegistryProcessors中所有DefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
		// 清空
		currentRegistryProcessors.clear();

		// 接下来调用所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor
		// 根据BeanDefinitionRegistryPostProcessor.class类型获取所有注册的beanNames
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 判断是否已执行（已执行添加到processedBeans） && 是否实现了Ordered接口
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
		currentRegistryProcessors.clear();

		// 最后调用所有剩下的未执行的BeanDefinitionRegistryPostProcessor
		// 重复标志位
		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, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();
		}

		// 批量调用实现了BeanDefinitionRegistryPostProcessor接口的BFPP及常规的BFPP的postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// 批量调用beanFactoryPostProcessors中各BFPP的postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	// 根据BeanFactoryPostProcessor.class类型获取所有已注册的beanNames
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		// 判断是否已执行，true:skip
		if (processedBeans.contains(ppName)) {
		}
		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);
		}
	}

	// 首先调用实现了PriorityOrdered接口的BFPP
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, 调用实现了Ordered接口的BFPP
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// 最终调用常规的BFPP
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

	beanFactory.clearMetadataCache();
}

内部调用方法细节不再展开，有兴趣的同学可以自行阅读。

registerBeanPostProcessors(beanFactory)

/**
 * 实例化并调用所有BeanPostProcessor，如果指定顺序则按照顺序执行
 */
 // AbstractApplicationContext
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

// PostProcessorRegistrationDelegate
public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	// 根据BeanPostProcessor.class类型获取所有注册的beanNames
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// 注册BeanPostProcessorChecker，
	// 当在bean实例化期间存在不符合被所有BeanPostProcessor执行的条件，log该bean信息
	// logger.info("Bean '" + beanName + "' of type [" //+ bean.getClass().getName() +
	//						"] is not eligible for getting processed by all BeanPostProcessors " +
	//						"(for example: not eligible for auto-proxying)");
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// 根据实现PriorityOrdered、Ordered、均未实现进行分组
	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);
		}
	}

	// 首选注册priorityOrderedPostProcessors中实现了PriorityOrdered的BeanPostProcessor
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// 接下来注册orderedPostProcessors中实现Ordered的BeanPostProcessor
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	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);

	// 注册所有常规nonOrderedPostProcessors
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	// 最终注册所有internalPostProcessors
	sortPostProcessors(internalPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, internalPostProcessors);

	// 将ApplicationListenerDetector添加到尾端
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

initMessageSource

初始化MessageSource，通常用来做国际化，注册bean名称必须为“messageSource”。

	protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 判断是否存在beanName为“messageSource”的BeanDefinition
		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());
				}
			}
			// 部分省略
		}
		else {
			// 默认设置空DelegatingMessageSource来注册一个名为“messageSource”的单例bean
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			// 部分省略
		}
	}

initApplicationEventMulticaster()

初始化事件Multicaster。

	protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// APPLICATION_EVENT_MULTICASTER_BEAN_NAME = applicationEventMulticaster
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			// 部分省略
		}
		else {
			
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			// 部分省略
		}
	}

onRefresh()

空方法，通过重写的方式做额外扩展。

registerListeners()

注册监听。

	protected void registerListeners() {
		// 首先注册指定监听
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

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

总结

本文我们阅读了refresh()核心方法的其中八个方法：

  1. prepareBeanFactory(beanFactory)：配置标准上下文特征。
  2. postProcessBeanFactory(beanFactory)：空方法，可以在所有bean未被加载实例化前做一些前置处理或其他动作进行额外扩展。
  3. invokeBeanFactoryPostProcessors(beanFactory)：实例化并调用所有已注册的BeanFactoryPostProcessor bean。
  4. registerBeanPostProcessors(beanFactory)：实例化和注册所有的BeanPostProcessor bean。
  5. initMessageSource：初始化MessageSource。
  6. initApplicationEventMulticaster()：初始化ApplicationEventMulticaster。
  7. onRefresh()：空方法，可以被重写以添加上下文特定的刷新工作。在特殊bean初始化时，在单例实例化之前调用。
  8. registerListeners()：注册实现ApplicationListener作为侦听器的bean。
人生逆旅我亦行人
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring容器的初始化流程
紫焱
01-19 845
文章目录一、创建BeanFactory流程1、流程入口2、流程分析二、加载BeanDefeation流程1、流程入口2、流程图3、流程分析三、创建Bean流程1、流程入口2、流程图3、流程分析 一、创建BeanFactory流程 1、流程入口 创建BeanFactory的流程是从refresh方法的第二步开始的，通过调用obtainFreshBeanFactory方法完成流程。 Configura...
spring容器初始化
weixin_42090162的博客
10-11 495
*1、SpringBoot启动过程 创建 SpringApplication ○ 保存一些信息。 ○ 判定当前应用的类型。ClassUtils。Servlet ○ bootstrappers：初始启动引导器（List）：去spring.factories文件中找 org.springframework.boot.Bootstrapper ○ 找 ApplicationContextInitializer；去spring.factories找 ApplicationContextInitializer ■ L
powerdesign怎么画分析类图_Spring容器是怎么初始化的
weixin_39854070的博客
11-20 212
Spring容器是怎么初始化的原创声明本人署名原创文章，未经许可不支持转载。本公众号所有文章均原创，为了容易理解和记忆，文章以图解为主、代码为辅。如果您感兴趣，欢迎关注！文/吴潇(Java Senior)本文分析Spring容器初始化过程。在Spring Framework中，所有类型的容器都是由ApplicationContext接口表示的，而AbstractApplicationContext...
spring 容器初始化
weixin_39768264的博客
09-30 173
1、ApplicationContext实现 BeanFactory 实例 实体类 public class Car { private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = i...
Spring容器初始化
有志者一定行
10-21 2449
一，容器初始化 1，在web.xml中配置ContextLoaderListener     这个监听器实现了ServletContextListener,这个接口有2个方法。     public void contextInitialized ( ServletContextEvent sce );     public void contextDestroyed ( ServletC
深入解析Spring IoC源码：核心机制与实践应用
最新发布
12-13
本文将深入剖析Spring IoC容器的源码，揭示其工作原理，以便开发者能够更好地理解和运用这一强大的工具。 一、Spring IoC容器的初始化 1. **实例化容器**：容器的起点通常是`AnnotationConfigApplicationContext`...
Spring IOC容器实现分析.pdf 下载
03-01
本文将深入剖析Spring的IOC容器，理解其工作原理和重要功能，以帮助开发者更好地利用这一强大的工具。 一、IOC容器的概念 IOC，即控制反转，是面向对象编程中的一个设计原则，它的主要思想是将对象的创建和管理权...
Java进阶之SpringIoC源码深度剖析共19页.pd
11-20
【标题】"Java进阶之SpringIoC源码深度剖析共19页.pd" 提供的是一项关于Java开发中的高级主题，特别是针对Spring框架的依赖注入（Inversion of Control，IoC）部分的深入研究。Spring IoC是Spring框架的核心特性之一...
马士兵Spring源码剖析文档
12-21
**IoC容器**是Spring的核心特性，它反转了控制权，使得应用程序不再负责对象的创建和管理，而是由容器来负责。IoC通过依赖注入（Dependency Injection，DI）实现，允许开发者声明所需依赖，而无需显式地在代码中创建...
spring源码视频教程
05-22
从Bean的创建过程，到AOP的织入机制，再到IoC容器的工作流程，每个环节都将逐一剖析，使开发者能更好地利用Spring优化自己的项目。通过学习，你将能够掌握Spring框架的精髓，提升你的后端开发技能。
（一）Spring容器初始化
u012417552的专栏
08-10 518
Spring的核心功能就是容器功能，用于存放bean的容器。这里有几个概念需要清楚：什么是容器什么又是bean？bean我们可以理解为系统中的类实例对象，而容器在Spring中就是BeanFactory的实现类。 1. 首先定义Spring容器 我们有两种方式配置Spring容器，一种是xml配置方式，一种是java配置方式（一般是结合使用） // 1. xml配置方式初始化容器 Appl...
Spring容器初始化过程
qq_27127145的博客
12-05 433
一、Spring 容器高层视图 Spring启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化Bean，装配好Bean之间的依赖关系，为上层应用提供准备就绪的运行环境。 二、内部工作机制 该图描述了Spring容器从加载配置文件到创建出一个完整Bean的作业流程： １、ResourceLoader从存储介质中加...
spring容器的初始化过程
m0_52383454的博客
01-07 496
refreshBeanFactory()方法中，它销毁了原有的bean工厂，并创建了新的bean工厂，并且加载并解析了配置文件中的bean的配置信息，但这一步并没有将bean实例化。prepareRefresh函数，主要做了一些容器刷新之前的配置工作，如：配置容器启动时间，配置容器状态，检查配置文件，创建事件监听器容器，创建存储事件的容器。这个方法的作用是调用所有的beanFactory的后置处理器，来执行一些beanFactory创建完成之后的工作。属性后置处理器，是处理那些添加了注解的属性的处理器。
spring容器初始化过程
cph1022xp的专栏
12-11 111
https://javadoop.com/post/spring-ioc spring容器最顶层接口 beanfactory定义了spring容器最顶层的接口，它定义了spring容器的最基本的接口，定义的规范比较基础，没有实现AOP功能、web应用等。而applicationContext则是有beanfactory衍生而来，以一种更向面向框架的方式工作以及对上下文进行分层和实现继承，通常比b...
Spring容器初始化全过程
一只蜗牛的博客
04-16 6024
spring容器主要有三种初始化方式，xml；注解；JavaConfig+注解形式，这里以目前最前卫的JavaConfig初始化方式来解读整个容器的初始化。（毕竟spring官方都强烈建议这种初始化方式，但可悲的是，国内的大部分中小企业还是使用传统的xml...） AnnotationConfigApplicationContext context = new AnnotationConfigA...
Spring源码（二）Spring容器初始化
weixin_39997751的博客
09-28 526
了解完整的专栏内容，请点击跳转： Spring Framework专栏导航页 为了阐述得简要些，以下几篇内容都侧重于介绍注解方式的Spring容器，XML方式的略过。 什么是Spring容器 微观来说这个容器就是存储bean的Map，宏观来说（一般来说）是指ApplicationContext或者Spring框架的概念。 我们知道Spring是基于Ioc原理来管理我们的bean，让程序员解放双手，使对象的创建和使用不再犯难。 所以，Spring在启动的时候，会把我们用注解标识的bean都创建好并存起来，这个
spring容器初始化流程
qq_43147121的博客
02-09 257
今天整理一下我对于spring容器初始化的理解，首先要明白什么是spring容器 在我看来spring容器就是spring所有组件的集合。 首先我们看一下加载配置文件的类都做了什么 public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { this(); this.register...
Spring容器初始化（2）
07-04 209
11. 初始化容器中所有非类加载的类// Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory);设置转换服务，日期转换，钱币转换等等，设置占位符解析器，初始化LoadTimeWeaverAware类型的类，在容器中设置冻结配置的标志，缓存所有bean定义元...
spring 容器初始化流程
phenix_egg的专栏
03-05 327
上图是我看spring容器初始化源码的思维导图，转载YurBatman大神的总结，写的很好，要多读好几遍。 1、prepareRefresh()刷新前的预处理; 0）、this.closed.set(false)，this.active.set(true) 设置一些标记位 1）、initPropertySources()初始化一些属性设置;(交由子类去实现，比如we...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

人生逆旅我亦行人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值