Spring源码分析(1)--Spring初始化(注册)

最新推荐文章于 2020-11-18 18:22:52 发布
最新推荐文章于 2020-11-18 18:22:52 发布
阅读量185 收藏
点赞数
分类专栏： spring源码学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oqqLai123456/article/details/103328563
版权

Note：spring源码版本5.0.2Release

基于ClassPathXmlApplicationContext的BeanDefinition注册过程

	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

学习Spring时我相信大部分人的第一个实例就是这样的，那就看看在实例化ClassPathXmlApplication时 spring都干了些什么事情吧。

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
	super(parent);
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

跟踪进去之后，发现了有这么一处关键的代码，那就一个方法一个方法看看他们究竟干了什么。

首先是super(parent)，看看它干了些什么事情

//org.springframework.context.support.AbstractApplicationContext
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
		this();
		setParent(parent);
}	


public AbstractApplicationContext() {
		this.resourcePatternResolver = getResourcePatternResolver();
}

protected ResourcePatternResolver getResourcePatternResolver() {
		return new PathMatchingResourcePatternResolver(this);
}

可以看到，这个方法主要是将AbstractApplicationContext中的属性resourcePatternResolver 设置为PathMatchingResourcePatternResolver

@Override
public void setParent(@Nullable ApplicationContext parent) {
	this.parent = parent;
	if (parent != null) {
		Environment parentEnvironment = parent.getEnvironment();
		if (parentEnvironment instanceof ConfigurableEnvironment) {
			getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
		}
	}
}

由于parent传递为空值，因此这个方法什么也没干。

好，继续看ClassPathXmlApplicationContext中的setConfigLocations方法

org.springframework.context.support.AbstractRefreshableConfigApplicationContext
public void setConfigLocations(@Nullable String... locations) {
	if (locations != null) {
		Assert.noNullElements(locations, "Config locations must not be null");
		this.configLocations = new String[locations.length];
		for (int i = 0; i < locations.length; i++) {
			this.configLocations[i] = resolvePath(locations[i]).trim();
		}
	}
	else {
		this.configLocations = null;
	}
}

他其实调的是超类AbstractRefreshableConfigApplicationContext的方法，而这个方法最重要的一步就是resolvePath，可以看看它干了什么事情

protected String resolvePath(String path) {
	return getEnvironment().resolveRequiredPlaceholders(path);
}

@Override
public ConfigurableEnvironment getEnvironment() {
	if (this.environment == null) {
		this.environment = createEnvironment();
	}
	return this.environment;
}
protected ConfigurableEnvironment createEnvironment() {
	return new StandardEnvironment();
}

可以看到，resolvePath其实就是创建了一个Environment对象，并调用该对象的resolveRequiredPlaceholders，而这个方法就是将所传入的string(如果有${key})解析为对应的value(获取环境变量中的值)。为了验证这个方法，来一个demo

@Test
public void test(){
	Environment environment = new StandardEnvironment();
	String javaHome1 = environment.resolveRequiredPlaceholders("${java.home}");
	String javaHome2 = environment.resolveRequiredPlaceholders("java.home");
	System.out.println(javaHome1);
	System.out.println(javaHome2);
}

以下为输出结果

C:\software\Java\jdk1.8.0_191\jre
java.home

因此不难明白setConfigLocations方法的左右了，具体就是将类AbstractRefreshableConfigApplicationContext的字段configLocations设置为输入的值，如果有占位符，则进行解析

接下来就是最重要的方法了org.springframework.context.support.AbstractApplicationContext#refresh()

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		prepareRefresh();
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		//以下省略
		...
}

首先观察prepareRefresh方法

protected void prepareRefresh() {
	this.startupDate = System.currentTimeMillis();
	this.closed.set(false);
	this.active.set(true);
	if (logger.isInfoEnabled()) {
		logger.info("Refreshing " + this);
	}
	initPropertySources();
	getEnvironment().validateRequiredProperties();
	this.earlyApplicationEvents = new LinkedHashSet<>();
}

