Spring5 源码阅读笔记（1.1.2）delegate.parseCustomElement(ele) 自定义标签的解析和注册

最新推荐文章于 2022-04-10 20:52:00 发布
最新推荐文章于 2022-04-10 20:52:00 发布
阅读量420 收藏
点赞数 1
分类专栏： # refresh()
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44367006/article/details/104358862
版权

本节会揭晓：
自定义标签解析流程和注册过程
重点：< context:component-scan > 的解析
正是由于对这个自定义标签的解析，Spring 有了@Component，@Lazy，@DependOn，@Primary，@Role，@Description，@PostConstruct，@PreDestroy，@Resource，@Autowired，@Value 的支持

前面的文章 Spring5 源码阅读笔记（1.1）obtainFreshBeanFactory() 末尾介绍到了默认标签解析和自定义标签解析。

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)) {

					//默认标签解析
					parseDefaultElement(ele, delegate);
				}
				else {

					//自定义标签解析
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

默认标签解析已经分析过了，见文章 Spring5 源码阅读笔记（1.1.1）parseDefaultElement(ele, delegate) 默认标签的解析和注册。

跟 parseCustomElement ：
类 BeanDefinitionParserDelegate
在这里插入图片描述
跟 parseCustomElement ：

@Nullable
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));
}

关于 NamespaceHandler 如果不了解，可以看这篇文章：从源码角度解读 xml 文件中的 xmlns、xsi、xsd

跟 parse ：
类 NamespaceHandler
在这里插入图片描述

在这里插入图片描述
跟 parse ：
类 BeanDefinitionParser
在这里插入图片描述
我们重点看 ComponentScanBeanDefinitionParser：
这个类对应< context:component-scan > 这个标签

/*
* 1、扫描路径。.class后缀的文件
* 2、要判断类上是否有注解 @Component
* 3、对于有注解的类，创建对应的 BeanDefinition
* 4、完成 BeanDefinition 注册
* 5、完成某些组件的注册
* */
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//获取basePackage属性
	String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
	basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
	//可以用逗号分开
	String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
			ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

	//重要程度 2 创建注解扫描器 就是这里面支持了@Component
	// Actually scan for bean definitions and register them. 见1.1.2.1
	ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
	//重要程度 5 扫描并把扫描的类封装成beanDefinition对象并注册 见1.1.2.2
	Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
	//重要程度 5 注册 见1.1.2.3
	registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

	return null;
}
1.1.2.1 configureScanner
protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
	//使用默认的过滤器
	boolean useDefaultFilters = true;
	
	if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
		useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
	}

	//创建注解的扫描器
	// Delegate bean definition registration to scanner class.
	ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
	scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
	scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());

	if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
		scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
	}

	try {
		parseBeanNameGenerator(element, scanner);
	}
	catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}

	try {
		parseScope(element, scanner);
	}
	catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}

	parseTypeFilters(element, scanner, parserContext);

	return scanner;
}

跟 createScanner：

protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
	return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters,
			readerContext.getEnvironment(), readerContext.getResourceLoader());
}

跟 ClassPathBeanDefinitionScanner ：

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, @Nullable ResourceLoader resourceLoader) {

	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	this.registry = registry;

	//使用默认的过滤器
	if (useDefaultFilters) {
		//@Component
		registerDefaultFilters();
	}
	setEnvironment(environment);
	setResourceLoader(resourceLoader);
}

跟 registerDefaultFilters ：
类 ClassPathScanningCandidateComponentProvider，上面那个类的父类

