SpringIOC源码阅读笔记（1）

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

刚看完springMVC的源码，感觉spring的容器源码还是掌握不到位，所以打算写一点笔记再理一遍思路。

一.Resource

spring给资源提供了封装，根据不同的资源类型有不同的实现类，首先先看下UML图：
在这里插入图片描述
1.org.springframework.core.io.InputStreamSource
顶层接口，其中就定义了一个方法获取输入流：
InputStream getInputStream() throws IOException
2.org.springframework.core.io.Resource
Spring 框架所有资源的抽象和访问接口，定义了一些通用的方法。

public interface Resource extends InputStreamSource {
	//资源是否存在
	boolean exists();
	//资源是否可读
	default boolean isReadable() {
		return true;
	}
	 // 资源所代表的句柄是否被一个 stream 打开了
	default boolean isOpen() {
		return false;
	}
	 // 是否为 File
	default boolean isFile() {
		return false;
	}
	 //返回资源的 URL 的句柄
	URL getURL() throws IOException;
	 // 返回资源的 URI 的句柄
	URI getURI() throws IOException;
	// 返回资源的 File 的句柄
	File getFile() throws IOException;
	//返回 ReadableByteChannel
	default ReadableByteChannel readableChannel() throws IOException {
		return java.nio.channels.Channels.newChannel(getInputStream());
	}
	 //资源内容的长度
	long contentLength() throws IOException;
	 // 资源最后的修改时间
	long lastModified() throws IOException;
	 // 根据资源的相对路径创建新资源
	Resource createRelative(String relativePath) throws IOException;
	 // 资源的文件名
	@Nullable
	String getFilename();
	 //资源的描述
	String getDescription();
}

3.org.springframework.core.io.AbstractResource，是Resource接口的默认抽象实现：

public abstract class AbstractResource implements Resource {
	@Override
	public boolean exists() {
		try {
		//基于File进行判断
			return getFile().exists();
		}
		catch (IOException ex) {
			try {
			//基于inputStream进行判断
				InputStream is = getInputStream();
				is.close();
				return true;
			}
			catch (Throwable isEx) {
				return false;
			}
		}
	}
	//表示可读
	@Override
	public boolean isReadable() {
		return true;
	}
	//没有被打开
	@Override
	public boolean isOpen() {
		return false;
	}
	//不是File
	@Override
	public boolean isFile() {
		return false;
	}
	//抛出 FileNotFoundException 异常，交给子类实现
	@Override
	public URL getURL() throws IOException {
		throw new FileNotFoundException(getDescription() + " cannot be resolved to URL");
	}
	//基于 getURL() 返回的 URL 构建 URI
	@Override
	public URI getURI() throws IOException {
		URL url = getURL();
		try {
			return ResourceUtils.toURI(url);
		}
		catch (URISyntaxException ex) {
			throw new NestedIOException("Invalid URI [" + url + "]", ex);
		}
	}
	//不是File，自然不能返回File
	@Override
	public File getFile() throws IOException {
		throw new FileNotFoundException(getDescription() + " cannot be resolved to absolute file path");
	}
	//根据 getInputStream() 的返回结果构建 ReadableByteChannel
	@Override
	public ReadableByteChannel readableChannel() throws IOException {
		return Channels.newChannel(getInputStream());
	}
	//这个资源内容长度实际就是资源的字节长度
	@Override
	public long contentLength() throws IOException {
		InputStream is = getInputStream();
		try {
			long size = 0;
			byte[] buf = new byte[255];
			int read;
			while ((read = is.read(buf)) != -1) {
				size += read;
			}
			return size;
		}
		finally {
			try {
				is.close();
			}
			catch (IOException ex) {
			}
		}
	}

	//返回资源的最后修改时间
	@Override
	public long lastModified() throws IOException {
		long lastModified = getFileForLastModifiedCheck().lastModified();
		if (lastModified == 0L) {
			throw new FileNotFoundException(getDescription() +
					" cannot be resolved in the file system for resolving its last-modified timestamp");
		}
		return lastModified;
	}
	protected File getFileForLastModifiedCheck() throws IOException {
		return getFile();
	}
	//子类实现相对路径
	@Override
	public Resource createRelative(String relativePath) throws IOException {
		throw new FileNotFoundException("Cannot create a relative resource for " + getDescription());
	}
	//得到文件名
	@Override
	@Nullable
	public String getFilename() {
		return null;
	}