这个主要记录spring初始化的开始时间，closed、active标志位状态。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//刷新beanFactory，如果已存在BeanFactory则销毁，不存在则创建，并且扫描配置文件，注册BeanDefinition
	//BeanDefinition就在这一步生成并注册到BeanFactory中
	refreshBeanFactory();
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}
//refreshBeanFactory是一个抽象方法，调用的为子类 AbstractRefreshableApplicationContext的实现
@Override
protected final void refreshBeanFactory() throws BeansException {
	//if代码段不影响整体流程，具体可以先跳过
	if (hasBeanFactory()) {
		//清空beanFactory中缓存的数据
		destroyBeans();
		//beanFactroy 置空
		closeBeanFactory();
	}
	try {
		//实例化beanFactory对象
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		//设置BeanFactory的属性：BeanDefinition是否可以被覆盖，是否可以循环引用(将applicationContext中的对应属性设置上去)
		customizeBeanFactory(beanFactory);
		//这一步进行BeanDefinition的注册
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

org.springframework.context.support.AbstractRefreshableApplicationContext
protected DefaultListableBeanFactory createBeanFactory() {
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

接下来看loadBeanDefinitions(beanFactory)方法，而它是一个抽象方法，具体有4个实现
在这里插入图片描述
而ClassPathXmlApplicationContext的继承体系为
在这里插入图片描述
因此具体看org.springframework.context.support.AbstractXmlApplicationContext中的方法

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
	//为BeanFactory创建一个XmlBeanDefinitionReader，读取xml文件，读取xml文件，生成Document对象
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
	//beanDefinitionReader对象的初始化过程
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
	initBeanDefinitionReader(beanDefinitionReader);
	//加载xml配置文件中的bean定义
	loadBeanDefinitions(beanDefinitionReader);
}

注意方法beanDefinitionReader.setResourceLoader(this)，this代表的是ClassPathXmlApplicationContext对象，而ClassPathXmlApplicationContext集成了DefaultResourceLoader类，之后会用到这个ResourceLoader
在这里插入图片描述
接着看代码

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	//根据给定的配置文件，循环配置文件，进行BeanDefinition的解析、加载
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	//configLocations 为加载spring xml配置文件时输入的文件路径
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations);
	}
}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader
@Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
	Assert.notNull(locations, "Location array must not be null");
	int counter = 0;
	for (String location : locations) {
		counter += loadBeanDefinitions(location);
	}
	return counter;
}

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws 		                             BeanDefinitionStoreException {
	//由于resourceLoader = DefaultResourceLoder，因此走下面的流程
	ResourceLoader resourceLoader = getResourceLoader();
	...省略
	if (resourceLoader instanceof ResourcePatternResolver) {
		...省略
	}
	else {
		// Can only load single resources by absolute URL.
		Resource resource = resourceLoader.getResource(location);
		int loadCount = loadBeanDefinitions(resource);
		if (actualResources != null) {
			actualResources.add(resource);
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
		}
		return loadCount;
	}
}

org.springframework.beans.factory.xml.XmlBeanDefinitionReader
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
	return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
	...省略
	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	if (currentResources == null) {
		currentResources = new HashSet<>(4);
		this.resourcesCurrentlyBeingLoaded.set(currentResources);
	}
	if (!currentResources.add(encodedResource)) {
		throw new BeanDefinitionStoreException(
				"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
	}
	try {
		InputStream inputStream = encodedResource.getResource().getInputStream();
		try {
			InputSource inputSource = new InputSource(inputStream);
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			//主要看这个方法
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		}
		finally {
			inputStream.close();
		}
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(
				"IOException parsing XML document from " + encodedResource.getResource(), ex);
	}
	finally {
		currentResources.remove(encodedResource);
		if (currentResources.isEmpty()) {
			this.resourcesCurrentlyBeingLoaded.remove();
		}
	}
}


protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
	try {
		Document doc = doLoadDocument(inputSource, resource);
		return registerBeanDefinitions(doc, resource);
	}
	catch (BeanDefinitionStoreException ex) {
		throw ex;
	}
	catch (SAXParseException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
	}
	catch (SAXException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"XML document from " + resource + " is invalid", ex);
	}
	catch (ParserConfigurationException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Parser configuration exception parsing XML from " + resource, ex);
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"IOException parsing XML document from " + resource, ex);
	}
	catch (Throwable ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Unexpected exception parsing XML document from " + resource, ex);
	}
}

doLoadDocument使用java自带的xml解析器，将xml文件解析为Document对象；

org.springframework.beans.factory.xml.XmlBeanDefinitionReader
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	int countBefore = getRegistry().getBeanDefinitionCount();
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	logger.debug("Loading bean definitions");
	Element root = doc.getDocumentElement();
	doRegisterBeanDefinitions(root);
}

protected void doRegisterBeanDefinitions(Element root) {
		// Any nested <beans> elements will cause recursion in this method. In
		// order to propagate and preserve <beans> default-* attributes correctly,
		// keep track of the current (parent) delegate, which may be null. Create
		// the new (child) delegate with a reference to the parent for fallback purposes,
		// then ultimately reset this.delegate back to its original (parent) reference.
		// this behavior emulates a stack of delegates without actually necessitating one.
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);

	//此处针对文件的profile属性起作用  如果当前环境为profile=default，则解析xml文件时不再解析非default profile的文件
	if (this.delegate.isDefaultNamespace(root)) {
		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
		if (StringUtils.hasText(profileSpec)) {
			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
				if (logger.isInfoEnabled()) {
					logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}

	preProcessXml(root);
	parseBeanDefinitions(root, this.delegate);
	postProcessXml(root);

	this.delegate = parent;
}

此方法中的if代码段实现的功能是profile切换。如果配置文件如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
	<beans profile="default" >
		<bean class="test.User" id="user">
			<property name="name" value="profile_default"/>
			<property name="javaHome" value="${java.home}"/>
		</bean>
	</beans>
	<beans profile="test">
		<bean class="test.User" id="user">
			<property name="name" value="profile_test"/>
			<property name="javaHome" value="${user.name}"/>
		</bean>
	</beans>
</beans>

当当前的profile为default时，则会解析<bean profile="default">中的内容，而跳过<bean profile="test">中的内容。具体spring的profile怎么使用，请点击查看
而doRegisterBeanDefinitions中调用的 preProcessXml(root)、postProcessXml(root) 是2个空方法，接着继续往下看

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	if (delegate.isDefaultNamespace(root)) {
		NodeList nl = root.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (node instanceof Element) {
				Element ele = (Element) node;
				//当获得的element标签为bean下的命名空间时，进入此代码段
				if (delegate.isDefaultNamespace(ele)) {
					parseDefaultElement(ele, delegate);
				}
				else {
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	//ji
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);
	}
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// recurse
		doRegisterBeanDefinitions(ele);
	}
}

这里我们着重看当元素标签为bean时，spring时如何解析的

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// Register the final decorated instance.
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// Send registration event.
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
	return parseBeanDefinitionElement(ele, null);
}

