【Spring】Spring ioc源码学习以及关于阅读源码方式的一些小笔记

已于 2023-04-02 17:22:48 修改
阅读量270 收藏
点赞数
分类专栏： 学习时候记录的笔记 文章标签： spring 学习 java
于 2023-03-19 22:34:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41279172/article/details/129482462
版权

Spring ioc源码学习以及关于阅读源码方式的一些小笔记

学习源码的方式

最好的方法是带着问题去学习。
如果拿到的是一个新的框架源码，首先应当去搞懂如何使用，这个框架能做什么事。接下来可以采取两种方式：
第一种：

  1. 第一步了解它的核心概念有哪些，确定你要学习的目标
  2. 由整体到局部的分析，先拆分目标，这个框架为了达到这个效果做了哪些步骤
  3. 找到每个步骤对应的入口，先理清楚主干流程，再详细看具体细节
  4. 理清楚之后针对其可扩展的部分，自己编写一些代码去验证是否能实现（多折腾）

第二种：

  1. 第一步了解它的核心概念有哪些，确定你要学习的目标
  2. 自己动手去实现
  3. 自己实现完之后再对比框架源码，思考为什么源码此处要这么写

由于本人自认为水平欠佳，在阅读过程中采取的是第一种方式。

做了些什么

ioc容器最核心的功能就是帮助用户管理bean，把用户自己创建的模式改成由容器创建的模式，所以至少需要两个步骤：创建bean和获取bean。

实现的步骤

主要有如下几个步骤：

  1. 用户配置bean定义
  2. 容器读取用户配置的bean定义
  3. 容器创建bean定义
  4. 用户从容器中读取bean

首先找到加载的入口，此处以xml配置方式为例，注解方式后续补充：
xml配置方式的入口为:ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("lalala.xml");

把握整体

ApplicationContext是Spring中的高级容器，它内嵌了一个BeanFactory， ClassPathXmlApplicationContext也是ApplicaitonContext的实现类。下面是ApplicationContext的类图。

在这里插入图片描述

这里采用了设计模式中的装饰模式（有疑问，算装饰模式吗）:

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    @Nullable
    String getId();

    String getApplicationName();

    String getDisplayName();

    long getStartupDate();

    @Nullable
    ApplicationContext getParent();

    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

可以看到ApplicationContext 继承的功能有:

  • EnvironmentCapable: 获取环境相关变量
  • ListableBeanFactory: 提供BeanFactory容器
  • HierarchicalBeanFactory: 提供父子容器相关的内容
  • MessageSource: 提供国际化的内容
  • ApplicationEventPublisher： 提供事件发布机制
  • ResourcePatternResolver : 提供资源解析器

具体实现

第一次读源码的时候首先要找准一个你熟悉的过程，debug打断点，获取到它的调用栈并截图保存。 需要关注的重点是入参在这些方法中是如何变化的，从而知道每一个类是干什么用的。

接下来再将步骤拆分的细一点：

  1. 读取用户配置的xml文件
  2. 将xml树解析为beanDefinition
  3. 创建beanFactory
  4. 将beanDefinition注册到beanFactory

首先我们观察到启动时候的入参只有一个xml文件的地址:

/**
     * xml文件配置方式
     */
    private static void testClassPathXmlApplicationContext() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("lalala.xml");
        for (String beanName : context.getBeanDefinitionNames()) {
            System.out.println(beanName);
        }
        System.out.println(context.getBean(Bean2.class).getBean1());
    }

那第一步就要先将这个xml文件配置的内容解析成beanDefinition。上面提到过ResourcePatternResolver 是用来解析资源的，点开ClassPathXmlApplicationContext的类图，找到上层哪个类持有这个解析器->AbstractApplicationContext。
在这里插入图片描述
然后定位到对应的方法，再一步一步往下跟踪，能够得到如下的调用栈:

在这里插入图片描述
下面拿出一些个人认为重要的步骤进行说明:

  1. 在org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory()方法中新建了一个BeanFactory.
    它的默认类型是DefaultListableBeanFactory。
    在这里插入图片描述
  2. 在org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(DefaultListableBeanFactory beanFactory) 中新建了一个XmlBeanDefinitionReader，容器在此处将xml文件的解析过程委托给了这个XmlBeanDefinitionReader进行下一步的解析:

在这里插入图片描述
3. 在org.springframework.beans.factory.support.AbstractBeanDefinitionReader 中读取xml的内容并将其转换为Resource 对象。对于多个配置文件是进行循环读取。
在这里插入图片描述

  1. 在org.springframework.beans.factory.xml.XmlBeanDefinitionReader中有一处转换是将Resource 转化为EncodedResource
@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}
  1. 在org.springframework.beans.factory.xml.XmlBeanDefinitionReader 中开始进行注册beanDefinition的行为
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

		try {
			Document doc = doLoadDocument(inputSource, resource);
			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);
		}
	}

注册BeanDefinition的行为实际是被委托给了BeanDefinitionDocumentReader 去完成。

  1. 在org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader 中进行实际的BeanDefinition 注册过程。
protected void doRegisterBeanDefinitions(Element root) {
		BeanDefinitionParserDelegate parent = this.delegate;
		// 处理嵌套的<beans>标签
		this.delegate = createDelegate(getReaderContext(), root, parent);

		// 判断是否是默认命名空间  http://www.springframework.org/schema/beans
		if (this.delegate.isDefaultNamespace(root)) {
			// 判断运行的环境 profile属性
			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;
				}
			}
		}

		// xml的前置处理
		preProcessXml(root);
		// 处理BeanDefinition
		parseBeanDefinitions(root, this.delegate);
		// xml的后置处理
		postProcessXml(root);

		this.delegate = parent;
	}

进入parseBeanDefinitions方法:

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)) {
						// 处理默认元素 import alias bean beans
						parseDefaultElement(ele, delegate);
					}
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

下面来看看它怎么解析bean标签的:

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

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)) {
			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.isTraceEnabled()) {
				logger.trace("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);
						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;
	}

@Nullable
	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

		String className = null;
		// 获取class属性的值
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		String parent = null;
		// 获取parent属性的值
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			// 创建beanDefinition 默认的beanDefinition类型是GenericBeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			
			// 解析scope abstract lazy-init(默认为false) autowire depends-on autowire-candidate primary init-method destory-method factory-method factory-bean 属性 这里有部分属性会在populateDefaults中设置一遍
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			// 解析meta标签
			parseMetaElements(ele, bd);
			// 解析lookup-method
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			// 解析replaced-method
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			// 解析constructor-arg
			parseConstructorArgElements(ele, bd);
			// 解析property
			parsePropertyElements(ele, bd);
			// 解析qualifier
			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (ClassNotFoundException ex) {
			error("Bean class [" + className + "] not found", ele, ex);
		}
		catch (NoClassDefFoundError err) {
			error("Class that bean class [" + className + "] depends on not found", ele, err);
		}
		catch (Throwable ex) {
			error("Unexpected failure during bean definition parsing", ele, ex);
		}
		finally {
			this.parseState.pop();
		}

		return null;
	}

在org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.populateDefaults方法中会先处理如下属性内容:

protected void populateDefaults(DocumentDefaultsDefinition defaults, @Nullable DocumentDefaultsDefinition parentDefaults, Element root) {
		String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);
		if (isDefaultValue(lazyInit)) {
			lazyInit = (parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE);
		}
		defaults.setLazyInit(lazyInit);

		String merge = root.getAttribute(DEFAULT_MERGE_ATTRIBUTE);
		if (isDefaultValue(merge)) {
			merge = (parentDefaults != null ? parentDefaults.getMerge() : FALSE_VALUE);
		}
		defaults.setMerge(merge);

		String autowire = root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE);
		if (isDefaultValue(autowire)) {
			autowire = (parentDefaults != null ? parentDefaults.getAutowire() : AUTOWIRE_NO_VALUE);
		}
		defaults.setAutowire(autowire);

		if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {
			defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));
		}
		else if (parentDefaults != null) {
			defaults.setAutowireCandidates(parentDefaults.getAutowireCandidates());
		}

		if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {
			defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));
		}
		else if (parentDefaults != null) {
			defaults.setInitMethod(parentDefaults.getInitMethod());
		}

		if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {
			defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));
		}
		else if (parentDefaults != null) {
			defaults.setDestroyMethod(parentDefaults.getDestroyMethod());
		}

		defaults.setSource(this.readerContext.extractSource(root));
	}

