spring源码加载bean定义信息 loadBeanDefinitions-自定义标签解析（component-scan-2）

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量564 收藏 1
点赞数
分类专栏： 源码 spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaomengxin521/article/details/123474810
版权

上篇传送门
上篇大体了解了下执行BFPP的过程，BFPP的作用也介绍了，但是并没有深入看下如何实现的，接下来咱们了解下context:component-scan 标签是如何解析的

概述

咱们开发过程中会使用到很多的注解配置等，这些注解必须要被扫描到才能被识别

spring中标签分为几种

分为两种

  1. 标签
  2. 自定义标签（除了bean标签外）
源码之前先了解两个类
  1. DefaultBeanDefinitionDocumentReader 调度者
  2. BeanDefinitionParserDelegate 解析策略类用于策略模式的指令执行者
  3. NamespaceHandler 策略抽象，用于制定规范

源码

咱们继续回到DefaultBeanDefinitionDocumentReader.parseBeanDefinitions方法

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)) {
			//只有解析bean标签的时候才是默认标签，其他事自定义标签
			//解析bean标签
			parseDefaultElement(ele, delegate);
		}else {
			//使用策略类解析自定义标签
			delegate.parseCustomElement(ele);
		}
	}
}
BeanDefinitionParserDelegate.parseCustomElement 解析自定义标签，使用策略模式
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	//根据节点名称获取对应命名空间
	String namespaceUri = getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	}
	//获取处理器
	//具体在spring-context/resources/spring.handlers文件中配置
	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
	if (handler == null) {
		return null;
	}
	//使用处理器进行解析
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
DefaultNamespaceHandlerResolver.resolve 得到对应的命令空间的处理器
public NamespaceHandler resolve(String namespaceUri) {
	//获取spring-context/META-INF/spring.handlers文件中的缓存
	Map<String, Object> handlerMappings = getHandlerMappings();
	Object handlerOrClassName = handlerMappings.get(namespaceUri);
	if (handlerOrClassName == null) {
		return null;
	}else if (handlerOrClassName instanceof NamespaceHandler) {
		//如果实例化过了
		return (NamespaceHandler) handlerOrClassName;
	}else {
		String className = (String) handlerOrClassName;
		try {
			Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
			if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
				throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
			}
			//实例化
			NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
			//初始化
			namespaceHandler.init();
			//替换缓存中的value为对象
			handlerMappings.put(namespaceUri, namespaceHandler);
			return namespaceHandler;
		}catch (ClassNotFoundException ex) {
			throw new FatalBeanException("Could not find NamespaceHandler class [" + className +"] for namespace [" + namespaceUri + "]", ex);
		}
		catch (LinkageError err) {
			throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +className + "] for namespace [" + namespaceUri + "]", err);
		}
	}
}
NamespaceHandlerSupport.parse 使用处理器解析元素标签（使用策略模式）
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//获取到标签的解析器 从ContextNamespaceHandler里面获取
	BeanDefinitionParser parser = findParserForElement(element, parserContext);
	return (parser != null ? parser.parse(element, parserContext) : null);
}
NamespaceHandlerSupport.parse 使用处理器解析元素标签

