Spring-IoC注入过程

最新推荐文章于 2021-12-09 11:39:10 发布
最新推荐文章于 2021-12-09 11:39:10 发布
阅读量802 收藏 2
点赞数
分类专栏： java spring 源码 文章标签： java 源码 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ellen_Tangxiang/article/details/90691279
版权
java 同时被 3 个专栏收录
17 篇文章 0 订阅
订阅专栏
spring
7 篇文章 0 订阅
订阅专栏
源码
6 篇文章 0 订阅
订阅专栏
本文基于spring5.1.6

一、大体流程

  1. 使用ResourceLoader加载资源
  2. 创建Bean工厂
  3. 获得BeanDefinition
  4. 装载资源
    资源定位、装载、注册
    装载。装载就是 BeanDefinition 的载入
//加载资源
ClassPathResource resource = new ClassPathResource("bean.xml");
//创建bean工厂
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//xml解析器
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
//装载资源
reader.loadBeanDefinitions(resource);

不理解资源解析的请参考Spring-Resource源码解析

1.1 new XmlBeanDefinitionReader(factory)其实是调用的父类的构造方法

关系

public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader,EnvironmentCapable
public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader

关系图

1.2AbstractBeanDefinitionReader

  1. 创建对象就是初始化资源加载器和环境的过程
protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	this.registry = registry;

	// 确定加载器如果BeanDefinitionRegistry是一个资源加载器，那么就使用它作为加载器，否则使用路径匹配加载器
	if (this.registry instanceof ResourceLoader) {
		this.resourceLoader = (ResourceLoader) this.registry;
	}
	else {
		this.resourceLoader = new PathMatchingResourcePatternResolver();
	}

	//EnvironmentCapable：Spring中所有的应用上下文类都实现了此接口。这个接口的主要作用是用于类型检查的
	if (this.registry instanceof EnvironmentCapable) {
		this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
	}
	else {
		this.environment = new StandardEnvironment();
	}
}

环境类Environment

/**
*	环境的一些参数
*/
public interface Environment extends PropertyResolver {
	//获取激活的配置
	String[] getActiveProfiles();
	//默认的配置
	String[] getDefaultProfiles();
	//废弃的方法通过字符串的配置判断是否可以使用该配置
	@Deprecated
	boolean acceptsProfiles(String... profiles);
	//通过Profiles对象判断是否可以使用该配置
	boolean acceptsProfiles(Profiles profiles);

}

public interface PropertyResolver {

	boolean containsProperty(String key);
	//获取参数
	@Nullable
	String getProperty(String key);
	//获取参数，如果为空，返回默认值
	String getProperty(String key, String defaultValue);
	//返回指定的对象的字节码对象
	@Nullable
	<T> T getProperty(String key, Class<T> targetType);
	//返回指定的对象的字节码类，如果为空返回默认值
	<T> T getProperty(String key, Class<T> targetType, T defaultValue);
	//获取要求的参数
	String getRequiredProperty(String key) throws IllegalStateException;
	//获取要求的参数的对象的字节码对象
	<T> T getRequiredProperty(String key, Class<T> targetType) throws IllegalStateException;
	//解析占位符
	String resolvePlaceholders(String text);
	//解析要求的占位符
	String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;

}

1.3加载过程

loadBeanDefinitions会将资源进行编码，然后执行的是下面的代码

将encodedResource放入Set，去重
将encodedResource转成流并且将Resource对象传入doLoadBeanDefinitions，详见1.4源码

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	Assert.notNull(encodedResource, "EncodedResource must not be null");
	if (logger.isTraceEnabled()) {
		logger.trace("Loading XML bean definitions from " + encodedResource);
	}
	//resourcesCurrentlyBeingLoaded是一个ThreadLocal对象
	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	//如果是空的，那么就初始化一个set
	if (currentResources == null) {
		currentResources = new HashSet<>(4);
		this.resourcesCurrentlyBeingLoaded.set(currentResources);
	}
	//如果set集合添加不进去，那么抛出异常,说明已经加载过了，防止重复加载
	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());
			}
			//见下方源码1.4
			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()) {
			//ThreadLocal必须要remove掉，防止线程池下的线程复用
			this.resourcesCurrentlyBeingLoaded.remove();
		}
	}
}

1.4doLoadBeanDefinitions方法

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

	try {
		//获取Document 实例
		Document doc = doLoadDocument(inputSource, resource);
		//注册到ioc容器中详见1.5
		int count = registerBeanDefinitions(doc, resource);
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + count + " bean definitions from " + resource);
		}
		return count;
	}
	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);
	}
}