补充一部分：

上面的parseBeanDefinitionElement 有这么两行

// 解析constructor-arg标签
parseConstructorArgElements(ele, bd);
// 解析property标签
parsePropertyElements(ele, bd);

这两个方法再继续往下调用会进入parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName)方法
在这里插入图片描述
在此处这两类标签ref属性里的值会被初始化成为RuntimeBeanReference对象，value属性里的值会被初始化为TypedStringValue对象，如果里面还有子标签，则递归处理。
然后把处理好的<constructor-arg>内容放入beanDefinition的constructorArgumentValues.genericArgumentValues属性里。
处理好的<property>标签内容会被初始化为PropertyValue对象，放入this.propertyValues属性里。

接下来回到: BeanDefinitionReaderUtils.registerBeanDefinition 方法，它内层是这样的：

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 {
				// 验证beanDefinition的完整性
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		// 判断容器中是否已经存在当前beanDefinition
		if (existingDefinition != null) {
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
			}
			else if (!beanDefinition.equals(existingDefinition)) {
			}
			else {
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				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;
					removeManualSingletonName(beanName);
				}
			}
			else {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

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

从此看出ioc容器中的BeanDefinition都存放在beanDefinitionMap中。
此时beanDefinition已经加载完成。

ps: 嵌套bean标签注入的用法:

如果某个Bean所依赖的Bean不想被Spring容器直接访问，可以使用嵌套Bean。<bean…/>元素用来定义嵌套Bean，嵌套Bean只对嵌套它的外部Bean有效，Spring容器无法直接访问嵌套Bean，因此定义嵌套Bean时无须指定id属性。

<?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:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-4.2.xsd"
>
	<bean id="chinese" class="DependencyInjection.Chinese">
		<property name="axe">
			<bean class="DependencyInjection.StoneAxe"/>
		</property>
	</bean>
</beans>

时序图如下:

在这里插入图片描述

遗留的问题

  1. EncodedResource 的作用？
  2. BeanDefinitionHolder 的作用？
  3. 解析自定义标签的时候，readContext里面的内容是从哪里来的？
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));
	}

参考资料

1.小不点啊的spring源码阅读系列文
2.注入嵌套bean的用法