在这里插入图片描述

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
	//元素标签的名称
	String localName = parserContext.getDelegate().getLocalName(element);
	//从ContextNamespaceHandler里面定义的多个标签中获取出对应的解析类
	//这里获取到的是ComponentScanBeanDefinitionParser
	BeanDefinitionParser parser = this.parsers.get(localName);
	if (parser == null) {
		parserContext.getReaderContext().fatal(
				"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
	}
	return parser;
}
ComponentScanBeanDefinitionParser.parse 真正开始解析了
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//获取包扫描路径
	String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
	//使用PropertyPlaceholderHelper处理包路径
	//处理${}占位符
	basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
	//使用分隔符分割，就是咱们可以在package中写多个路径 如：“com.msg.package2,;com.msg.package2”
	String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
	// 配置扫描器
	ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
	// 开始扫描，并创建出BeanDefinitionHolder
	Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
	//开始注册组件
	registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
	return null;
}
ComponentScanBeanDefinitionParser.configureScanner 配置扫描器
protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
	boolean useDefaultFilters = true;
	if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
		useDefaultFilters = Boolean.parseBoolean(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
	}

	// 创建一个ClassPathBeanDefinitionScanner类路径扫描器并设置相应的属性
	ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
	//设置BeanDefinitionDefaults对象
	scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
	scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
	if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
		scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
	}
	try {
		// 如果指定了 name-generator 属性，设置对应bean名称的生成器 如：<bean class=“xxx.xxx.xxx”> 这个类创建完成后对应的名字是什么（就是id值）
		parseBeanNameGenerator(element, scanner);
	}catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}
	try {
		// 设置 Scope 解析相关信息
		<context:component-scan base-package="com">
			<context:exclude-filter type="annotation" expression="com.msg"/>
			<context:include-filter type="annotation" expression="com.msg"/>
		</context:component-scan>
		parseScope(element, scanner);
	}catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}
	// 设置子标签过滤、包含相关信息
	parseTypeFilters(element, scanner, parserContext);
	return scanner;
}
ClassPathBeanDefinitionScanner.doScan 执行扫描

