spring源码的xml解析过程-2（注册注解处理器）

最新推荐文章于 2022-07-01 18:00:29 发布
最新推荐文章于 2022-07-01 18:00:29 发布
阅读量234 收藏
点赞数
分类专栏： Spring 系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xyz9353/article/details/104739261
版权

文章目录


接上一篇xml解析，回到
org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse 

@Override
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		return findParserForElement(element, parserContext)
		.parse(element, parserContext);
	}
ComponentScanBeanDefinitionParser 标签解析器

component-scan标签解析类

<!-- 激活Spring注解方式：自动扫描，并注入bean -->
<context:component-scan base-package="com.consult.action" 
	use-default-filters="" 
	annotation-config="">
		<context:include-filter type="annotation"
		expression="org.springframework.stereotype.Controller" />
		<context:exclude-filter type="annotation"
		expression="org.springframework.stereotype.Service" />
</context:component-scan>
  • Annotation org.example.SomeAnnotation符合SomeAnnoation的target class
  • Assignable org.example.SomeClass指定class或interface的全名
  • Aspectj org.example…*Service+AspectJ語法
  • Regex org.example.Default.* Regelar Expression
  • Custom org.example.MyTypeFilterSpring3新增自定义Type，见org.springframework.core.type.TypeFilter

在解析类里面完成了
1.基本包的扫描
2.类型过滤器的配置
3.<context:annotation-config/>配置的兼容
4.注解处理器BeanPostProcessor的注册

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

// base-package 标签属性值，即扫描的包配置
String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);

ClassPathBeanDefinitionScanner scanner = 
configureScanner(parserContext, element);

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#configureScanner

//默认过滤器标记
boolean useDefaultFilters = true;

ClassPathBeanDefinitionScanner scanner = 
createScanner(parserContext.getReaderContext(), useDefaultFilters);

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#createScanner

return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), 
useDefaultFilters,
readerContext.getEnvironment(), 
readerContext.getResourceLoader());

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#ClassPathBeanDefinitionScanner(org.springframework.beans.factory.support.BeanDefinitionRegistry, boolean, org.springframework.core.env.Environment, org.springframework.core.io.ResourceLoader)

//注册默认的过滤器
if (useDefaultFilters) {
	registerDefaultFilters();
}

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#registerDefaultFilters

// 扫描 @Component 注解以及  @Component注解的子类，如@Service
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
// 扫描 @ManagedBean 注解 JSR-250
this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) 
ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));

// 扫描 @Named 注解 JSR-330
this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));

见 AnnotationTypeFilter 类中的 annotationType 字段，注解类型

返回到
org.springframework.context.annotation.ComponentScanBeanDefinitionParser#configureScanner

parseTypeFilters(element, scanner, parserContext);

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parseTypeFilters

   //include-filter 元素解析
	if (INCLUDE_FILTER_ELEMENT.equals(localName)) {
		TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
			scanner.addIncludeFilter(typeFilter);
		}
	//exclude-filter 元素解析	
	else if (EXCLUDE_FILTER_ELEMENT.equals(localName)) {
			TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
			scanner.addExcludeFilter(typeFilter);
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#createTypeFilter

// annotation 过滤是最常用的
if ("annotation".equals(filterType)) {
				return new AnnotationTypeFilter((Class<Annotation>) classLoader.loadClass(expression));
			}
			else if ("assignable".equals(filterType)) {
				return new AssignableTypeFilter(classLoader.loadClass(expression));
			}
			else if ("aspectj".equals(filterType)) {
				return new AspectJTypeFilter(expression, classLoader);
			}
			else if ("regex".equals(filterType)) {
				return new RegexPatternTypeFilter(Pattern.compile(expression));
			}
			else if ("custom".equals(filterType)) {
				Class<?> filterClass = classLoader.loadClass(expression);
				if (!TypeFilter.class.isAssignableFrom(filterClass)) {
					throw new IllegalArgumentException(
							"Class is not assignable to [" + TypeFilter.class.getName() + "]: " + expression);
				}
				return (TypeFilter) BeanUtils.instantiateClass(filterClass);
			}

返回到
org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan

Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents

// 将配置包路径的 点 转为 斜杠
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 加载包下的 class 文件
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);

