SpringIOC源码阅读笔记（2）

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量141 收藏
点赞数
分类专栏： spring 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jacobbbbbbbb/article/details/106403796
版权

整个ioc的过程可以分为3个步骤：
1.资源定位，根据location找到对应的资源。
2.装载，将资源解析到对应的beanDefinition。
3.注册，将beanDefinition中的对象注册进容器。
给一个简单的例子，后面的分析也将从这个例子中展开
BeanFactory bf= new XmlBeanFactory(new ClassPathResource(“beanFactory.xml”))
classpathresource的定位就不细说了，

//XmlBeanFactory的主要实现都在父类DefaultListableBeanFactory中
public class XmlBeanFactory extends DefaultListableBeanFactory {
//每个BeanFactory对应有一个BeanDefinition的读取器
	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
	//没有父容器的定义方法
public XmlBeanFactory(Resource resource) throws BeansException {
		this(resource, null);
	}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
		super(parentBeanFactory);
		this.reader.loadBeanDefinitions(resource);
	}

接下来进入org.springframework.beans.factory.xml.XmlBeanDefinitionReader

@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}

首先进行的是EncodedResource的封装，用于对资源文件的编码进行处理的
主要是为了getReader方法的时候可以根据指定的编码或者字符集来生成字符流

public Reader getReader() throws IOException {
		if (this.charset != null) {
			return new InputStreamReader(this.resource.getInputStream(), this.charset);
		}
		else if (this.encoding != null) {
			return new InputStreamReader(this.resource.getInputStream(), this.encoding);
		}
		else {
			return new InputStreamReader(this.resource.getInputStream());
		}
	}

沿着XmlBeanDefinitionReader类继续分析，进入了真正的数据准备阶段：

//当前线程中正在加载EncodedResource集合
	private final ThreadLocal<Set<EncodedResource>> resourcesCurrentlyBeingLoaded =
			new NamedThreadLocal<>("XML bean definition resources currently being loaded");
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isInfoEnabled()) {
			logger.info("Loading XML bean definitions from " + encodedResource.getResource());
		}
		//获取已经加载过的资源
		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		//如果为null，就设置一个大小为4的set进去
		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 {
			//接下来会用sax来解析xml，因此先将字节流转成InputSource
				InputSource inputSource = new InputSource(inputStream);
				//设置编码
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				//核心逻辑，执行加载beanDefinition
				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 {
		//获取XML Document实例
			Document doc = doLoadDocument(inputSource, resource);
			//根据Document实例来注册Bean信息
			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);
		}
	}

private DocumentLoader documentLoader = new DefaultDocumentLoader();
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
		return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
				getValidationModeForResource(resource), isNamespaceAware());
	}

上述方法中有5个参数：
1.inputSource
2.getEntityResolver()
首先看一下这个EntityResolver到底是什么：
这是一个接口，并且只有一个方法，主要作用是项目本身就可以提供一个如何寻找DTD声明的办法。

//接口方法接收两个参数publicId（被引用的外部实体的公共标识符）和systemId（被引用的外部实体的系统标识符）。
public abstract InputSource resolveEntity (String publicId,
                                               String systemId)
        throws SAXException, IOException;

返回方法本身

protected EntityResolver getEntityResolver() {
		if (this.entityResolver == null) {
			// Determine default EntityResolver to use.
			ResourceLoader resourceLoader = getResourceLoader();
			if (resourceLoader != null) {
			//指定了资源定位器，就使用ResourceEntityResolver
				this.entityResolver = new ResourceEntityResolver(resourceLoader);
			}
			else {
			//如果没有指定，使用DelegatingEntityResolver
				this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader());
			}
		}
		return this.entityResolver;
	}

看一下上述两个类的实现：
这是ResourceEntityResolver的，父类是DelegatingEntityResolver：

private final ResourceLoader resourceLoader;