@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	String id = ele.getAttribute(ID_ATTRIBUTE);
	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
	List<String> aliases = new ArrayList<>();
	if (StringUtils.hasLength(nameAttr)) {
		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		aliases.addAll(Arrays.asList(nameArr));
	}
	String beanName = id;
	if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
		beanName = aliases.remove(0);
		if (logger.isDebugEnabled()) {
			logger.debug("No XML 'id' specified - using '" + beanName +
					"' as bean name and " + aliases + " as aliases");
		}
	}
	if (containingBean == null) {
		checkNameUniqueness(beanName, aliases, ele);
	}
	//
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
	if (beanDefinition != null) {
		if (!StringUtils.hasText(beanName)) {
			try {
				if (containingBean != null) {
					beanName = BeanDefinitionReaderUtils.generateBeanName(
							beanDefinition, this.readerContext.getRegistry(), true);
				}
				else {
					beanName = this.readerContext.generateBeanName(beanDefinition);
					// Register an alias for the plain bean class name, if still possible,
					// if the generator returned the class name plus a suffix.
					// This is expected for Spring 1.2/2.0 backwards compatibility.
					String beanClassName = beanDefinition.getBeanClassName();
					if (beanClassName != null &&
							beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
							!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
						aliases.add(beanClassName);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Neither XML 'id' nor 'name' specified - " +
							"using generated bean name [" + beanName + "]");
				}
			}
			catch (Exception ex) {
				error(ex.getMessage(), ele);
				return null;
			}
		}
		String[] aliasesArray = StringUtils.toStringArray(aliases);
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}

	return null;
}

可以看到，这个方法主要就是根据xml配置文件中<bean>标签的内容生成对应的BeanDefinition对象，返回BeanDefinition、beanName、aliasersArray的封装对象 BeanDefinitionHolder，之后代码会走到BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())

public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {

	// Register bean definition under primary name.
	String beanName = definitionHolder.getBeanName();
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	// Register aliases for bean name, if any.
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}

spring的beanDefinition注册流程完毕 ~