protected void registerDefaultFilters() {
	//注意这里，说明了要扫描的注解是 Component。具体的说是 includeFilters 里包含了 Component
	this.includeFilters.add(new AnnotationTypeFilter(Component.class));
	ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
	try {
		this.includeFilters.add(new AnnotationTypeFilter(
				((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
		logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
	}
	catch (ClassNotFoundException ex) {
		// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
	}
	try {
		this.includeFilters.add(new AnnotationTypeFilter(
				((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
		logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
	}
	catch (ClassNotFoundException ex) {
		// JSR-330 API not available - simply skip.
	}
}
1.1.2.2 doScan

类 ClassPathBeanDefinitionScanner

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) {
		//扫描到有注解的类并封装成BeanDefinition对象
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
		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);
			}
			if (candidate instanceof AnnotatedBeanDefinition) {
				//支持了@Lazy @DependOn @Primary @Role @Description
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			if (checkCandidate(beanName, candidate)) {
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				//这里不看
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				beanDefinitions.add(definitionHolder);

				//BeanDefinition 注册
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

可以看到这里和默认标签的 parseBeanDefinition 有点类似，核心是两步：
一、封装 BeanDefinition 对象
二、对 BeanDefinition 进行注册

第二步和前面默认标签的注册过程是一样的，就不跟代码了。主要看第一步：
跟 findCandidateComponents ：
类 ClassPathScanningCandidateComponentProvider
在这里插入图片描述
跟 scanCandidateComponents ：

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
	Set<BeanDefinition> candidates = new LinkedHashSet<>();
	try {
		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
				resolveBasePackage(basePackage) + '/' + this.resourcePattern;

		//这里递归寻找文件
		Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
		boolean traceEnabled = logger.isTraceEnabled();
		boolean debugEnabled = logger.isDebugEnabled();
		for (Resource resource : resources) {
			if (traceEnabled) {
				logger.trace("Scanning " + resource);
			}
			if (resource.isReadable()) {
				try {
					//包装了类的基本信息的对象
					MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
					//如果类上面有候选的注解，这里面可以看一下
					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);
							}
							candidates.add(sbd);
						}
						else {
							if (debugEnabled) {
								logger.debug("Ignored because not a concrete top-level class: " + resource);
							}
						}
					}
					else {
						if (traceEnabled) {
							logger.trace("Ignored because not matching any filter: " + resource);
						}
					}
				}
				catch (Throwable ex) {
					throw new BeanDefinitionStoreException(
							"Failed to read candidate component class: " + resource, ex);
				}
			}
			else {
				if (traceEnabled) {
					logger.trace("Ignored because not readable: " + resource);
				}
			}
		}
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
	}
	return candidates;
}

跟 isCandidateComponent ：

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
	for (TypeFilter tf : this.excludeFilters) {
		if (tf.match(metadataReader, getMetadataReaderFactory())) {
			return false;
		}
	}
	//前面出现过的 includeFilters 这里又出现了，这里面就有 Component 注解
	for (TypeFilter tf : this.includeFilters) {
		if (tf.match(metadataReader, getMetadataReaderFactory())) {
			return isConditionMatch(metadataReader);
		}
	}
	return false;
}

看完上面的源码，我们就可以知道了为什么加了 < context:component-scan base-package=""> 标签，spring 就会扫描包下的 @Component 注解。

下面这个方法可以放到后面看，会与1.4.2产生联系。

1.1.2.3 registerComponents
protected void registerComponents(
		XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

	Object source = readerContext.extractSource(element);
	CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);

	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.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
	}
	if (annotationConfig) {

		//注册了几个比较重要的BeanPostProcessor类
		//ConfigurationClassPostProcessor,AutowiredAnnotationBeanPostProcessor,CommonAnnotationBeanPostProcessor
		Set<BeanDefinitionHolder> processorDefinitions =
				AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
		for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
		}
	}

	readerContext.fireComponentRegistered(compositeDef);
}

跟 registerAnnotationConfigProcessors：
类 org.springframework.context.annotation.AnnotationConfigUtils

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, @Nullable Object source) {

	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);

	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));
	}

	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));
	}

	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	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;
}

跟 registerPostProcessor：

private static BeanDefinitionHolder registerPostProcessor(
		BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

	definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	//这个方法在1.1.1节已经看过了，这里就注册到了beanFactory中，
	//这里并还没有注册到beanPostProcessors里，那一步是在1.3节里
	registry.registerBeanDefinition(beanName, definition);
	return new BeanDefinitionHolder(definition, beanName);
}

再回过头看一下ConfigurationClassPostProcessor,AutowiredAnnotationBeanPostProcessor,CommonAnnotationBeanPostProcessor 这三个类实现了什么：
它们都在 org.springframework.context.annotation 包下