org.springframework.context.support.AbstractApplicationContext#getResources

return this.resourcePatternResolver.getResources(locationPattern);

org.springframework.core.io.support.PathMatchingResourcePatternResolver#getResources

// 如果是 classpath*: 前缀时
	if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
			// a class path resource (multiple resources for same name possible)
			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()));
			}
		}

org.springframework.core.io.support.PathMatchingResourcePatternResolver#findPathMatchingResources


if (rootDirURL.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
				result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirURL, subPattern, getPathMatcher()));
			}
			// 识别 jar 包
			else if (ResourceUtils.isJarURL(rootDirURL) || isJarResource(rootDirResource)) {
				result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirURL, subPattern));
			}
			else {
				
// class 文件添加到结集中，查看 	doFindPathMatchingFileResources			result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
			}

org.springframework.core.io.support.PathMatchingResourcePatternResolver#doFindPathMatchingFileResources

rootDir = rootDirResource.getFile().getAbsoluteFile();

return doFindMatchingFileSystemResources(rootDir, subPattern);

org.springframework.core.io.support.PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources

Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);

org.springframework.core.io.support.PathMatchingResourcePatternResolver#retrieveMatchingFiles


String fullPattern = StringUtils.replace(rootDir.getAbsolutePath(), File.separator, "/");

doRetrieveMatchingFiles(fullPattern, rootDir, result);

org.springframework.core.io.support.PathMatchingResourcePatternResolver#doRetrieveMatchingFiles

File[] dirContents = dir.listFiles();

for (File content : dirContents) {
			String currPath = StringUtils.replace(content.getAbsolutePath(), File.separator, "/");
			if (content.isDirectory() && getPathMatcher().matchStart(fullPattern, currPath + "/")) {
				if (!content.canRead()) {
					if (logger.isDebugEnabled()) {
						logger.debug("Skipping subdirectory [" + dir.getAbsolutePath() +
								"] because the application is not allowed to read the directory");
					}
				}
				else {
				    // 作递归查找文件
					doRetrieveMatchingFiles(fullPattern, content, result);
				}
			}
			if (getPathMatcher().match(fullPattern, currPath)) {
			    // 是文件是加入到集合中
				result.add(content);
			}
		}

返回到
org.springframework.core.io.support.PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources

// matchingFiles 所有class 文件
Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);
Set<Resource> result = new LinkedHashSet<Resource>(matchingFiles.size());
for (File file : matchingFiles) {
    // class 文件转为 Resource后，添加到集合中
	result.add(new FileSystemResource(file));
}

返回到
org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents

// 获取所有 class 文件转为 Resource对象，见上
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);

// 获取class文件中所有的注解信息，封装到 MetadataReader 对象中
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);