@Override
@Nullable
public InputSource resolveEntity(String publicId, @Nullable String systemId) throws SAXException, IOException {
    // 调用父类的方法，进行解析
    InputSource source = super.resolveEntity(publicId, systemId);
    // 解析失败，resourceLoader 进行解析
    if (source == null && systemId != null) {
        // 获得 resourcePath ，即 Resource 资源地址
        String resourcePath = null;
        try {
            String decodedSystemId = URLDecoder.decode(systemId, "UTF-8"); // 使用 UTF-8 ，解码 systemId
            String givenUrl = new URL(decodedSystemId).toString(); // 转换成 URL 字符串
            // 解析文件资源的相对路径（相对于系统根路径）
            String systemRootUrl = new File("").toURI().toURL().toString();
            // Try relative to resource base if currently in system root.
            if (givenUrl.startsWith(systemRootUrl)) {
                resourcePath = givenUrl.substring(systemRootUrl.length());
            }
        } catch (Exception ex) {
            // Typically a MalformedURLException or AccessControlException.
            if (logger.isDebugEnabled()) {
                logger.debug("Could not resolve XML entity [" + systemId + "] against system root URL", ex);
            }
            // No URL (or no resolvable URL) -> try relative to resource base.
            resourcePath = systemId;
        }
        if (resourcePath != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Trying to locate XML entity [" + systemId + "] as resource [" + resourcePath + "]");
            }
            // 获得 Resource 资源
            Resource resource = this.resourceLoader.getResource(resourcePath);
            // 创建 InputSource 对象
            source = new InputSource(resource.getInputStream());
            // 设置 publicId 和 systemId 属性
            source.setPublicId(publicId);
            source.setSystemId(systemId);
            if (logger.isDebugEnabled()) {
                logger.debug("Found XML entity [" + systemId + "]: " + resource);
            }
        }
    }
    return source;
}

这是DelegatingEntityResolver的：

@Override
	@Nullable
	public InputSource resolveEntity(String publicId, @Nullable String systemId) throws SAXException, IOException {
		if (systemId != null) {
			if (systemId.endsWith(DTD_SUFFIX)) {
			//如果是dtd用dtdResolver来解析
				return this.dtdResolver.resolveEntity(publicId, systemId);
			}
			//xsd用schemaResolver解析
			else if (systemId.endsWith(XSD_SUFFIX)) {
				return this.schemaResolver.resolveEntity(publicId, systemId);
			}
		}
		return null;
	}

dtdResolver对应的是BeansDtdResolver

@Override
	@Nullable
	public InputSource resolveEntity(String publicId, @Nullable String systemId) throws IOException {
		if (logger.isTraceEnabled()) {
			logger.trace("Trying to resolve XML entity with public ID [" + publicId +
					"] and system ID [" + systemId + "]");
		}
		if (systemId != null && systemId.endsWith(DTD_EXTENSION)) {
			int lastPathSeparator = systemId.lastIndexOf("/");
			int dtdNameStart = systemId.indexOf(DTD_NAME, lastPathSeparator);
			//spring-beans是否存在
			if (dtdNameStart != -1) {
			//spring-beans.dtd
				String dtdFile = DTD_NAME + DTD_EXTENSION;
				if (logger.isTraceEnabled()) {
					logger.trace("Trying to locate [" + dtdFile + "] in Spring jar on classpath");
				}
				try {
					Resource resource = new ClassPathResource(dtdFile, getClass());
					InputSource source = new InputSource(resource.getInputStream());
					source.setPublicId(publicId);
					source.setSystemId(systemId);
					if (logger.isDebugEnabled()) {
						logger.debug("Found beans DTD [" + systemId + "] in classpath: " + dtdFile);
					}
					return source;
				}
				catch (IOException ex) {
					if (logger.isDebugEnabled()) {
						logger.debug("Could not resolve beans DTD [" + systemId + "]: not found in classpath", ex);
					}
				}

			}
		}

		// Use the default behavior -> download from website or wherever.
		return null;
	}

schemaResolver对应的是PluggableSchemaResolver

	@Override
	@Nullable
	public InputSource resolveEntity(String publicId, @Nullable String systemId) throws IOException {
		if (logger.isTraceEnabled()) {
			logger.trace("Trying to resolve XML entity with public id [" + publicId +
					"] and system id [" + systemId + "]");
		}

		if (systemId != null) {
		//类加载器加载"META-INF/spring.schemas"
			String resourceLocation = getSchemaMappings().get(systemId);
			if (resourceLocation != null) {
				Resource resource = new ClassPathResource(resourceLocation, this.classLoader);
				try {
					InputSource source = new InputSource(resource.getInputStream());
					source.setPublicId(publicId);
					source.setSystemId(systemId);
					if (logger.isDebugEnabled()) {
						logger.debug("Found XML schema [" + systemId + "] in classpath: " + resourceLocation);
					}
					return source;
				}
				catch (FileNotFoundException ex) {
					if (logger.isDebugEnabled()) {
						logger.debug("Couldn't find XML schema [" + systemId + "]: " + resource, ex);
					}
				}
			}
		}
		return null;
	}