1.5 registerBeanDefinitions

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	//利用反射创建对象详见1。6
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	//registry是不是有点眼熟XmlBeanDefinitionReader extends AbstractBeanDefinitionReader
	//在创建XmlBeanDefinitionReader的时候初始化了registry和environment
	//也就是DefaultListableBeanFactory 
	//获取容器总数量
	int countBefore = getRegistry().getBeanDefinitionCount();
	//将Resource包装成XmlReaderContext详见1.7
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	//返回成功的个数beanDefinitionMap新增的数量
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

1.6 instantiateClass

public static <T> T instantiateClass(Class<T> clazz) throws BeanInstantiationException {
	Assert.notNull(clazz, "Class must not be null");
	//如果是接口，抛出异常
	if (clazz.isInterface()) {
		throw new BeanInstantiationException(clazz, "Specified class is an interface");
	}
	try {
		//如果不是接口，根据反射实例化对象
		return instantiateClass(clazz.getDeclaredConstructor());
	}
	catch (NoSuchMethodException ex) {
		Constructor<T> ctor = findPrimaryConstructor(clazz);
		if (ctor != null) {
			return instantiateClass(ctor);
		}
		throw new BeanInstantiationException(clazz, "No default constructor found", ex);
	}
	catch (LinkageError err) {
		throw new BeanInstantiationException(clazz, "Unresolvable class definition", err);
	}
}

1.7registerBeanDefinitions

@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	//详见1.8
	doRegisterBeanDefinitions(doc.getDocumentElement());
}

1.8doRegisterBeanDefinitions

@SuppressWarnings("deprecation")  // for Environment.acceptsProfiles(String...)
protected void doRegisterBeanDefinitions(Element root) {
	//解析器
	BeanDefinitionParserDelegate parent = this.delegate;
	//this.delegate重新指向新的delegate
	this.delegate = createDelegate(getReaderContext(), root, parent);
	//根节点是否为默认的命名空间，node.getNamespaceURI()为空
	//或者为BeanDefinitionParserDelegate.BEANS_NAMESPACE_URI
	//"http://www.springframework.org/schema/beans"
	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.isDebugEnabled()) {
					logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}
	//什么都没做，需要子类来实现
	preProcessXml(root);
	//解析BeanDefinitions，详见1.9parseBeanDefinitions
	parseBeanDefinitions(root, this.delegate);
	//什么都没做，需要子类来实现
	postProcessXml(root);

	this.delegate = parent;
}

1.9parseBeanDefinitions

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;
				if (delegate.isDefaultNamespace(ele)) {
					//处理默认的元素
					parseDefaultElement(ele, delegate);
				}
				else {
					//处理自定义的元素
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		//处理自定义的元素
		delegate.parseCustomElement(root);
	}
}

2.0 parseDefaultElement处理默认的元素

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	//import标签
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	//alias标签
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	//bean标签
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		//2.2processBeanDefinition
		processBeanDefinition(ele, delegate);
	}
	//beans标签
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		//调用1.9的方法继续往下解析即解析bean
		doRegisterBeanDefinitions(ele);
	}
}

2.1parseCustomElement处理客户自定义的元素

@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	String namespaceUri = getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	}
	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
	if (handler == null) {
		error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
		return null;
	}
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

2.2 processBeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	//解析ele并且将bean封装到BeanDefinitionHolder
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	//如果不为空
	if (bdHolder != null) {
		//获取属性
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 注册到IOC容器
			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));
	}
}

2.3parseBeanDefinitionElement 从xml中解析bean