// isCandidateComponent 过滤class文件上的所有的注解，即判断类上是否有 @Component、@Service、@Controller 等注解
if (isCandidateComponent(metadataReader)) {
	ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
	sbd.setResource(resource);
	sbd.setSource(resource);
	if (isCandidateComponent(sbd)) {
		if (debugEnabled) {
			logger.debug("Identified candidate component class: " + resource);
								}
					// 将注解的 BeanDefinition 对象添加到集合中			
					candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}

MetadataReader 类中有 AnnotationMetadata getAnnotationMetadata(); 方法，可以获取类中的所有注解
isCandidateComponent 方法过滤所有的注解，即判断类上是否有 @Component、@Service、@Controller 等注解，如果有则创建一个 ScannedGenericBeanDefinition ，将注解信息封装成 BeanDefinition 对象中

返回到
org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan

for (String basePackage : basePackages) {
            // 返回每个类中的注解封装的BeanDefinition 对象集合
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			// 循环 BeanDefinition 
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				// 是 AnnotatedBeanDefinition 类型时
				if (candidate instanceof AnnotatedBeanDefinition) {
// 解析注解的相关属性值					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}

org.springframework.context.annotation.AnnotationConfigUtils#processCommonDefinitionAnnotations(org.springframework.beans.factory.annotation.AnnotatedBeanDefinition)

processCommonDefinitionAnnotations(abd, abd.getMetadata());

org.springframework.context.annotation.AnnotationConfigUtils#processCommonDefinitionAnnotations(org.springframework.beans.factory.annotation.AnnotatedBeanDefinition, org.springframework.core.type.AnnotatedTypeMetadata)

if (metadata.isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata && abd.getMetadata().isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
		}

		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}

返回到
org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan

if (checkCandidate(beanName, candidate)) {
// BeanDefinition 封装成 BeanDefinitionHolder 
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
		definitionHolder =
		AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		beanDefinitions.add(definitionHolder);
		// 注册 BeanDefinition
		registerBeanDefinition(definitionHolder, this.registry);
}

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#registerBeanDefinition

BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);

org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition

registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition

this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;

// ....
//缓存 beanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
// beanDefinitionNames 集合中添加 beanName
this.beanDefinitionNames.add(beanName);

注解的 beanDefinition 注册完毕，注册 beanDefinition 其实就是将 beanDefinition 对象缓存在 DefaultListableBeanFactory 类中的 一些集合中

返回到
org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

// 注解的 beanDefinition 集合
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#registerComponents

// 兼容 annotation-config 标签配置 
boolean annotationConfig = true;
if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
	annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
}
  // 
	if (annotationConfig) {
		Set<BeanDefinitionHolder> processorDefinitions =
		// 注册相关注解的支持处理类，如 @Autowired、@Required 、@Configuration 等注解
		AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
		for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
			}
		}

org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)

// @Order 注解的支持
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);

// @Lazy 注解的支持
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());

// @Configuration 注解的支持
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);

// @Autowired 注解的支持
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
// 注册 PostProcessor 处理器，查看该方法
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));

// @Required 注解的支持
RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);

// @Resource 注解的支持 JSR-250
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);

// JPA 注解的支持
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
	AnnotationConfigUtils.class.getClassLoader()));
	
// @EventListener 注解的支持
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);

org.springframework.context.annotation.AnnotationConfigUtils#registerPostProcessor

// 这里是对注解 @Autowired 的 BeanDefinition 对象（上面的那个）进行注册
registry.registerBeanDefinition(beanName, definition);
// 返回 BeanDefinitionHolder
return new BeanDefinitionHolder(definition, beanName);

对 BeanDefinition 对象注册时都会进入到 org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition 方法中

返回到
org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

总结：<context:component-scan base-package="com.dn.spring.controller" > 标签在扫描配置的包时，会注册很多关于注解的相关处理器

<context:annotation-config/> 的处理器 org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser 里面其实注册了很多关于注解的处理器

总结
  1. 通过扫描指定包路径并加载 class 文件,将 class 文件转为 Resource对象
  2. 注册要扫描class文件中的注解，例如： @Component 注解 以及 @Component注解的子类，如@Service 等
  3. 过滤class文件上的所有的注解，即判断类上是否有 @Component、@Service、@Controller 等注解，将符合的 resource 封装为 ScannedGenericBeanDefinition 对象即 BeanDefinition
  4. 将 BeanDefinition 封装成 BeanDefinitionHolder 并进行注册，注册 beanDefinition 其实就是将 beanDefinition 对象缓存在 DefaultListableBeanFactory 类中的 一些集合中
  5. 注册相关注解的处理器类即BeanPostProcessor或BeanFactoryPostProcessor的子类，如 @Autowired、@Required 、@Configuration 等注解的解析和处理