	@Override
	public String toString() {
		return getDescription();
	}

	//资源的描述相同也可以成立
	@Override
	public boolean equals(Object obj) {
		return (obj == this ||
			(obj instanceof Resource && ((Resource) obj).getDescription().equals(getDescription())));
	}
	@Override
	public int hashCode() {
		return getDescription().hashCode();
	}

}

其余子类就不分析了，大同小异。

二.ResourceLoader

在这里插入图片描述
1.资源的加载都是通过ResourceLoader来完成的：

public interface ResourceLoader {
//classpath前缀，默认是“classpath：”
	String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;
	//根据路径获取资源：URL位置资源、ClassPath位置资源、相对路径资源等，主要实现是在DefaultResourceLoader
	Resource getResource(String location);
	//返回 ClassLoader 实例，对于想要获取 ResourceLoader 使用的 ClassLoader 用户来说，可以直接调用该方法来获取。
	@Nullable
	ClassLoader getClassLoader();

}

2、DefaultResourceLoader

public class DefaultResourceLoader implements ResourceLoader {

	@Nullable
	private ClassLoader classLoader;
	//用户自定义协议资源解决策略
	private final Set<ProtocolResolver> protocolResolvers = new LinkedHashSet<>(4);
	//资源缓存
	private final Map<Class<?>, Map<Resource, ?>> resourceCaches = new ConcurrentHashMap<>(4);

	//默认的无参构造
	public DefaultResourceLoader() {
		this.classLoader = ClassUtils.getDefaultClassLoader();
	}
//传入构造函数classLoader
	public DefaultResourceLoader(@Nullable ClassLoader classLoader) {
		this.classLoader = classLoader;
	}
	public void setClassLoader(@Nullable ClassLoader classLoader) {
		this.classLoader = classLoader;
	}
	@Override
	@Nullable
	public ClassLoader getClassLoader() {
		return (this.classLoader != null ? this.classLoader : ClassUtils.getDefaultClassLoader());
	}

	public void addProtocolResolver(ProtocolResolver resolver) {
		Assert.notNull(resolver, "ProtocolResolver must not be null");
		this.protocolResolvers.add(resolver);
	}

	/**
	 * Return the collection of currently registered protocol resolvers,
	 * allowing for introspection as well as modification.
	 * @since 4.3
	 */
	public Collection<ProtocolResolver> getProtocolResolvers() {
		return this.protocolResolvers;
	}

	/**
	 * Obtain a cache for the given value type, keyed by {@link Resource}.
	 * @param valueType the value type, e.g. an ASM {@code MetadataReader}
	 * @return the cache {@link Map}, shared at the {@code ResourceLoader} level
	 * @since 5.0
	 */
	@SuppressWarnings("unchecked")
	public <T> Map<Resource, T> getResourceCache(Class<T> valueType) {
		return (Map<Resource, T>) this.resourceCaches.computeIfAbsent(valueType, key -> new ConcurrentHashMap<>());
	}

	/**
	 * Clear all resource caches in this resource loader.
	 * @since 5.0
	 * @see #getResourceCache
	 */
	public void clearResourceCaches() {
		this.resourceCaches.clear();
	}