3.this.errorhandler
private ErrorHandler errorHandler = new SimpleSaxErrorHandler(logger)
4.getValidationModeForResource(resource)

protected int getValidationModeForResource(Resource resource) {
//默认的是XmlValidationModeDetector.VALIDATION_AUTO
		int validationModeToUse = getValidationMode();
		//不是默认的就直接返回
		if (validationModeToUse != VALIDATION_AUTO) {
			return validationModeToUse;
		}
		//检测验证模式
		int detectedMode = detectValidationMode(resource);
		if (detectedMode != VALIDATION_AUTO) {
			return detectedMode;
		}
		//都没有返回XSD验证模式
		return VALIDATION_XSD;
	}

private final XmlValidationModeDetector validationModeDetector = new XmlValidationModeDetector();
protected int detectValidationMode(Resource resource) {
//不可读，异常
		if (resource.isOpen()) {
			throw new BeanDefinitionStoreException(
					"Passed-in Resource [" + resource + "] contains an open stream: " +
					"cannot determine validation mode automatically. Either pass in a Resource " +
					"that is able to create fresh streams, or explicitly specify the validationMode " +
					"on your XmlBeanDefinitionReader instance.");
		}
		//打开stream流
		InputStream inputStream;
		try {
			inputStream = resource.getInputStream();
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"Unable to determine validation mode for [" + resource + "]: cannot open InputStream. " +
					"Did you attempt to load directly from a SAX InputSource without specifying the " +
					"validationMode on your XmlBeanDefinitionReader instance?", ex);
		}

		try {
			return this.validationModeDetector.detectValidationMode(inputStream);
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("Unable to determine validation mode for [" +
					resource + "]: an error occurred whilst reading from the InputStream.", ex);
		}
	}

接下来代码进入了org.springframework.util.xml.XmlValidationModeDetector

	public int detectValidationMode(InputStream inputStream) throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
		try {
		//默认非DTD，即XSD
			boolean isDtdValidated = false;
			String content;
			//循环逐行读取XML文件的内容
			while ((content = reader.readLine()) != null) {
				content = consumeCommentTokens(content);
				if (this.inComment || !StringUtils.hasText(content)) {
					continue;
				}
				//如果其中有DOCTYPE就是dtd
				if (hasDoctype(content)) {
					isDtdValidated = true;
					break;
				}
				//
				if (hasOpeningTag(content)) {
					// End of meaningful data...
					break;
				}
			}
			return (isDtdValidated ? VALIDATION_DTD : VALIDATION_XSD);
		}
		catch (CharConversionException ex) {
			return VALIDATION_AUTO;
		}
		finally {
			reader.close();
		}
	}

5.isNamespaceAware()
指示此解析器是否被配置为可识别名称空间。
默认为false

接下来分析loadDocument方法，该方法的实现是在org.springframework.beans.factory.xml.DefaultDocumentLoader。

	@Override
	public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
			ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
		//创建DocumentBuilderFactory
		DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
		if (logger.isDebugEnabled()) {
			logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
		}
		//创建 DocumentBuilder
		DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
		//解析XML InputSource 返回 Document 对象
		return builder.parse(inputSource);
	}

private static final String SCHEMA_LANGUAGE_ATTRIBUTE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";
private static final String XSD_SCHEMA_LANGUAGE = "http://www.w3.org/2001/XMLSchema";
	protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware)
			throws ParserConfigurationException {
		//创建DocumentBuilderFactory
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		//设置命名空间支持
		factory.setNamespaceAware(namespaceAware);
		//验证方式不为none就开启验证
		if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
			factory.setValidating(true);
			if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
			// XSD 模式下，强制设置命名空间支持
				factory.setNamespaceAware(true);
				try {
				// 设置 SCHEMA_LANGUAGE_ATTRIBUTE
					factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
				}
				catch (IllegalArgumentException ex) {
					ParserConfigurationException pcex = new ParserConfigurationException(
							"Unable to validate using XSD: Your JAXP provider [" + factory +
							"] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
							"Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
					pcex.initCause(ex);
					throw pcex;
				}
			}
		}

		return factory;
	}