小鱼儿2020
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-framework-5.1.x-源碼解析详细注解
09-22
《Spring Framework 5.1.x 源码解析详细注解》 Spring Framework作为Java开发中的核心框架，其设计理念和实现机制对...同时，对于想要深入了解Java企业级应用开发的程序员来说，深入研究Spring源码也是一条必经之路。
Spring Core Resource 随手笔记
廖金龙的博客
04-26 239
Spring Core ResourceResource Interface重要方法：主要子类UrlResourceClassPathResourceFileSystemResourceServletContextResourceInputStreamResourceByteArrayResourceResourceLoaderResourceLoaderAware接口 Resource Inte...
xml注解
sprita1的专栏
04-15 802
@XmlType(name=类被映射到的xml模型类型名称                      PropOrder=在将类映射到xml模型模型复杂类型时，指定xml模型元素的顺序) @XmlRootElement(name=xml元素的本地名称                      namespace=xml元素的名称空间名) @XmlRegistry        标记具有的类
深入Spring IOC源码之ResourceLoader
李博/Alex的技术海洋
04-04 96
声明：转载于：http://www.blogjava.net/DLevin/archive/2012/12/01/392337.html 在《深入Spring IOC源码之Resource》中已经详细介绍了Spring中Resource的抽象，Resource接口有很多实现类，我们当然可以使用各自的构造函数创建符合需求的Resource实例，然而Spring提供了ResourceLoad...
3.Spring源码关于annotation扫描（1）
拯救大白程序猿的博客
04-21 523
spring源码关于annotation扫描Spring对于的详细解释的配置详情欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML ...
spring入门之资源获取：PathMatchingResourcePatternResolver源码浅谈
zhuhaoyu6666的博客
03-02 3592
ResourcePatternResolver就是根据资源的前缀来决定使用哪种Resource；因为Resource实在太多了 public interface ResourceLoader { String CLASSPATH_URL_PREFIX = "classpath:"; Resource getResource(String var1); Clas...
Spring源码解析.zip
07-31
《Spring源码解析》 Spring框架作为Java领域最流行的开源框架之一，它的设计思想和实现原理一直是许多开发者深入研究的重点。本压缩包“Spring源码解析”提供了对Spring框架核心组件——IOC（Inversion of Control...
Spring Ioc源码分析系列--@Autowired注解的实现原理.doc
07-09
Spring Ioc源码分析系列--@Autowired注解的实现原理 @ Автоwired注解是 Spring Framework 中的一个重要组件，它提供了自动装配的功能，能够将 Bean 之间的依赖关系自动解析和注入。今天，我们将深入探讨 @...
官方源码 spring-framework-5.3.4.zip
02-18
《Spring Framework 5.3.4 源码解析与深度探索》 Spring Framework作为Java领域最广泛应用的开源框架之一，其稳定性和灵活性备受开发者喜爱。本次我们关注的是它的5.3.4版本，官方源码的发布为开发者提供了一个深入...
spring配置文件----注解配置
03-20
注解配置是Spring框架的一种简化配置手段，它允许开发者通过在类或方法上添加特定的注解，替代传统的XML配置文件，使得代码更加简洁且易于维护。 首先，我们需要理解Spring配置文件的作用。在早期的Spring版本中，...
Spring自动加载指定路径规则的文件--PathMatchingResourcePatternResolver
weixin_34197488的博客
04-19 607
使用场景： 　　根据配置路径自动加载符合路径规则的xml文件、类文件等等； 　　查找范围：当前工程，当前工程依赖的jar包； 示例： public void testGetResources(){ ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver(...
java jaxb 注解_JAXB解析XML的几个常用注解用法讲解
weixin_33277215的博客
02-24 3378
JAXB(即Java Architecturefor XML Binding)是一个业界的标准，即是一项可以根据XML Schema产生Java类的技术。该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。下面对JAXB中的几个常用注解做一下讲解说明，抛砖引玉，有不足之处，还望指出。1.@XmlRootElement将一个Jav...
面试常见问题丨深入解析Spring中Bean的整个初始化过程
威哥爱编程，一个坚持研究技术的80后老鸟，擅长后端、AI 大模型、鸿蒙等技术体系，愿与你在技术路上一起成长！
07-01 937
原创 千锋侯哥一. 前言在面试过程中，经常有小伙伴会被问到Spring中Bean的生命周期，如果对Spring不了解可能对此类问题难以下手，就算通过百度查询到答案，也可能因为不理解而难以记忆，过段时间又忘记了，那么今天千锋侯哥就带小伙伴深入的解析下Spring中Bean的整个初始化过程。二. IOC容器的初始化过程我们都知道，IOC容器初始化时会进行各种Bean的初始化（单例非懒加载），因此在了解Bean的生命周期之前，我们先来看一下IOC容器的整个初始化过程。我们先整体看下流程图，做到心中有数，理解无误。
Spring中@Component，@Service等注解如何被解析？
Java笔记虾
07-25 2664
本文来源：http://8rr.co/EjqL这个系列分为5篇，这是首篇1.@Component，@Service等注解是如何被解析的2.@Enableq驱动原理3.@EnableAut...
关于Spring加载classpath与classpath*的过程剖析
热门推荐
老张
07-12 4万+
提到Spring配置文件，我不知道各位想到的是什么，首先浮现在我脑海里面的就是classpath 和 classpath*。    网上有很多关于这个2个前缀分别能读到那些资源文件的文章，但是我相信仍然有大部分同学是迷糊的，或者说知其然不知其所以然。那么这篇文章就带你走进Spring源码，让你知其然，更知其所以然。    关于Spring Resource的资源类型以及继承体系我们已经在上一篇
Spring源码研究之注解扫描<context:component-scan/>
夫礼者的专栏
10-02 8952
虽然在两年前已跟随《Spring源码深度解析》一书看过Spring源码的核心实现, 但就注解这块的解析一直没有时间了解. 导致每次碰到此类问题时心理没有底气. 这种感觉着实让人不爽, 加之距离上次阅读源码已过去比较长时间了, 所以也借机再次领略下Spring里的精妙设计, 体会OOP理念以及设计模式的实际应用。
Spring&Mybaits数据库配置解惑
加多的博客
07-14 3774
一、前言 一般我们会在datasource.xml中进行如下配置，但是其中每个配置项原理和用途是什么，并不是那么清楚，如果不清楚的话，在使用时候就很有可能会遇到坑，所以下面对这些配置项进行一一解说 （1）配置数据源 ?xml version="1.0" encoding="UTF-8" standalone="no"?&gt; &lt;beans xmlns="http://www.spr...
Spring - 注解解析器
u011614717的博客
08-13 7440
Spring Boot-注解解析器 Spring中使用了大量自定义的注解，如果通过我们自定义的注解解析器可能达不到预想的效果，必须使用Spring的AnnotationUtils.java类来获取方可正确解析。 一、自定义注解解析器解析Spring中的@AliasFor注解 @AliasFor注解是Spring中自定义的设置方法设置别名的注解，原理可查看：https://blog.c...
Spring 是解析配置类过程详解
勇往直前的专栏
07-08 486
Spring执行流程图如下： Spring执行流程图这个流程图会随着我们的学习不断的变得越来越详细，也会越来越复杂，希望在这个过程中我们都能朝着精通Spring的目标不断前进！  在上篇文章我们学习了Spring中的第一行代码，我们已经知道了Spring中的第一行代码其实就是创建了一个AnnotatedBeanDefinitionReader对象，这个对象的主要作用就是注册bd（BeanDefinition）到容器中。并且在创建这个对象的过程中，Spring还为容器注册了开天辟地的几个bd，包括Con

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值