ConfigurationClassPostProcessor：
在这里插入图片描述
见 Spring5 源码阅读笔记（2）AnnotationConfigApplicationContext 有更详细的介绍
AutowiredAnnotationBeanPostProcessor：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
见 Spring5 源码阅读笔记（1.4.2.2）applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) 有更详细的介绍

CommonAnnotationBeanPostProcessor ：
在这里插入图片描述
注意这个 InstantiationAwareBeanPostProcessor，它会在 1.3 末尾出现，继而与 1.4.2.1 产生联系。

对注解的支持：
对 @Autowired @Value 的支持
在这里插入图片描述
对 @PostConstruct，@PreDestroy 的支持
在这里插入图片描述
对 @Resource 的支持见1.4.2.2

见 Spring5 源码阅读笔记（1.4.2.2）applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) 有更详细的介绍

君莫笑(๑˙ー˙๑)
关注
专栏目录
jstl-1.1.2.jar（及源码）、standard-1.1.2.jar（及源码）
12-03
Standard库是JSTL的一部分，它实现了EL（Expression Language）表达式解析器，同时也包含了JSTL Core和XML标签的实现。标准库是JSTL运行的必要依赖。 5. **Standard-1.1.2-sources.jar** 同样，这个文件提供了...
5.SpringMVC源码关于annotation扫描3
拯救大白程序猿的博客
04-25 758
扫描器加载basePackages 再次回顾，ComponentScanBeanDefinitionParser这个类中的parse()，之前描述了配置扫描器configureScanner()，我们接着了解一下扫描器是如何加载这些包类的。 @Override public BeanDefinition parse(Element element, ParserContext parserC...
SpringMVC 源代码深度解析<context:component-scan>（扫描和注册的注解Bean）
在前进的路上
11-05 9793
们在SpringMVC开发项目中，有的用注解和XML配置Bean,这两种都各有自己的优势，数据源配置比较经常用XML配置，控制层依赖的service比较经常用注解等（在部署时比较不会改变的），我们经常比较常用的注解有@Component是通用标注，@Controller标注web控制器，@Service标注Servicec层的服务，@Respository标注DAO层的数据访问。SpringMVC启动时怎么被自动扫描然后解析并注册到Bean工厂中去（放到DefaultListableBeanFactory中
Spring扫描类过程解析和案例
qq_28834355的博客
03-03 1402
1. 前言
一、spring中委派模式
简单的坚持的专栏
04-13 927
委派模式（Delegate Patter）行为模式，代理模式注重过程，而委派模式注重结果。 在spring中的体现：Spring MVC框架中的DispatcherServlet其实就用到了委派模式。 委派模式的作用： 基本作用就是负责任务的调用和分配任务，跟代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是代理模式注重过程，而委派模式注重结果 日常中委派模式例子：boss把...
【Spring实战】Spring注解配置工作原理源码解析
热门推荐
honghailiang的专栏
07-12 1万+
一、背景知识在【Spring实战】Spring容器初始化完成后执行初始化数据方法一文中说要分析其实现原理，于是就从源码中寻找答案，看源码容易跑偏，因此应当有个主线，或者带着问题、目标去看，这样才能最大限度的提升自身代码水平。由于上文中大部分都基于注解进行设置的（Spring实战系列篇demo大部分也都是基于注解实现的），因此就想弄明白Spring中注解是怎么工作的，这个也是分析上文中实现原理的一个
spring-cloud-kubernetes-1.1.2.RELEASE.tar.gz
06-15
《Spring Cloud Kubernetes 1.1.2.RELEASE：在Kubernetes上构建微服务的深度解析》 Spring Cloud Kubernetes（简称SCK）是Spring Cloud生态体系中的一个重要组件，它为开发者提供了一种在Kubernetes（k8s）环境中...
ueditor-1.1.2.jar（自定义文件上传和下载图片回显）
01-10
在使用百度UEditor使时遇到图片上传，文件保存会默认保存在webapp下，每当重启项目上传的资源会被清空，这里采用修改ueditor源码方式解决上传文件到服务器指定地址，并完成图片的回显和附件的下载.使用方法在config....
SpringCodeReadingNotes:Spring源码阅读笔记-spring源码阅读
03-24
Spring源码阅读笔记 以Spring 4.2.9版本为基础，进行以下探索。 1.1 Spring是如何处理事务的 即先@Transactional注解是如何完成的。我们先创建一个类TestService，加上@Service和@Transactional注解，随便写一个保存...
基于PHP的think仓储管理系统PHPv1.1.2源码.zip
最新发布
08-29
5. **错误处理与日志记录**：系统运行过程中难免会出现错误，ThinkPHP提供了一套完善的异常处理和日志记录机制，帮助开发者定位并解决问题。 6. **性能优化**：通过缓存机制，如文件缓存、Memcached或Redis等，...
Spring源码解读（十二）通过包路径扫描Bean——ClassPathBeanDefinitionScanner
lishuzhen5678的博客
04-10 1241
前言 spring解析Bean通常通过 读取x...
解决:javax.annotation.ManagedBean' found and supported for component scanning问题
黑崎一护父
04-09 5752
今天将负责的项目从jdk7升级到jdk8,启动正常,但是访问时候出现了这个错误,记录下来防止以后以后遇到不知道啥原因. org.springframework.context.annotation.ClassPathBeanDefinitionScanner JSR-250 ‘javax.annotation.ManagedBean’ found and supported for compone...
Spring 基于ClassPathXmlApplicationContext的初始化流程03-xml自定义标签解析过程
eighthspace的专栏
02-02 288
本文中主要记录Spring自定义标签的解析过程，我们先回到标签解析的方法中 DefaultBeanDefinitionDocumentReader protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChild
spring中delegate的使用
山,在那边
01-16 2401
 在实际使用的时候,MultiActionController的使用不是在>中介绍的那种方法(会spring的都应该知道那本书吧^V^),转而是使用delegate.其实delegate的使用和书中介绍的方法差不多,下面就来介绍它的使用,一个很入门的例子:首先在你的spring的配制文件里(例如example-servlet.xml里)写入如下代码                      act
spring 源码分析 学习总结
dcxmaozi的博客
11-19 231
spring源码解析和时序图 IOC容器创建主要分为创建容器、 bean的扫描、容器初始化、获取bean、创建bean几个步骤，下面以AnnotationConfigApplicationContext（）容器初始化为入口解析整个IOC容器创建的过程。 1、创建容器 容器创建测试代码入口 public static void main(String[] args) { ...
好玩Spring之委派模式在Spring中的应用
yuan882696yan的专栏
02-27 523
委派模式 它不属于23中模式，我理解其实就是有个中间角色进行派活的过程，是一种派活的模式。-- 委托安排 Java双亲委派 说起委派，可能更容易想到的是Java双亲委派，没错，它确实也是委派模式。 在spring中应用 那么在Spring中又有哪些地方用到了委派模式呢？ 在bean中的应用 在MVC中的应用 ......
Spring整合MyBatis(二)源码分析
u012291108的博客
07-18 4249
在Spring配置Mybatis的文件中我们可以看到如下代码： MapperScannerConfigurer，让它扫描特定的包，自动帮我们成批地创建映射器。这样就大大减少了配置的工作量。 basePackage属性是让你为映射器接口文件设置基本的包路径。可以使用分号或逗号作为分隔符设置多于一个的包路径。每个映射器都会在指定的包路径中递归地被搜索到。被发现的映射器将会使用Spri
Spring配置解析之Component-scan解析
NYNYNY
11-15 3217
*基于3.1.2进行源码解析. 首先看一段项目中关于component-scan的配置： &lt;context:component-scan base-package="com.suning.rsc.server,com.suning.uops"&gt; &lt;context:exclude-filter type="annotation" expressio...
Delegate类简介
panyanyan的专栏
06-25 556
Delegate类简介------------------------ 命名空间:System程序集:mscorlib（在 mscorlib.dll 中） 委托(Delegate)类是一种数据结构，通过它可引用静态方法或引用类实例及该类的实例方法。 以往的界面编程中我们应该都接触过各种类型的事件驱动（event driven）的处理模式，在这种模式里，我们定义相应事件触发的函数。例如
利用jstl自定义标签与EL表达式实现配置文件管理
在Servletweb.xml配置文件中，对于版本2.4，你需要确保正确的命名空间引用和标签声明，例如： ```xml <web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值