wannatolive
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring ioc 源码阅读
wwj_bupt
09-21 201
阅读框架源码最好的方式，是通过一个小例子，看代码的执行顺序，这样比较容易理解过程。如果是上来就直接看某个重要类的实现，估计会迷失在代码里，这段代码用来干什么的？这个类用来干什么的？这个有什么用？东西太多了啊，类太多了啊！ 使用idea，f4进入函数实现或者变量定义，以及返回，以及ctrl+f12看类的函数列表。 所以，先从一个ioc例子看代码。 代码在https://github.com/geneRocket/spring-ioc-aop void test_ioc() { Resource
Spring AOP IOC源码笔记.pdf
05-08
本笔记将深入探讨这两个概念以及它们在Spring中的实现。 1. Spring框架简介： Spring作为一个轻量级的开源框架，旨在简化企业级应用的开发。它通过提供IOC容器，实现了对象的创建、管理和依赖注入，减轻了开发者对...
Spring IoC源码阅读
weixin_44153131的博客
09-25 259
最近在看Spring源码，本来想全部看了后写文档总结，但怕后面懒不想写，就准备先写一篇。Spring是很多模块的集合，是一款开源的轻量级 Java 开发框架，旨在简化企业开发以及提高系统的可维护性。Spring 最重要的概念是IoC 和 AoP，关于定义不再多做介绍，本文主要是介绍IoC源码部分。IoC中总体来说分为两部分，一个是创建 Bean 容器，一个是初始化 Bean。全文的流程关系主要如下图所示，该图来自于马士兵教育Spring公开课。
spring Ioc源码阅读
qq_31443653的博客
04-17 275
源码阅读 spring core ioc 类名关系 子主题 1 factory关系 aop ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:aop02.xml"); Mat math = ctx.getBean("math", Mat.class); Abstract...
Spring源码阅读一——IOC
张硕的博客
11-26 1114
什么是IOC? Inversion of Control (IoC) (DI). It is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a
Spring源码编译及阅读源码入门
个人站点：javatv.net
10-24 2836
我为什么要去读源码 首先说明我并不是什么大佬，普普通通小开发一枚，那为什么我要去读源码呢？ 其实不管是 Spring 还是 JDK 的源码，如果我们想要称为更高阶的开发者，阅读源码是必经阶段，第一可以提高自己的代码能力，因为个人觉得写好代码的最好方式就是看别人怎么写代码并学习，第二是提升自己后找到更好的工作，如果我们去看大厂的招聘要求基本都是要精通 S.
Spring高级源码学习笔记.zip
05-24
在阅读Spring源码笔记时，建议结合实际项目经验，逐步理解并实践源码中的关键概念。"查看密码，打开必看.txt"可能是提供解压文件的密码，确保正确解压并阅读PDF文档，以获得完整的知识体系。 总之，Spring源码学习...
Spring学习笔记&源码
12-14
本资料“Spring学习笔记&源码”是基于网易云课堂黑马程序员的Spring四天精通课程，旨在帮助学习者深入理解和实践Spring框架。 笔记部分可能会涵盖以下内容： 1. **Spring概述**：介绍Spring框架的历史、特点和主要...
spring高级源码笔记.pdf
09-05
通过阅读源码，开发者可以了解如何实现DI和AOP，以及Spring如何优雅地管理对象和处理各种框架的集成。对于初入IT行业的人员来说，这是一条理解高级技术、提升专业素养的有效途径。在阅读过程中，做笔记是非常重要的...
Spring IOC源码剖析：Spring IOC容器初始化主体流程
丿涛哥哥的博客
06-15 181
Spring IOC源码剖析：Spring IOC容器初始化主体流程 1、 Spring IOC的容器体系 IoC容器是Spring的核⼼模块，是抽象了对象管理、依赖关系管理的框架解决方案。Spring 提供了很多的容器，其中 BeanFactory 是顶层容器（根容器），不能被实例化，它定义了所有 IoC 容器必须遵从的一套原则，具体的容器实现可以增加额外的功能，比如我们常用到的ApplicationContext，其下更具体的实现如 ClassPathXmlApplicationContext 包含了解
spring ioc源码详解
修理男爵的博客
08-21 2952
ioc是 spring 中最最最最重要的部分，本文将会详细讲解 ioc的源码。
Spring源码之IOC源码解析
从入门到脱发
05-03 3525
文章目录前言类的体系结构源码解析ClassPathScanningCandidateComponentProviderClassPathBeanDefinitionScannerAnnotatedBeanDefinitionReaderAnnotationConfigUtilsBeanDefinitionReaderUtilsAbstractApplicationContextPostProces...
Spring IOC 源码解析
WP19921017的博客
06-14 841
Spring IOC 源码解析 控制反转（IoC） 控制反转（IoC）原理的Spring Framework实现。IoC也称为依赖注入（DI）。这是一个过程，通过这个过程，对象只能通过构造函数参数，工厂方法的参数或在构造或从工厂方法返回后在对象实例上设置的...
spring IOC和DI源码分析
wyl6019的博客
04-27 6315
引言先看下最基本的启动 Spring 容器的例子：public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationfile.xml"); }以上代码就可以利用配置文件来启动一个 Spring 容器了，请...
【Mybatis】Mybatis使用日期类型参数作为where查询条件遇到的一点小坑
要继续努力的孤独的博客
03-20 7606
@Data public class Work { private Employee employee; @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") private Date workTime; private Date startTime; private Date endTime; priva...
【Java】SpringBoot应用简单示例
要继续努力的孤独的博客
11-15 4064
springboot应用的一些小示例
【Java】Spring中Aware接口的作用
要继续努力的孤独的博客
01-08 1541
学习spring的笔记
【Java】Seata全局事务与本地事务的用法
最新发布
要继续努力的孤独的博客
02-06 1470
seata用法
"拿捏面试官-Spring AOP IOC源码笔记
本文是关于Spring AOP IOC源码的笔记，通过对Spring的入门和IOC的介绍，深入分析了Spring的核心模块以及Bean对象的创建细节和对象依赖注入。文章通过解释Spring的侵入式和松耦合概念，引出了Spring的核心模块IOC的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值