	@Override
	public Resource getResource(String location) {
		Assert.notNull(location, "Location must not be null");
		//首先，通过 ProtocolResolver 来加载资源，这个类就是自定义的解析方法，自己定义location与资源的对应关系
		for (ProtocolResolver protocolResolver : this.protocolResolvers) {
			Resource resource = protocolResolver.resolve(location, this);
			if (resource != null) {
				return resource;
			}
		}
		//如果路径是以“/”开始的，返回ClassPathContextResource（DefaultResourceLoader的内部类，继承了ClassPathResource）
		if (location.startsWith("/")) {
			return getResourceByPath(location);
		}
		//如果是以“classpath：”开头的，返回 ClassPathResource 类型的资源
		else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
			return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
		}
		else {
			try {
				// 根据是否为文件 URL ，是则返回 FileUrlResource 类型的资源，否则返回 UrlResource 类型的资源
				URL url = new URL(location);
				return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
			}
			catch (MalformedURLException ex) {
				// No URL -> resolve as resource path.
				return getResourceByPath(location);
			}
		}
	}
	protected Resource getResourceByPath(String path) {
	//构造 ClassPathContextResource 类型资源并返回
		return new ClassPathContextResource(path, getClassLoader());
	}

	protected static class ClassPathContextResource extends ClassPathResource implements ContextResource {

		public ClassPathContextResource(String path, @Nullable ClassLoader classLoader) {
			super(path, classLoader);
		}
		//重写ContextResource接口方法
		@Override
		public String getPathWithinContext() {
			return getPath();
		}

		@Override
		public Resource createRelative(String relativePath) {
			String pathToUse = StringUtils.applyRelativePath(getPath(), relativePath);
			return new ClassPathContextResource(pathToUse, getClassLoader());
		}
	}

}

3.FileSystemResourceLoader

public class FileSystemResourceLoader extends DefaultResourceLoader {
	@Override
	//在DefaultResourceLoader中，这个方法直接返回创建ClassPathContextResource，在这个类中重写了该方法，可以得到我们想要的资源类型
	protected Resource getResourceByPath(String path) {
		if (path.startsWith("/")) {
			path = path.substring(1);
		}
		return new FileSystemContextResource(path);
	}

	private static class FileSystemContextResource extends FileSystemResource implements ContextResource {

		public FileSystemContextResource(String path) {
			super(path);
		}

		@Override
		public String getPathWithinContext() {
			return getPath();
		}
	}
}

4.ClassRelativeResourceLoader

//可以根据给定的class 所在包或者所在包的子包下加载资源。
public class ClassRelativeResourceLoader extends DefaultResourceLoader {

	private final Class<?> clazz;
	public ClassRelativeResourceLoader(Class<?> clazz) {
		Assert.notNull(clazz, "Class must not be null");
		this.clazz = clazz;
		setClassLoader(clazz.getClassLoader());
	}

	@Override
	protected Resource getResourceByPath(String path) {
		return new ClassRelativeContextResource(path, this.clazz);
	}


	/**
	 * ClassPathResource that explicitly expresses a context-relative path
	 * through implementing the ContextResource interface.
	 */
	private static class ClassRelativeContextResource extends ClassPathResource implements ContextResource {

		private final Class<?> clazz;

		public ClassRelativeContextResource(String path, Class<?> clazz) {
			super(path, clazz);
			this.clazz = clazz;
		}

		@Override
		public String getPathWithinContext() {
			return getPath();
		}

		@Override
		public Resource createRelative(String relativePath) {
			String pathToUse = StringUtils.applyRelativePath(getPath(), relativePath);
			return new ClassRelativeContextResource(pathToUse, this.clazz);
		}
	}

}

5.ResourcePatternResolver

//它支持根据指定的资源路径匹配模式每次返回多个 Resource 实例
public interface ResourcePatternResolver extends ResourceLoader {
	String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
	Resource[] getResources(String locationPattern) throws IOException;
}

6.PathMatchingResourcePatternResolver

//内置的资源加载器
	private final ResourceLoader resourceLoader;