protected DocumentBuilder createDocumentBuilder(DocumentBuilderFactory factory,
			@Nullable EntityResolver entityResolver, @Nullable ErrorHandler errorHandler)
			throws ParserConfigurationException {
		// 创建 DocumentBuilder 对象
		DocumentBuilder docBuilder = factory.newDocumentBuilder();
		// 设置 EntityResolver 属性
		if (entityResolver != null) {
			docBuilder.setEntityResolver(entityResolver);
		}
		// 设置 ErrorHandler 属性
		if (errorHandler != null) {
			docBuilder.setErrorHandler(errorHandler);
		}
		return docBuilder;
	}

接下来回到XmlBeanDefinitionReader的registerBeanDefinitions方法：
通过上面的分析我们已经将xml文件资源转换成了解析完的Document类型

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        //创建BeanDefinitionDocumentReader 对象
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		//获取已注册的 BeanDefinition 数量
		int countBefore = getRegistry().getBeanDefinitionCount();
		//创建XmlReaderContext对象，注册BeanDefinition
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		//计算新注册的 BeanDefinition 数量
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

首先是createBeanDefinitionDocumentReader

private Class<?> documentReaderClass = DefaultBeanDefinitionDocumentReader.class;
protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
//生成DefaultBeanDefinitionDocumentReader
		return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
	}

getRegistry()返回的是AbstractBeanDefinitionReader中的registry
而我们一直说的DefaultListableBeanFactory就是实现了BeanDefinitionRegistry，换句话说就是个注册中心，那么
getBeanDefinitionCount返回的其实就是注册中心中注册的那些beandefinition的数量。

private ProblemReporter problemReporter = new FailFastProblemReporter();

private ReaderEventListener eventListener = new EmptyReaderEventListener();

private SourceExtractor sourceExtractor = new NullSourceExtractor();
public XmlReaderContext createReaderContext(Resource resource) {
//创建 XmlReaderContext 对象
		return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
				this.sourceExtractor, this, getNamespaceHandlerResolver());
	}

接下来是registerBeanDefinitions，实现在DefaultBeanDefinitionDocumentReader

@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		//获取XML的Root Element
		Element root = doc.getDocumentElement();
		//执行注册BeanDefinition
		doRegisterBeanDefinitions(root);
	}

protected void doRegisterBeanDefinitions(Element root) {
// 记录老的 BeanDefinitionParserDelegate 对象
		BeanDefinitionParserDelegate parent = this.delegate;
		//创建 BeanDefinitionParserDelegate 对象，并进行设置到 delegate
		this.delegate = createDelegate(getReaderContext(), root, parent);
		//检查 <beans /> 根标签的命名空间是否为空，或者是 http://www.springframework.org/schema/beans
		if (this.delegate.isDefaultNamespace(root)) {
		//处理 profile 属性
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
			//使用分隔符切分，可能有多个 profile
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
						//如果所有 profile 都无效，则不进行注册
				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);
		//将delegate恢复
		this.delegate = parent;
	}

protected BeanDefinitionParserDelegate createDelegate(
			XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) {
		// 创建 BeanDefinitionParserDelegate 对象
		BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
		 // 初始化默认
		delegate.initDefaults(root, parentDelegate);
		return delegate;
	}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//根节点是默认命名空间（beans，alias,import,bean），执行默认解析
		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);
		}
	}
