- 浏览: 50204 次
- 性别:
- 来自: 南京
文章分类
最新评论
本章探讨从document到beanDefinition的过程-注册beanDefinition到容器beanDefinitionMap中
从xml到document
从document到beanDefinition
从beanDefiniton到instance
涉及到的部分主要类或接口:
org.springframework.beans.factory.xml.BeanDefinitionDocumentReader
org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
org.springframework.beans.factory.support.BeanDefinitionReaderUtils
org.springframework.beans.factory.config.BeanDefinition
org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver
从document到beanDefinition
<bean>的解析
从最直接的xml配置开始<bean>
对于像事务tx:annotation等标签在spring-tx.jar/META-INF/spring.handlers下有配置具体的处理类。bean是不是也有一样的配置呢,其实不然,我们找到解析注册标签的入口。
省略从web.xml加载到doc的过程,从解析Element root = doc.getDocumentElement()开始
解析根节点root的任务由DefaultBeanDefinitionDocumentReader开始
DefaultBeanDefinitionDocumentReader源码:
http://www.grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java/
DefaultBeanDefinitionDocumentReader.parseBeanDefinitions
对于默认的标签,如"import", "alias", "bean" 在parseDefaultElement处开始解析。非默认的标签需定义schema/handlers进行处理。
查看默认标签的处理方法:
DefaultBeanDefinitionDocumentReader#parseDefaultElement
继续bean标签的处理BEAN_ELEMENT:
DefaultBeanDefinitionDocumentReader#processBeanDefinition
从以上代码可以看到,DefaultBeanDefinitionDocumentReader将解析生成beanDefinition的任务委托给了BeanDefinitionParserDelegate进行处理。
beanDefinitionDocumentReader
-------------------------------------------------------承上启下的分割线----------------------------------------------
beanDefinitionParserDelegate
BeanDefinitionParserDelegate源码:
http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java#BeanDefinitionParserDelegate
由上可知,处理bean标签分3个部分:
一是解析bean标签生成BeanDefinitionHolder-处理spring默认元素或属性
BeanDefinitionParserDelegate#parseBeanDefinitionElement
可以看到,先生成beanDefinition再包装成beanDefinitionHolder
(1)生成beanDefinition的过程
BeanDefinitionParserDelegate#createBeanDefinition
创建GenericBeanDefinition
BeanDefinitionReaderUtils#createBeanDefinition
这里可以发挥你的想象力。就像平时定义了一个model,然后设置各种属性的过程。这里处理的属性或子标签都是spring默认定义的属性或标签,自定义的标签会在第二步进行处理
bd.setBeanClass涉及到从benDefintion到instance的一个处理过程:resolveBeanClass
如果这里设置了beanClass,resolveBeanClass可以直接返回。
那这里会不会设置beanClass呢?
关键点是this.readerContext.getBeanClassLoader(),其里面继续调用XmlBeanDefinitionReader.getBeanClassLoader();
查看<spring源码学习系列2.1-从xml到document>创建XmlBeanDefinitionReader对象时,并没有设置beanClassLoader的值
这里定义的beanDefinition的实际类是GenericBeanDefinition,在从beanDefinition到instance的过程中,会转为RootBeanDefinition
平常我们只会设置几个熟悉的属性,其实beanDefinition中有很多属性,
例如:lookup-method replace-method等
spring是如何解析这些特殊属性或标签的来生成实例的呢?
其他属性可查看BeanDefinitionParserDelegate的源码,其用静态变量基本定义了所有属性
(2)此时生成的beanDefinitionHolder对象也很简单,只是存储了beanDefinition及其名称等
二是装饰第一步生成的BeanDefinitionHolder对象-处理自定义标签或属性-可以看做spring的一种扩展-对spring的默认标签进行扩展
// Decorate based on custom attributes first.
NamedNodeMap attributes = ele.getAttributes();
// Decorate based on custom nested elements.
NodeList children = ele.getChildNodes();
这里继续循环bean标签的属性或子标签,难道是继续对第一步的属性进行深入处理?其实不然,继续跟到decorateIfRequired方法中看看
这段代码中,有个很重要的分子判断!isDefaultNamespace(namespaceUri),即是否是自定义标签,如果不是则继续获取相应命名空间处理类进行解析
可见装饰主要是对自定义子标签或属性的解析过程-对spring bean标签的扩展
this.readerContext.getNamespaceHandlerResolver()获取的是DefaultNamespaceHandlerResolver,其主要职责是管理命名空间处理器的。其数据来源主要是META-INF/spring.handlers下的内容,加载这些文件用到了懒加载机制(Load the specified NamespaceHandler mappings lazily)
resolve方法中,首先加载META-INF/spring.handler文件:
并将其Properties类中的文件,转换为hashMap缓存起来:
再就是根据命名空间,读取相应命名空间处理器,并初始化返回:
将namespaceHandler放入handlerMappings中(之前将Properties转换为hashMap,value值只是string类型的)
可跟踪源代码,借鉴spring是如何读取配置文件的
DefaultNamespaceHandlerResolver源码:
http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/DefaultNamespaceHandlerResolver.java/
三是注册到beanDefinition容器
这里registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());实际上就是放到DefaultListableBeanFactory.beanDefinitionMap中
至此,从document到beanDefinition分析结束
从xml到document
从document到beanDefinition
从beanDefiniton到instance
涉及到的部分主要类或接口:
org.springframework.beans.factory.xml.BeanDefinitionDocumentReader
org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
org.springframework.beans.factory.support.BeanDefinitionReaderUtils
org.springframework.beans.factory.config.BeanDefinition
org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver
从document到beanDefinition
<bean>的解析
从最直接的xml配置开始<bean>
对于像事务tx:annotation等标签在spring-tx.jar/META-INF/spring.handlers下有配置具体的处理类。bean是不是也有一样的配置呢,其实不然,我们找到解析注册标签的入口。
省略从web.xml加载到doc的过程,从解析Element root = doc.getDocumentElement()开始
解析根节点root的任务由DefaultBeanDefinitionDocumentReader开始
DefaultBeanDefinitionDocumentReader源码:
http://www.grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java/
DefaultBeanDefinitionDocumentReader.parseBeanDefinitions
/** * Parse the elements at the root level in the document: * "import", "alias", "bean". * @param root the DOM root element of the document */ 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)) { //1.处理默认标签 parseDefaultElement(ele, delegate); } else { delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } }
对于默认的标签,如"import", "alias", "bean" 在parseDefaultElement处开始解析。非默认的标签需定义schema/handlers进行处理。
查看默认标签的处理方法:
DefaultBeanDefinitionDocumentReader#parseDefaultElement
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { //1.1 处理import标签 if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } //1.2 处理alias标签 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } //1.3 处理bean标签 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse doRegisterBeanDefinitions(ele); } }
继续bean标签的处理BEAN_ELEMENT:
DefaultBeanDefinitionDocumentReader#processBeanDefinition
/** * Process the given bean element, parsing the bean definition * and registering it with the registry. */ protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { //1.3.1 生成beanDefinitionHolder BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { //1.3.2 解析bean标签的自定义元素 //扩展BeanDefinition-自定义标签 bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { //1.3.3 注册beanDefinitionMap // Register the final decorated instance. BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex); } // Send registration event. getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } }
从以上代码可以看到,DefaultBeanDefinitionDocumentReader将解析生成beanDefinition的任务委托给了BeanDefinitionParserDelegate进行处理。
beanDefinitionDocumentReader
-------------------------------------------------------承上启下的分割线----------------------------------------------
beanDefinitionParserDelegate
BeanDefinitionParserDelegate源码:
http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java#BeanDefinitionParserDelegate
由上可知,处理bean标签分3个部分:
一是解析bean标签生成BeanDefinitionHolder-处理spring默认元素或属性
BeanDefinitionParserDelegate#parseBeanDefinitionElement
/** * Parses the supplied {@code <bean>} element. May return {@code null} * if there were errors during parse. Errors are reported to the * {@link org.springframework.beans.factory.parsing.ProblemReporter}. */ public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) { String id = ele.getAttribute(ID_ATTRIBUTE); String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); List<String> aliases = new ArrayList<String>(); if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } String beanName = id; if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); if (logger.isDebugEnabled()) { logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases"); } } if (containingBean == null) { checkNameUniqueness(beanName, aliases, ele); } AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { try { if (containingBean != null) { beanName = BeanDefinitionReaderUtils.generateBeanName( beanDefinition, this.readerContext.getRegistry(), true); } else { beanName = this.readerContext.generateBeanName(beanDefinition); // Register an alias for the plain bean class name, if still possible, // if the generator returned the class name plus a suffix. // This is expected for Spring 1.2/2.0 backwards compatibility. String beanClassName = beanDefinition.getBeanClassName(); if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) { aliases.add(beanClassName); } } if (logger.isDebugEnabled()) { logger.debug("Neither XML 'id' nor 'name' specified - " + "using generated bean name [" + beanName + "]"); } } catch (Exception ex) { error(ex.getMessage(), ele); return null; } } String[] aliasesArray = StringUtils.toStringArray(aliases); return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); } return null; }
可以看到,先生成beanDefinition再包装成beanDefinitionHolder
(1)生成beanDefinition的过程
BeanDefinitionParserDelegate#createBeanDefinition
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName) throws ClassNotFoundException { return BeanDefinitionReaderUtils.createBeanDefinition( parentName, className, this.readerContext.getBeanClassLoader()); }
创建GenericBeanDefinition
BeanDefinitionReaderUtils#createBeanDefinition
public static AbstractBeanDefinition createBeanDefinition( String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException { GenericBeanDefinition bd = new GenericBeanDefinition(); bd.setParentName(parentName); if (className != null) { if (classLoader != null) { bd.setBeanClass(ClassUtils.forName(className, classLoader)); } else { bd.setBeanClassName(className); } } return bd; }
这里可以发挥你的想象力。就像平时定义了一个model,然后设置各种属性的过程。这里处理的属性或子标签都是spring默认定义的属性或标签,自定义的标签会在第二步进行处理
bd.setBeanClass涉及到从benDefintion到instance的一个处理过程:resolveBeanClass
如果这里设置了beanClass,resolveBeanClass可以直接返回。
那这里会不会设置beanClass呢?
关键点是this.readerContext.getBeanClassLoader(),其里面继续调用XmlBeanDefinitionReader.getBeanClassLoader();
查看<spring源码学习系列2.1-从xml到document>创建XmlBeanDefinitionReader对象时,并没有设置beanClassLoader的值
这里定义的beanDefinition的实际类是GenericBeanDefinition,在从beanDefinition到instance的过程中,会转为RootBeanDefinition
平常我们只会设置几个熟悉的属性,其实beanDefinition中有很多属性,
例如:lookup-method replace-method等
spring是如何解析这些特殊属性或标签的来生成实例的呢?
其他属性可查看BeanDefinitionParserDelegate的源码,其用静态变量基本定义了所有属性
(2)此时生成的beanDefinitionHolder对象也很简单,只是存储了beanDefinition及其名称等
二是装饰第一步生成的BeanDefinitionHolder对象-处理自定义标签或属性-可以看做spring的一种扩展-对spring的默认标签进行扩展
public BeanDefinitionHolder decorateBeanDefinitionIfRequired( Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) { BeanDefinitionHolder finalDefinition = definitionHolder; // Decorate based on custom attributes first. NamedNodeMap attributes = ele.getAttributes(); for (int i = 0; i < attributes.getLength(); i++) { Node node = attributes.item(i); finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); } // Decorate based on custom nested elements. NodeList children = ele.getChildNodes(); for (int i = 0; i < children.getLength(); i++) { Node node = children.item(i); if (node.getNodeType() == Node.ELEMENT_NODE) { finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); } } return finalDefinition; }
// Decorate based on custom attributes first.
NamedNodeMap attributes = ele.getAttributes();
// Decorate based on custom nested elements.
NodeList children = ele.getChildNodes();
这里继续循环bean标签的属性或子标签,难道是继续对第一步的属性进行深入处理?其实不然,继续跟到decorateIfRequired方法中看看
private BeanDefinitionHolder decorateIfRequired( Node node, BeanDefinitionHolder originalDef, BeanDefinition containingBd) { String namespaceUri = getNamespaceURI(node); if (!isDefaultNamespace(namespaceUri)) { NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); if (handler != null) { return handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd)); } else if (namespaceUri != null && namespaceUri.startsWith("http://www.springframework.org/")) { error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node); } else { // A custom namespace, not to be handled by Spring - maybe "xml:...". if (logger.isDebugEnabled()) { logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]"); } } } return originalDef; }
这段代码中,有个很重要的分子判断!isDefaultNamespace(namespaceUri),即是否是自定义标签,如果不是则继续获取相应命名空间处理类进行解析
可见装饰主要是对自定义子标签或属性的解析过程-对spring bean标签的扩展
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
this.readerContext.getNamespaceHandlerResolver()获取的是DefaultNamespaceHandlerResolver,其主要职责是管理命名空间处理器的。其数据来源主要是META-INF/spring.handlers下的内容,加载这些文件用到了懒加载机制(Load the specified NamespaceHandler mappings lazily)
resolve方法中,首先加载META-INF/spring.handler文件:
Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
并将其Properties类中的文件,转换为hashMap缓存起来:
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
再就是根据命名空间,读取相应命名空间处理器,并初始化返回:
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
将namespaceHandler放入handlerMappings中(之前将Properties转换为hashMap,value值只是string类型的)
handlerMappings.put(namespaceUri, namespaceHandler);
可跟踪源代码,借鉴spring是如何读取配置文件的
DefaultNamespaceHandlerResolver源码:
http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/DefaultNamespaceHandlerResolver.java/
三是注册到beanDefinition容器
// Register the final decorated instance. BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
/** * Register the given bean definition with the given bean factory. * @param definitionHolder the bean definition including name and aliases * @param registry the bean factory to register with * @throws BeanDefinitionStoreException if registration failed */ public static void registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException { // Register bean definition under primary name. String beanName = definitionHolder.getBeanName(); registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // Register aliases for bean name, if any. String[] aliases = definitionHolder.getAliases(); if (aliases != null) { for (String aliase : aliases) { registry.registerAlias(beanName, aliase); } } }
这里registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());实际上就是放到DefaultListableBeanFactory.beanDefinitionMap中
至此,从document到beanDefinition分析结束
发表评论
-
spring疑难解惑-循环依赖的解决
2020-06-17 23:27 538AbstractAutowireCapableBeanFact ... -
spring容器
2019-07-14 08:47 305private final ServletContainer ... -
spring容器
2019-07-13 23:35 0spring容器与springmvc容器 73 ... -
spring源码学习系列2.6-spring ioc原理-codes
2019-03-05 22:56 487web.xml <listener> < ... -
spring源码学习系列3.4-spring mvc原理-codes
2019-01-21 22:46 296本篇章从核心类角度解读springmvc的原理 web.xm ... -
spring源码学习系列4.2-spring aop原理-codes
2018-12-04 22:29 560jdk: Proxy InvocationHandler ... -
spring源码学习系列4.1-spring实现对ibatis的事务管理
2018-09-17 15:44 576事务由spring管理,可以理解为由spring管理数据库连接 ... -
spring源码学习系列4-3种常用的自动代理创建器
2018-09-02 15:48 5693种自动代理器是 AnnotationAwareAspectJ ... -
spring源码学习系列1.2-spring事务代理深入分析2
2018-05-27 19:46 449提示: BeanPostProcessor AopUtils ... -
spring源码学习系列2.5-ApplicationContext初始化-设计模式
2018-05-08 15:17 517ApplicationContext容器的初始化可以通过模板方 ... -
spring源码学习系列3.3-DispatcherServlet初始化-设计模式
2018-05-07 11:12 619springmvc的核心是DispatcherServlet ... -
封装spring-security
2018-01-23 19:33 515github地址: https://github.com/ne ... -
eclipse导入spring源码
2018-05-12 07:20 978spring在git上的项目时gradle管理jar包的,所以 ... -
spring源码学习系列3.2.3-异常页面拦截机制
2017-07-29 19:07 766前序:本文的意义在于了解 tomcat处理异常 请求访问 ... -
spring源码学习系列3.2.2-How to bind String to Date
2017-07-17 12:40 596springmvc开发中,经常需将界面日期数据(String) ... -
spring源码学习系列3.2.1-command对象的绑定
2017-05-28 12:00 979在<spring源码学习系列3.2-handlerAda ... -
spring源码学习系列3.2-handlerAdapter执行
2017-05-28 12:01 409DispatcherServlet#doDispatch中调用 ... -
spring源码学习系列3.1-handlerMapping初始化
2017-05-28 11:56 698SimpleUrlHandlerMapping的继承体系 or ... -
spring源码学习系列2.4-finishRefresh会做什么
2017-05-06 16:36 573spring容器初始化完成后,调用finishRresh 该 ... -
spring源码学习系列3-springmvc原理
2017-05-28 11:56 455问题: springmvc是如何控 ...
相关推荐
在本案例中,"Spring源码编译缺少的两个包:spring-cglib-repack-3.2.0.jar和spring-objenesis-repack-2.2.jar"揭示了这两个关键的库对于Spring源码编译是必不可少的。下面将详细讲解这两个库的作用及其在Spring中的...
在Spring框架中,"工厂Bean"是一个非常关键的概念,它扩展了传统的Bean定义,使得我们可以在Spring IoC容器中创建自定义的实例化逻辑。工厂Bean允许开发者在对象实例化时进行更复杂的控制,比如引入特定的初始化过程...
基于java的开发源码-Message-Driven Bean EJB实例源代码.zip 基于java的开发源码-Message-Driven Bean EJB实例源代码.zip 基于java的开发源码-Message-Driven Bean EJB实例源代码.zip 基于java的开发源码-Message-...
Spring Ioc 源码分析系列--自动注入循环依赖的处理 本篇文章主要讲解了 Spring Ioc 源码分析系列中自动注入循环依赖的处理机制。循环依赖是 Spring 框架中一个经典的问题,也是面试中常被问到的问题。本篇文章将...
Spring Ioc源码分析系列--@Autowired注解的实现原理 @ Автоwired注解是 Spring Framework 中的一个重要组件,它提供了自动装配的功能,能够将 Bean 之间的依赖关系自动解析和注入。今天,我们将深入探讨 @...
通过对Spring 4.3.2.RELEASE源码的深入研究,我们可以了解其设计理念,学习到如何优雅地管理依赖、实现面向切面编程,以及如何利用Spring构建高效、健壮的Web应用。同时,源码阅读也能帮助我们理解Spring如何与其他...
在本文中,我将讨论棘手的Spring Boot bean定义覆盖机制。 为了使您对该主题更加清楚,让我们从小测验开始。请看下一个简单的例子。 因此,我们有2种配置,它们使用名称beanName实例化bean,在主应用程序中,我们仅...
### Spring 源码分析——设计模式篇 #### 一、引言 Spring框架作为Java企业级开发领域中不可或缺的一部分,其内部集成了多种设计模式,不仅有助于提高系统的可维护性和扩展性,还能够帮助开发者更好地理解和应用...
Spring 源码学习五:BeanDefinition 装载 1 在 Spring 框架中,BeanDefinition 是一个核心概念,它描述了一个 Bean 的定义,包括其依赖项、作用域、生命周期等信息。在本篇文章中,我们将深入探讨 Spring 的源码,...
在Spring框架中,BeanDefinition是核心组件之一,它定义了bean的基本信息和元数据,包括bean的类、...理解和掌握BeanDefinition对于深入学习Spring框架至关重要,因为它直接影响到bean的生命周期管理和依赖注入机制。
springframework 是sping 里面的一个开源框架,主要用户javaee的企业开发。Spring是什么呢?首先它是一个开源的项目,而且非常活跃;它是一个基于IOC和AOP的构架多层j2ee系统的框架,但它不强迫你必须在每一层中必须...
在学习源码时,应重点关注BeanDefinition的创建、加载和实例化过程,理解Spring如何将配置信息转化为运行时的对象。同时,理解BeanFactoryPostProcessor和BeanPostProcessor的作用,以及它们如何扩展Spring的功能,...
Spring 源代码分析系列涵盖了多个关键模块,包括事务处理、IoC容器、JDBC、MVC、AOP以及与Hibernate和Acegi安全框架的集成。以下是对这些知识点的详细阐述: 1. **Spring 事务处理**:Spring 提供了声明式事务管理...
使用Struts2-Spring-Plugin-2.2.3.1.jar时,开发者需要在Struts2的配置文件中指定插件,并在Spring配置文件中声明Action类和其他相关bean。一旦配置正确,Struts2框架在处理请求时会自动从Spring容器中获取Action...
《Spring Security Web源码解析与相关依赖》 Spring Security Web是Spring Security框架的重要组成部分,它主要负责Web应用程序的安全性,包括认证和授权等核心功能。本文将深入探讨Spring Security Web的源码,并...
Spring Boot是Java开发中的一个关键框架,它简化了基于Spring的应用程序开发流程。Spring Boot 2.6.2是该框架的一个稳定版本,提供了一系列...对于Java开发者来说,研究Spring Boot源码是一项非常有价值的学习过程。
在BeanFactory篇中,我们了解到BeanFactory在启动时会从配置元信息(通常是XML文件)中读取BeanDefinition,并将它们注册到BeanDefinitionRegistry中。这个过程是通过一系列的委托和解析机制完成的。 当我们运行...
2. 控制反转:IoC是指应用程序的控制权从应用程序本身转移到框架,Spring容器根据配置文件动态地创建、装配和管理对象。这种设计模式使得组件之间解耦,降低了系统复杂度。 三、核心组件分析 1. ...
通过阅读源码,开发者可以理解Spring是如何通过精心设计的接口和类,以及一系列的设计模式,实现了高可扩展性和易用性的。 总的来说,Spring框架5.2.8.RELEASE源码的学习是一次深入理解Java企业级开发、掌握模块化...
通过阅读和分析Spring 1.2.6的源码,不仅可以学习到Spring的核心设计原则,还能了解到设计模式的运用,例如工厂模式、单例模式、观察者模式等。同时,这也是提升Java编程技巧和理解框架底层运作的好机会。在实际的...