徐by小宝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring源码分析-Spring核心类认识（一）
yqx1714768514的博客
01-08 735
相信每个Java程序员都使用过Spring这个框架，Spring不仅作用于服务器端的开发，从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益，如今的Spring全家桶已经是风靡全球，深受广大程序员的喜爱，本系列文章将带你一步步窥探Spring核心。
Spring Boot源码解析（一）SpringApplication初始化
DevCampsite的博客
08-18 598
Spring Boot 源码解读之SpringApplication初始化
springboot启动流程
findbestoy的专栏
03-30 2633
SpringBoot启动流程 一句话总结：在context的refresh方法中，需要注册bean definition，实例化bean.在加载bean defintion的时候使用ConfigurationClassParser类来解析我们的主类。然后在解析主类的时候发现了@EnableAutoConfiguratio注解中的@Import注解，就去处理@Import注解中的value值，然后...
Spring Environment 源码解析
li11359713的博客
08-04 508
总所周知，Spring IOC 是通过调用 AbstractApplicationContext.refresh() 方法进行初始化的，但是 Spring 在调用 refresh()方法之前，先会调用 AbstractRefreshableConfigApplicationContext.setConfigLocations() 方法来处理配置文件数组，解析后的配置文件地址又需要写入 Spring 的Environment，因此 Spring会在这一步通过 AbstractApplicationCon...
第二部分-Spring容器的基本实现（一）- spring的简单使用以及源码中设置配置路径和标准环境
u011709128的专栏
06-29 660
Spring容器的基本实现 在开始分析源码之前，我们来回顾一下Spring的最简单的用法，我们来构建一个小demo Spring中最简单的用法 首先我们要构建一个maven项目 构建一个空的java项目，并引入spring的jar包，如下图： &amp;amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;groupId&
spring学习（十一）——spring官方文档阅读（5.0.7）——环境抽象
菜到怀疑人生的博客
08-26 211
环境抽象 profile允许在不同的环境下注册使用不同的bean，举个例子，我们在生产环境使用JNDI配置数据源，在测试环境使用in-memory的数据源，我们先实现这两种方法： in-memory的datasource： @Bean public DataSource dataSource() { return new EmbeddedDatabaseBuilder() ...
Spring源码学习10
大脸猫的博客
07-18 163
1.ApplicationContext ac = new ClassPathXmlApplicationContext("anComplexBeanTest.xml") /** * 使用给定父级创建新的ClassPathXmlApplicationContext， * 从给定的XML文件加载定义 * @param configLocations array of resource...
Spring 源码分析（Bean的初始化）
12-21
本篇文章主要分析了Spring如何通过`ClassPathXmlApplicationContext`来启动和初始化Bean的过程。 首先，`ClassPathXmlApplicationContext`是Spring的一种ApplicationContext实现，用于从类路径下的XML配置文件加载...
Spring Boot源码（spring-boot-2.6.2.zip）
01-07
1. `org.springframework.boot.SpringApplication`: 应用启动类，负责初始化Spring应用上下文。 2. `org.springframework.boot.autoconfigure.*`: 自动配置相关的类，定义了各种条件判断和bean的创建逻辑。 3. `org....
Spring Boot源码（spring-boot-2.6.2.tar.gz）
01-07
在源码中，相关的配置和初始化逻辑位于`org.springframework.boot.autoconfigure.data`包下。 对于测试，Spring Boot提供了`spring-boot-starter-test`模块，包含JUnit、Mockito等测试工具，使得单元测试和集成测试...
Spring源码学习九：DispatcherServlet初始化源码分析1
08-04
Spring源码学习九：DispatcherServlet初始化源码分析1 DispatcherServlet是SpringMVC的核心分发器，它实现了请求分发，是处理请求的入口，本篇将深入源码分析它的初始化过程。 首先，从DispatcherServlet的名称上...
Spring 5.2.9 06 源码分析-spring自定义标签解析过程
06-20
这个接口定义了两个主要方法：`init()`用于初始化命名空间处理器，以及`parseElement(Element element, ParserContext parserContext)`用于解析XML元素。 当Spring容器遇到一个自定义标签时，它会查找与该标签相关...
Spring源码深度解析总结（7）—— 容器的扩展功能
vergil小童鞋的博客
07-04 973
经过之前的分析，我们已经了解了Spring是如何解析和加载的bean的。但是在上一篇文章结束的时候说到，一般我们写程序是不会用到BeanFactory来当做Spring的容器的，一般使用的是ApplicationContext作为Spring的容器。这两者之间有什么区别呢？ApplicationContext和BeanFactory在Spring中都是用于加载bean的，但是Application...
关于Spring启动早期最先注册的六个BeanDefinition的解释
TankyZhang的博客
02-25 601
 在spring初始化的过程中会注册六个非常重要的beandefinition，他们的名字分别是： 1.org.springframework.context.annotation.internalConfigurationAnnotationProcessor 2.org.springframework.context.annotation.internalAutowiredAnnotatio...
Spring Cloud Config配置中心
lihaiyang_sz的博客
07-17 1290
Environment环境加载 Environment就是指Spring应用运行的环境信息，例如从系统变量、命令行、配置文件application.yml等文件中的信息加载之后都会保存到Environment中。 Environment的初始化 org.springframework.boot.SpringApplication#run(java.lang.String...) ConfigurableEnvironment environment = prepareEnvironment(lis
spring注册组件——@Bean的生命周期(指定初始化和销毁方法)示例
小志的博客
11-19 388
一、bean的生命周期： bean创建的过程 bean初始化的过程 bean销毁的过程 二、构造（对象创建） 单实例：在容器启动的时候创建对象 多实例：在每次获取的时候创建对象 三、bean的初始化 对象创建完成，并赋值好，调用初始化方法 四、bean的销毁 单实例：容器关闭的时候 多实例：容器不会管理这个bean；容器不会调用销毁方法 五、指定bean的初始化和销毁方法 通过@...
Spring源码解析之零 ------ 容器初始化过程(refresh()方法)概要
怪盗基德
07-03 5393
本篇主要讲解，容器初始化时候的refresh()方法里的，几个重要方法的基本作用。 首先来看一下refresh()方法。spring容器的启动，创建bean，bean的初始化等一系列过程都在这个refresh方法里面，进行调用。 public void refresh() throws BeansException, IllegalStateException { synchro
Spring创建Bean的全过程Debug，没人能说的这么通透了
程序员闪充宝
11-18 643
作者：x1aoda1https://www.cnblogs.com/darope/p/13917264.html1.1 Spring测试环境搭建Spring模块概览，绿色是模块，Spri...
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值