//Ant路径匹配器
	private PathMatcher pathMatcher = new AntPathMatcher();
	//默认构造
	public PathMatchingResourcePatternResolver() {
	this.resourceLoader = new DefaultResourceLoader();
}
//传入资源定位器
public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
	Assert.notNull(resourceLoader, "ResourceLoader must not be null");
	this.resourceLoader = resourceLoader;
}
//传入类加载器
public PathMatchingResourcePatternResolver(@Nullable ClassLoader classLoader) {
	this.resourceLoader = new DefaultResourceLoader(classLoader);

@Override
//委托给指定的资源定位器
public Resource getResource(String location) {
	return getResourceLoader().getResource(location);
}

public ResourceLoader getResourceLoader() {
	return this.resourceLoader;
}
@Override
public Resource[] getResources(String locationPattern) throws IOException {
    Assert.notNull(locationPattern, "Location pattern must not be null");
    // 以 "classpath*:" 开头
    if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
        // 路径包含通配符
        if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
            // a class path resource pattern
            return findPathMatchingResources(locationPattern);
        // 路径不包含通配符
        } else {
            // all class path resources with the given name
            return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
        }
    // 不以 "classpath*:" 开头
    } else {
        // Generally only look for a pattern after a prefix here, // 通常只在这里的前缀后面查找模式
        // and on Tomcat only after the "*/" separator for its "war:" protocol. 而在 Tomcat 上只有在 “*/ ”分隔符之后才为其 “war:” 协议
        int prefixEnd = (locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 :
                locationPattern.indexOf(':') + 1);
        // 路径包含通配符
        if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
            // a file pattern
            return findPathMatchingResources(locationPattern);
        // 路径不包含通配符
        } else {
            // a single resource with the given name
            return new Resource[] {getResourceLoader().getResource(locationPattern)};
        }
    }
}
其余方法不做分析，综上主要讲的是Spring中资源以及资源的定位器。
jacobbbbbbbb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PyEmu源码阅读笔记
无题
03-12 3333
PyEmu是一个用python编写的x86指令仿真器，所谓仿真器就是个类似沙盒或虚拟机的东西，在仿真器下运行的程序将被完全掌控，所有代码由仿真器模拟执行，具有极强的可控性并且恶意软件一般也无法对机器造成伤害 PyEmu由于作者的精心编写以及python语言本身的优点使得PyEmu源码具有极强的可读性 This is a short readme describing the layou
spring源码阅读（1）
静静的爱着你
10-28 131
1.web.xml <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class>
源码阅读笔记
星空下的约定
11-23 654
2005.11.23 nativeAPI:百度百科 原生API:wikieli’s docs翻译的wiki：http://www.cnblogs.com/exclm/p/4080630.html大牛的博客：待会儿再看吧#define ALIGN_DOWN(x, align) (x &~ (align - 1))//对齐代码用的？ #define ALIGN_UP(x, align) ((x &
Spring IOC 源码 笔记
aajjw的博客
06-02 100
接口，类和组件 BeanFactory：IOC容器的顶级接口，通过BeanFactory获取bean HierarchicalBeanFactory：具有层级结构的BeanFactory，即父子BeanFactory ConfigurableBeanFactory：可配置的BeanFactory接口，提供配置方法配置BeanFactory ListableBeanFactory：BeanFactory接口的扩展，由可以枚举其所有 bean 实例的 bean 工厂实现，而不是按照客户的要求逐一尝试通过名称查
代码阅读和实践笔记
laoj1228的聊天屋
01-14 715
高级c数据类型 C指针 c程序中，指针一般用来： 构造链式数据结构 引用动态分配的数据结构 #define new(type) (type*) calloc(sizeof((type),1) [...] node = new(struct codeword_entry) 实现引用调用（call by reference） 访问和迭代数据元素 传递数组参数 在c和c++程序中，将数组传递
CI框架源码阅读笔记7 配置管理组件 Config.php
weixin_30432579的博客
11-12 176
一个灵活可控的应用程序中，必然会存在大量的可控参数（我们称为配置），例如在CI的主配置文件中（这里指Application/Config/Config.php文件），有如下多项配置： $config['base_url'] = 'http://test.xq.com'; $config['index_page'] = ''; $config['uri_protocol'] ...
Spring高级源码学习笔记.zip
05-24
在阅读Spring源码笔记时，建议结合实际项目经验，逐步理解并实践源码中的关键概念。"查看密码，打开必看.txt"可能是提供解压文件的密码，确保正确解压并阅读PDF文档，以获得完整的知识体系。 总之，Spring源码学习...
Spring IOC 笔记
03-18
**Spring IOC 笔记** Spring 框架是 Java 应用开发中的核心框架，它引入了控制反转（Inversion of Control，简称 IOC）和依赖...在实际开发中，结合源码阅读和工具使用，可以更高效地利用 Spring 功能，提升开发效率。
拿捏面试官-Spring AOP IOC源码笔记
最新发布
01-30
1. **Spring介绍** - **侵入式概念**：传统Java EE应用中，业务逻辑与框架代码紧密耦合，Spring通过IOC降低这种耦合，让开发者更专注于业务逻辑。 - **松耦合概念**：Spring通过依赖注入（DI）实现了组件间的松...
spring源码阅读笔记（一）
weixin_33690367的博客
12-15 121
2019独角兽企业重金招聘Python工程师标准>>> ...
源码阅读笔记——Tablib
Peter的脱发日记
11-04 497
文章目录Tablib用法示例代码结构代码结构与风格细节Reference Tablib Tablib是一个支持多格式数据转换的库，支持的格式包括XLSX、XLS、JSON、YAML、DBF、CSV、TSV、HTML等 用法示例 代码结构 tablib tablib formats packages __init__.py compat.py core.py # 核心功能 README....
Spring IOC源码笔记(一)
weixiaohuai的博客
12-08 757
目录 一、概要 二、准备环境 三、IOC启动过程分析 四、prepareRefresh()：创建 Bean 容器前的准备工作 五、obtainFreshBeanFactory()：创建Bean容器 六、prepareBeanFactory(beanFactory)：准备Bean工厂 七、postProcessBeanFactory(beanFactory)：留给子类对BeanFactory定制化处理 八、总结 一、概要 首先需要明白什么是IOC? IOC（Inversion of.
读书笔记-许式伟架构课-如何阅读源代码
小豆角的博客
03-11 327
读源代码的目的就是了解架构。 我认为首先要找出来软件实体，然后理一下软件实体之间的关系。看源代码，我们首先要做到的是理解系统的概要设计。概要设计的关注点是各个软件实体的业务范畴，以及它们之间的关系。有了这些，我们就能够理解这个系统的架构设计的核心脉络。 要理一下各个软件实体的业务范畴，以及它们之间的关系。有了这些，我们就能够理解这个系统的架构设计的核心脉络。 有文档就先看文档，哪怕文档偏陈旧...
spring 源码_Spring源码高级笔记——Spring IOC源码深度剖析
weixin_39916379的博客
11-26 114
Spring IOC源码深度剖析好处:提高培养代码架构思维、深入理解框架原则定焦原则︰抓主线宏观原则:站在上帝视角，关注源码结构和业务流程(淡化具体某行代码的编写细节)读源码的方法和技巧断点(观察调用栈)反调(Find Usages)经验(spring框架中doXXX，做具体处理的地方)Spring源码构建下载源码(github)安装gradle 5.6.3(类似于maven) ldea 2019...
Spring学习笔记--SpringIOC源码(一)
qq_40977467的博客
05-20 232
Spring学习笔记–SpringIOC源码 再查看源码的过程中我们应该遵守定焦原则和宏观原则，抓主线，关注源码结构和业务流程，通过断点、反调、和经验来阅读源码以此来提高培养代码架构思维并深入的理解框架。 SpringIOC容器初始化主体流程 Spring IoC的容器体系 IoC容器是Spring的核⼼模块，是抽象了对象管理、依赖关系管理的框架解决⽅案。Spring 提供了很多的容器，其中 BeanFactory 是顶层容器（根容器），不能被实例化，它定义了所有 IoC 容器 必须遵从的⼀套原则，具体的容
Spring IOC源码笔记-SpringBean的生命周期
chengpangba1883的博客
03-06 109
spring bean的生命周期 spring bean的实例化经过了容器一系列繁琐的操作，包括实例化之前后，属性初始化前后留有相应的钩子 我们称这些关键的过程为bean在spring容器中的生命周期阶段 在分析每个生命周期时我们先给出一个序列图 spring bean的生命周期序...
Spring笔记：Spring IOC介绍与源码剖析
无趣的博客
03-21 321
文章目录前言一、IOC基础1.BeanFactory与ApplicationContext区别2.关于xml模式的一些东西2.1 Bean不同作用范围的生命周期2.2 Bean标签属性2.3 DI依赖注入的xml配置2.3.1 按照注入的方式分类2.3.1 按照注入的数据类型分类3.注解二、IOC高级特性1. lazy-Init 延迟加载2. FactoryBean 和 BeanFactory3.后置处理器3.1 BeanPostProcessor3.2 BeanFactoryPostProcessor4.
"拿捏面试官-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、付费专栏及课程。

余额充值