@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	//获取id熟悉
	String id = ele.getAttribute(ID_ATTRIBUTE);
	//获取name熟悉
	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
	
	List<String> aliases = new ArrayList<>();
	if (StringUtils.hasLength(nameAttr)) {
		//将name属性值进行分割放入aliases中
		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		aliases.addAll(Arrays.asList(nameArr));
	}
	//将id作为beanName，也就是说，id优先级最高
	String beanName = id;
	//id不存在的时候
	if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
		//是否真的有值，把aliases的第一个元素放进来，那么把name作为beanname
		beanName = aliases.remove(0);
		if (logger.isTraceEnabled()) {
			logger.trace("No XML 'id' specified - using '" + beanName +
					"' as bean name and " + aliases + " as aliases");
		}
	}

	if (containingBean == null) {
		//检查是否唯一如果存在抛出异常，如果不存在那么缓存起来
		checkNameUniqueness(beanName, aliases, ele);
	}
	//获取beanDefinition
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
	if (beanDefinition != null) {
		//如果别名和id都为空的情况
		if (!StringUtils.hasText(beanName)) {
			try {
				//如果不为空的情况下获取beanName
				if (containingBean != null) {
					beanName = BeanDefinitionReaderUtils.generateBeanName(
							beanDefinition, this.readerContext.getRegistry(), true);
				}
				else {
					//根据上下文生成beanName
					beanName = this.readerContext.generateBeanName(beanDefinition);
					// 获取真正的java类名
					String beanClassName = beanDefinition.getBeanClassName();
					if (beanClassName != null &&
							beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
							!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
						aliases.add(beanClassName);
					}
				}
				if (logger.isTraceEnabled()) {
					logger.trace("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;
}

2.4registerBeanDefinition

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

	// 获取bean名称
	String beanName = definitionHolder.getBeanName();
	//注册到IOC容器中
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
	//注册别名
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}

2.5 registerBeanDefinition

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
		throws BeanDefinitionStoreException {
	//校验
	Assert.hasText(beanName, "Bean name must not be empty");
	Assert.notNull(beanDefinition, "BeanDefinition must not be null");

	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}
	//通过Map查询是否存在BeanDefinition
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	//如果存在
	if (existingDefinition != null) {
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		else if (existingDefinition.getRole() < beanDefinition.getRole()) {
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
			if (logger.isInfoEnabled()) {
				logger.info("Overriding user-defined bean definition for bean '" + beanName +
						"' with a framework-generated bean definition: replacing [" +
						existingDefinition + "] with [" + beanDefinition + "]");
			}
		}
		else if (!beanDefinition.equals(existingDefinition)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Overriding bean definition for bean '" + beanName +
						"' with a different definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		//如果不存在BeanDefinition
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("Overriding bean definition for bean '" + beanName +
						"' with an equivalent definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		//注册进去IOC容器
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else {
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				if (this.manualSingletonNames.contains(beanName)) {
					Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
					updatedSingletons.remove(beanName);
					this.manualSingletonNames = updatedSingletons;
				}
			}
		}
		else {
			// Still in startup registration phase
			this.beanDefinitionMap.put(beanName, beanDefinition);
			this.beanDefinitionNames.add(beanName);
			this.manualSingletonNames.remove(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

	if (existingDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}

小结

1. 将Resource转成EncodedResource设置编码
2. 通过Resource和Resource的流获取Document
3. 通过命名空间（BEANS_NAMESPACE_URI = “http://www.springframework.org/schema/beans”;）判断是否是用户自定义的xml，然后解析不同的xml（我们这里只分析默认的）
4. 根据标签解析xml，spring解析import、alias、bean、beans
5. 解析bean标签、将Element对象封装成BeanDefinitionHolder
6. 将beanName作为key，BeanDefinition作为value保存到beanDefinitionMap中
Ellen翔
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SPRING IOC注入方式过程解析
08-25
主要介绍了SPRING IOC注入方式过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring框架源码(一) 如何加载并解析spring.xml配置文件？
Dream_it_possible！的博客
12-28 1915
目录 XmlBeanFactory XmlBeanDefinitionReader DefaultBeanDefinitionDoucmentReader doRegisterBeanDefinitions BeanDefinitionParserDelegate BeanDefinitionHolder DefaultListableBeanFactory 早期我们使用Spring框架做开发时，经常会用到xml去配置bean，这些bean首先在xml文件里配置好，然后由...
Spring(一) IOC原理 以及注入
qq_44630167的博客
07-09 623
1、Spring 框架概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 2、IOC 容器 （1.
面试被问烂的 Spring IOC(求求你别再问了)
weixin_34268843的博客
10-12 1735
广义的 IOC IoC(Inversion of Control) 控制反转，即“不用打电话过来，我们会打给你”。 两种实现： 依赖查找（DL）和依赖注入（DI）。 IOC 和 DI 、DL 的关系（这个 DL，Avalon 和 EJB 就是使用的这种方式实现的 IoC）： DL 已经被抛弃，因为他需要用户自己去是使用 API 进行查找资源和组装对象。即有侵入性。 DI 是 Sprin...
Spring依赖注入流程【完整版】（populateBean方法内部执行流程）
持续Java学习中
09-21 1432
本文主要讲解Spring生命周期中实例化后的方法。方法入口为populateBean(beanName, mbd, instanceWrapper)，该方法除了调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInstantiation方法（实例化后扩展接口），还会进行属性的依赖注入，即给@Bean中符合要求的字段进行属性填充。 文章目录一、DI整体流程图二、需明白知识点三、待补充知识点 一、DI整体流程图 我将具体的依赖注入步骤整理为如下的
Spring学习（二）spring ioc注入的三种方式
热门推荐
FFA(Frighting for Ambition!)
08-25 1万+
一、spring ioc注入有哪三种方式：a setter 原理 : 在目标对象中，定义需要注入的依赖对象对应的属性和setter方法；“让ioc容器调用该setter方法”，将ioc容器实例化的依赖对象通过setter注入给目标对象，封装在目标对象的属性中。 b 构造器 原理 : 为目标对象提供一个构造方法，在构造方法中添加一个依赖对象对应的参数。ioc容器解析时，实例化目标对
maven-spring-ioc
08-07
spring IoC， 使用配置文件方式配置Bean的实例化和依赖注入
Spring-Ioc时序图.png
05-14
Spring Ioc DI 时序图分享给大家，希望对大家看源码有所帮助，不足之处欢迎批评指正，可以在下方留言
Java课件-14-Spring-IoC-Course
01-10
Spring容器简介——依赖注入
Java - Spring-IoC（Inverse of Control）–> 控制反转
最新发布
03-11
依赖注入是IoC的主要实现方式 IoC的实现机制： 工厂模式 + 反射机制：工厂模式提供创建方法，通过反射获取需要加载的类的全限定名称，通过工厂加载产生需要的类对象。 ② AoP(Aspect Oriented Programing) --> 面向...
Spring IOC 原理解析
wuqihawubito的博客
12-09 740
文章目录IOC 概念IOC Service ProviderSpring 的 IOC Service ProviderBeanFactory直接编码方式示例：外部配置文件方式注解方式FactoryBean：BeanFactoryAware 接口 IOC 概念 IOC, Inversion of Control, 中文是 控制反转，还有一个别名是 dependency Injection，依赖注入。 在接触IOC之前，我们需要用到什么对象，就直接在类的构造函数里面新建相应的依赖的类 。 但是，我们每次需要用到
Spring 注入全过程图解
weixin_34253126的博客
07-31 1571
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring IOC加载全过程（转）
weixin_39713838的博客
03-04 722
本文章以ClassPathXmlApplicationContext为切入口，常用的还有ContextLoaderListener类 首先 **一般开始都是这样一句代码： ApplicationContext context = new ClassPathXmlApplicationContext(“classpath:application.xml”); 1 意思是加载xml文件创建一个A...
Spring源代码之bean的基本解析
kopshome的专栏
01-15 1918
先看这样一段儿代码:spring bean xml配置<?xml version="1.0" encoding="UTF-8"?> <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:sche
4、【死磕 Spring】—— IoC 之加载 BeanDefinition（转译）
a1290123825的博客
01-31 177
先看一段熟悉的代码： ClassPathResource resource = new ClassPathResource("bean.xml"); // <1> DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); // <2> XmlBeanDefinitionReade...
spring源码学习之路---IOC容器初始化要义之bean定义载入（五）
v5browser
03-10 106
作者：zuoxiaolong8810（左潇龙），转载请注明出处。 最近工作很忙，时间不多，研究spring的进度被严重拖下来，不过我会一直坚持写完。 上章说到要带各位去看看bean定义载入的要义，其实就是loadBeanDefinitions这个方法的具体实现步骤，下面我们跟随这个方法去看下它到底是如何载入bean定义的。 上面是我截取的实现了loadBeanDefinition...
Spring源码深度解析-读取配置文件
u010327957的博客
10-28 633
目录1. 加载配置文件的入口XmlBeanFactory2. applicationContext.xml被封装成一个ClassPathResource类型的对象3. XmlBeanDefinitionReader读取ClassPathResource类型的对象 1. 加载配置文件的入口XmlBeanFactory 2. applicationContext.xml被封装成一个ClassPathR...
Spring源码学习【二】IOC容器的初始化（二）BeanDefinition载入
一颗贪婪的星
07-25 1187
目录 一、总览 二、源码分析 （一）获取Document （二）解析Document 一、总览 经过前一篇（Spring源码学习【二】IOC容器的初始化（一）Resource定位）的分析，我们对IOC容器的初始化过程已经有了一定的了解。IOC的初始化由refresh()方法启动，最终对Resource的载入是由XmlBeanDefinitionReader处理的。参考上一节中6.loa...
Spring源码解析——从XmlBeanFactory的构造函数开始看LoadBeanDefinitions
weixin_34010566的博客
05-10 146
之前的文章聊过ClassPathResource类，通过这个类，我们从classpath加载到了我们的spring配置文件，之后，就开始执行XmlBeanFactory的构造过程了： public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)...
Spring Ioc依赖注入
08-16
Spring IOC (Inversion of Control) 是一种设计模式，它通过将对象的创建、管理和依赖注入的职责交给容器来实现。依赖注入是IOC的一种实现方式，它通过容器自动将依赖对象注入到需要它们的对象中。 在Spring中，IOC...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值