jacobbbbbbbb
关注
专栏目录
Spring AOP IOC源码笔记.pdf
05-08
本笔记将深入探讨这两个概念以及它们在Spring中的实现。 1. Spring框架简介： Spring作为一个轻量级的开源框架，旨在简化企业级应用的开发。它通过提供IOC容器，实现了对象的创建、管理和依赖注入，减轻了开发者对...
Spring IOC 笔记
03-18
**Spring IOC 笔记** Spring 框架是 Java 应用开发中的核心框架，它引入了控制反转（Inversion of Control，简称 IOC）和依赖...在实际开发中，结合源码阅读和工具使用，可以更高效地利用 Spring 功能，提升开发效率。
Spring源码导读之xml基础知识
lightj1996的博客
07-17 194
xml基础知识 <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/sche
spring学习（三）——BeanDefinition的拼装（资源验证和Document的获取）
大风的博客
03-14 353
参考文章： http://www.iocoder.cn/ IOC加载BeanDefinitions的核心逻辑 主要在XmlBeanDefinitionReader.#doLoadBeanDefinitions(InputSource inputSource, Resource resource)方法中 加载Definitions的流程 调用#getValidationMo...
spring xml EntityResolver
hehaibo
05-14 169
1 接口的声明 package org.xml.sax; import java.io.IOException; public interface EntityResolver { public abstract InputSource resolveEntity (String publicId, String systemId) throw...
xmlBeanFactory源码解析
p13132312312的博客
01-14 392
一.xmlBeanFactory结构 先来看看怎么用 我们可以使用xmlBeanFactory把spring使用起来，代码如下： ClassPathResource classPathResource = new ClassPathResource("spring2.xml"); XmlBeanFactory xmlBeanFactory = new XmlBean...
Android权限说明 system权限 root权限
weixin_30478923的博客
08-24 1001
原文链接：http://blog.csdn.net/rockwupj/article/details/8618655 Android权限说明 Android系统是运行在Linux内核上的，Android与Linux分别有自己的一套严格的安全及权限机制，Android系统权限相关的内容， （一）linux文件系统上的权限-rwxr-x--x system system 4156...
spring ioc源码阅读笔记
a7459的博客
08-24 112
Spring-IoC源码分析
一名蒟蒻的博客
05-25 2343
IoC源码分析 1、IoC定义 将原本在程序中⼿动创建对象的控制权，交由Spring框架来管理。 IoC 容器是 Spring⽤来实现 IoC 的载体， IoC 容器实际上就是个Map（key，value），Map 中存放的是各种对象 将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注⼊。 IoC 容器就像是⼀个⼯⼚⼀样，当我们需要创建⼀个对象的时候，只需要配置好配置⽂件/注解即 可，完全不⽤考虑对象是如何被创建出来的。 IoC 的实现原理就是工厂模式加反射机制 优点： 代
Spring IOC源码解析笔记
热门推荐
专注于Java架构学习 https://gitee.com/laokouyun https://github.com/KouShenhai
01-21 2万+
AnnotationConfigApplicationContext类继承图（多余的类去除掉了）AnnotationConfigApplicationContext类官网文档解释独立的应用程序上下文，接受组件类作为输入 — 特别是注释类，还有纯@Component类型和符合 JSR-330 类使用注释。允许使用寄存器（类...）逐个注册类以及使用扫描（字符串...）进行类路径扫描。在多个类的情况下，@Bean方法 在后面的类中定义的将覆盖在早期类中定义的那些。
拿捏面试官-Spring AOP IOC源码笔记
01-30
2. **IOC控制反转** - **引出Spring**：由于Java EE的复杂性，Spring引入了IOC，将对象的创建和管理交给容器，而不是由对象自身负责。 - **IOC容器**：Spring容器（如BeanFactory或ApplicationContext）负责创建、...
Spring高级源码学习笔记.zip
05-24
在阅读Spring源码笔记时，建议结合实际项目经验，逐步理解并实践源码中的关键概念。"查看密码，打开必看.txt"可能是提供解压文件的密码，确保正确解压并阅读PDF文档，以获得完整的知识体系。 总之，Spring源码学习...
spring高级源码笔记.pdf
09-05
通过阅读源码，开发者可以了解如何实现DI和AOP，以及Spring如何优雅地管理对象和处理各种框架的集成。对于初入IT行业的人员来说，这是一条理解高级技术、提升专业素养的有效途径。在阅读过程中，做笔记是非常重要的...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 928
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1217
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 360
JDK1.0主要特性。
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1018
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 522
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 702
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
深入解析Spring源码：核心组件阅读笔记
本压缩包文件集包含了对于Spring框架各个核心组件的深入分析和阅读笔记。Spring框架是目前Java开发者使用最为广泛的企业级应用开发框架之一，它的强大之处在于其轻量级的控制反转（IoC）和面向切面编程（AOP）机制。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值