在这里插入图片描述

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	Assert.notEmpty(basePackages, "At least one base package must be specified");
	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
	for (String basePackage : basePackages) {
		// 找到符合条件的Component组件（类上标注了@Component注解）
		//classpath*:com/msgqu/debug/**/*.class
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
		for (BeanDefinition candidate : candidates) {
			// 解析作用域及是否需要代理作用域
			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
			candidate.setScope(scopeMetadata.getScopeName());
			//生成bean的名称（AnnotationBeanNameGenerator）
			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
			if (candidate instanceof AbstractBeanDefinition) {
				//设置基本属性，lazy、AutowireMode...
				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
			}
			if (candidate instanceof AnnotatedBeanDefinition) {
				//设置注解信息 Lazy、Primary、DependsOn、Role、Description
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			// 检查是否符合条件 如：是不是已经注册过了
			if (checkCandidate(beanName, candidate)) {
				// 创建bean定义信息的包装类
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				// 如果需要代理，重新生成definitionHolder
				definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				//记录扫描后的容器中返回
				beanDefinitions.add(definitionHolder);
				//注册bean定义信息到工厂中
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}
ComponentScanBeanDefinitionParser.registerComponents 注册必要的组件
protected void registerComponents(XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

		Object source = readerContext.extractSource(element);
		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
		//创建内部bean以及引用
		for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
		}

		// Register annotation config processors, if necessary.
		boolean annotationConfig = true;
		if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
			annotationConfig = Boolean.parseBoolean(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
		}
		if (annotationConfig) {
			//注册内部使用的定义信息
			Set<BeanDefinitionHolder> processorDefinitions = AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
			for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
				compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
			}
		}
		//扩展方法
		readerContext.fireComponentRegistered(compositeDef);
	}
AnnotationConfigUtils.registerAnnotationConfigProcessors 注册内部使用的对象

方法执行前
在这里插入图片描述
方法执行后
在这里插入图片描述

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
	//对bean工厂做配置
	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}
	//定义内部解析的定义信息
	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
	//ConfigurationClassPostProcessor是一个BeanFactory的后置处理器，因此它的主要功能是参与BeanFactory的建造，在这个类中，会解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import等注解
	//借博主的描述,后面咱们还会详细在invokBFPP方法中讲解
	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	//支持 @Autowired 和 @Value 注解的支持也支持 @Inject 注解，也可以给setter 方法进行注入。也包括对 @Lookup 注解解析
	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	//对@PostConstruct和@PreDestroy注解的处理，完成bean初始化前和销毁前的回调
	//对@Resource注解的处理，完成依赖字段的注入
	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition();
		try {
			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
					AnnotationConfigUtils.class.getClassLoader()));
		}catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
		}
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
	}
	return beanDefs;
}
奔跑的蜗牛...
关注
专栏目录
spring源码解析之AnnotationConfigWebApplicationContext#loadBeanDefinitions()方法加载BeanDefinition过程
蛐蛐的博客
10-13 1959
1.简介 AnnotationConfigWebApplicationContext是常用的上下文容器类，在spring boot没有流行的时候，以前用tomcat在web.xml配置 spring容器时，如果使用Java注解的配置类，一般都会使用这个上下文类 顾名思义，AnnotationConfig代表注解配置，Web代表具有web功能，可以访问ServletContext。这是这个上下文的基本功能。 之前在spring源码解析之AbstractApplicationContext#..
【Spring】Spring原理源码解析（四）-- Spring在解析配置类时，怎么识别并处理@Bean的
ArvinZsh的博客
09-01 224
该篇主要介绍spring在解析配置类时，是如何解析@Bean，构建BD注册到spring中的
老生谈spring（十一）：自定义标签之component-scan
JankeDeng的博客
09-15 350
资深小白谈spring（十一）：自定义标签之component-scan 1、上一节讲到了spring通过resolve方法解析spring.handlers文件得到context的解析类，现在接着来看resolve方法。反射得到这个handler类以后用BeanUtils创建这个类的实例，调用init方法后放到handlerMappings容器中。 2、以context:component-scan为例，我们知道context的命名空间是由ContextNamespaceHandler来负责处理的，那么我
spring源码----loadBeanDefinitions(DefaultListableBeanFactory)详解
Code-zyc的博客
03-30 1078
目录方法图片：new XmlBeanDefinitionReader接着往下执行这四个方法：loadBeanDefinitions(XmlBeanDefinitionReader）loadBeanDefinitions(String...)loadBeanDefinitions(String）loadBeanDefinitions(String,@Nullable Set《Resource》）loadBeanDefinitions(Resource...） 方法图片： 首先执行第一个方法： new Xml
spring源码aop解析xml生成bean定义信息
蜗牛也需要奔跑
05-10 239
spring面向切面编程是咱们工作中使用比较频繁的一项技术，比如：日志、事务、表单重复提交等 了解aop之前需要先了解几个概念 什么是aspect ：切面 什么是连接点：切面方法 切入点表达式：用于过滤目标方法的过滤器 什么是织入：所有切面方法的总称 什么是目标方法：被代理的对象方法 看下AOP处理器 public class AopNamespaceHandler extends NamespaceHandlerSupport { @Override public void init() {
java 自定义注解 解析器_Spring Boot自定义注解扫描器
weixin_39646970的博客
02-25 388
之前在整合Spring Boot和tkMybatis的时候使用了这个注解：这个还挺实用的，会将指定包下的相应的类加载至Spring容器中，刚好我这边也有一个独立抽取出来的权限模块也想实现这样的功能(当然可以使用@EnableXX的方式，但是注入的组件太多了，直接包扫描直接点)，而不是使用@ComponentScan或者是scanBasePackages必须指定某个包，这样显得太low了，使用注解自...
spring配置文件加载 loadBeanDefinitions分析
蓝天的博客
03-31 512
下面来分析loadBeanDefinitions方法，如下图： loadBeanDefinitions(beanFactory);，这里的beanFactory是对象DefaultListableBeanFactory，这个对象是具体实际干活的类， 重点看loadBeanDefinitions方法， 这里比较关键的是判断是否是默认的命名空间，如果是默认的命名空间则调用parseDefaultElement...
【Spring】Spring原理源码解析（三）-- Spring在解析配置类时，怎么识别并处理@Import类的
ArvinZsh的博客
08-19 233
本篇主要介绍了spring如何通过内置的bean工厂后置处理器，解析配置类上的@Import注解的
Spring 源码分析（2）--SpringIoC源码分析
aidaowuqiong的博客
10-15 604
SpringIoC 初始化整体流程的跟踪，篇幅较长，耐心看完，肯定有惊喜。
逐行解读Spring（一） - Xml配置解析，bean标签的解析
github_37947909的博客
07-02 458
目录一、前言二、一个简单的示例三、源码解析1. beanDefinition注册流程2. bean标签解析四、总结 一、前言 最近在看spring源码，发现之前看的很多细节已经忘了，于是决定在看源码的过程中也把主要的流程用博客记载下来，希望自己能坚持下来吧。 spring已经发展很久，整个体系已经变得很庞大了。为了能更好的把源码看下去，我决定从最基础也是最核心的IOC开始切入，并且从最原始的xml解析开始看。面对这样一个庞大的体系，我认为从最原始的方式开始学习，才能更好的看懂它的设计和实现思路。 这一系列文
Spring源码讲解之 loadBeanDefinitions 方法
misterhou的专栏
08-07 852
loadBeanDefinitions 方法在 org.springframework.context.support.AbstractRefreshableApplicationContext 类中被定义，用来将 bean 定义信息加载到 bean 工厂中，该方法会在 org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory() 方法中被调用，调用该方法需要传递一个 org.sp
spring ioc源码讲解之加载BeanDefinition
修理男爵的博客
08-17 915
spring ioc大致流程 首先我们看一张 spring ioc的大致流程图： 流程大致说明： 加载 bean定义信息（BeanDefinition），来源可能是 XML、注解等等 通过 BeanFactoryPostProcessor 对BeanDefinition做一些事情 实例化 bean对象 在 bean初始化前，通过 BeanPostProcessor对 bean对象做一些事情 初始化 bean对象 在 bean初始化后，通过 BeanPostProce...
完全搞懂Spring的BeanDefintion和加载自定义BeanDefintion
qq_28136919的博客
05-11 898
一、什么是BeanDefinition BeanDefinition描述了Bean的定义,包括该bean有哪些属性、构造函数参数、作用域、是否是抽象的等. 在Spring中是根据BeanDefinition来创建Bean的. BeanDefinition是Spring非常核心的概念. 1.1.BeanDefinition源码介绍 public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { /**
Spring源码解读(2) 启动流程的那点事儿-refresh方法详解之loadBeanDefinitions
贾贾贾贾念文的博客丶
05-07 1913
承接上文https://mp.csdn.net/postedit/80216629，我们开始具体的讲解refresh方法。在该篇文章中，我们只讲解一些比较重要的方法。AbstractApplicationContext实现了ConfigurableApplicationContext接口，并重写了模板方法：refresh方法。在该方法里，会完成加载资源、配置文件解析、Bean定义的注册、组件的初始...
spring读取bean的定义信息
m0_49708063的博客
03-05 411
我们都知道spring要创建bean之前需要先在xml文件中读取到bean的定义信息，里面有着每个bean的相关的属性已经很多东西： 1.首先创建我们的bean处理器相关的 2.遍历资源对象 3.获取输入流，并且把xml文件转换为Document对象 4.解析document对象 可能大家会疑惑为什么我们有xmlBeanDefinitionReader还要创建这么多的reader这不是多此一举吗，不如不创建xmlBeanDefinitionReader？首先，我们的xmlBeanDefinit
三、SpringIOC源码之XmlBeanFactory
【原】编程界的小学生
10-01 424
SpringIOC源码之XmlBeanFactory 一、概述 1、说明 XmlBeanFactory是实现ioc方式之一，是那种比较屌丝的，功能对比ApplicationContext来讲差太多了。SpringIOC主要是如下三步骤 定位：说白了就是找到我们传递进去的xml文件。 加载：找到我们的xml文件位置后，将其解析成BeanDefinition对象。 注册：将bean对象放到ioc的工...
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 291
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
spring -第十四章 spring事务
m0_74606902的博客
11-11 599
要在spring中实现事务有两种方式编程式事务：编写代码手动的开启、提交、回滚事务。声明式事务：使用注解或xml配置文件进行事务管理。
SpringBoot助力的共享汽车业务优化系统
2402_85762143的博客
11-09 1094
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
深入解析Spring自定义标签的源码机制
标签信息: "Spring源码", "自定义标签解析", "XML配置", "BeanDefinition", "NamespaceHandler", "BeanDefinitionParserDelegate", "XmlBeanDefinitionReader", "BeanDefinitionRegistry", "BeanFactory" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值