BeanDefinition的加载与注册
BeanDefinition的加载
在开篇中我们介绍过spring ioc容器管理bean主要分为两个步骤
第一：加载bean的配置文件，从而在内存中生成BeanDefinition对象，并将BeanDefinition对象在BeanDefinitionRegistry中注册
第二：根据第一步生成的BeanDefinition对象创建bean的实例
首先我们分析下BeanDefinition到底是个什么组件，按照官方源码注释(BeanDefinition描述一个bean实例，它具有属性值、构造函数参数值和具体实现提供的进一步信息)，看下他的主要结构
//bean的单例作用域 String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON; //bean的原型作用域 String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE; //bean所扮演的角色，该角色表示是应用程序的主要部分。通常对应于用户定义的bean int ROLE_APPLICATION = 0; //bean所扮演的角色，该角色表示是某个较大配置(通常是外部配置)的支持部分 int ROLE_SUPPORT = 1; //bean所扮演的角色，该角色表示提供了一个完全的后台基础设施的bean角色，与最终用户无关。 int ROLE_INFRASTRUCTURE = 2; //设置此bean定义的父定义的名称 void setParentName(String parentName); //指定此bean定义的bean类名 void setBeanClassName(String beanClassName); //重写此bean的目标作用域，指定一个新的作用域名称 void setScope(String scope); //设置这个bean是否应该延迟初始化 void setLazyInit(boolean lazyInit); //这个bean是否是延迟初始化 boolean isLazyInit(); //设置此bean依赖于初始化的bean的名称，bean工厂将确保首先初始化这些bean void setDependsOn(String... dependsOn); //返回此bean所依赖的bean名称 String[] getDependsOn(); //指定要使用的factorybean(如果有的话) void setFactoryBeanName(String factoryBeanName); //返回factorybean(如果有的话) String getFactoryBeanName(); //指定工厂方法(如果有的话)。此方法将使用构造函数参数调用，如果没有指定参数，则不使用参数调用 void setFactoryMethodName(String factoryMethodName); //返回工厂方法(如果有的话) String getFactoryMethodName(); //返回此bean的构造函数参数值 ConstructorArgumentValues getConstructorArgumentValues(); //返回要应用于bean的新实例的属性值 MutablePropertyValues getPropertyValues(); //是否是单例 boolean isSingleton(); //是否是原型 boolean isPrototype(); //是否是抽象bean boolean isAbstract(); //返回bean的角色 int getRole(); //返回此bean定义的可读描述 String getDescription(); //返回此bean定义的资源的描述 String getResourceDescription(); //返回原始bean定义，如果没有，则返回null。允许检索修饰后的bean定义 BeanDefinition getOriginatingBeanDefinition();
抽象类AbstractBeanDefinition.java
篇幅限制我们只看下它的属性就能了解BeanDefinition具体描述了bean的哪些方面的内容
@SuppressWarnings("serial")
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable {
//默认的作用域
public static final String SCOPE_DEFAULT = "";
//不自动装配的标识
public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
//按名称自动装配
public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
//按类型自动装配
public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
//按构造器自动装配
public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
//常量，表示根本没有依赖项检查
public static final int DEPENDENCY_CHECK_NONE = 0;
//常量，指示对对象引用的依赖项检查
public static final int DEPENDENCY_CHECK_OBJECTS = 1;
//常量，指示对“简单”属性的依赖项检查
public static final int DEPENDENCY_CHECK_SIMPLE = 2;
//常量，指示对所有属性(对象引用以及“简单”属性)的依赖项检查
public static final int DEPENDENCY_CHECK_ALL = 3;
//描述bean的Class对象
private volatile Object beanClass;
//描述bean的所用域
private String scope = SCOPE_DEFAULT;
//描述bean是否是抽象
private boolean abstractFlag = false;
//描述bean是否是懒加载
private boolean lazyInit = false;
//描述bean的自动装配模式
private int autowireMode = AUTOWIRE_NO;
//描述bean如何进行依赖检查
private int dependencyCheck = DEPENDENCY_CHECK_NONE;
//依赖的bean的名称
private String[] dependsOn;
private String factoryBeanName;
private String factoryMethodName;
//bean的构造器参数
private ConstructorArgumentValues constructorArgumentValues;
//bean的属性参数
private MutablePropertyValues propertyValues;
private String initMethodName;
private String destroyMethodName;
//是否执行初始化方法
private boolean enforceInitMethod = true;
//是否执行销毁方法
private boolean enforceDestroyMethod = true;
//标识此BeanDefinition是否是合成的
private boolean synthetic = false;
//bean的角色(用户使用的还是spring内部的bean)
private int role = BeanDefinition.ROLE_APPLICATION;
//bean的描述符
private String description;
//当前描述beandefinition的资源对象
private Resource resource;
}
GenericBeanDefinition.java
GenericBeanDefinition是用于标准bean定义的统一对象，也是本文讲解BeanDefinition的最终产物。像任何bean定义一样，
它允许指定一个类以及可选的构造函数参数值和属性值。此外，可以通过“parentName”属性灵活地配置从父bean定义派生的bean，基本的属性从AbstractBeanDefinition 继承
@SuppressWarnings("serial")
public class GenericBeanDefinition extends AbstractBeanDefinition {
private String parentName;
public GenericBeanDefinition(BeanDefinition original) {
super(original);
}
@Override
public void setParentName(String parentName) {
this.parentName = parentName;
}
@Override
public String getParentName() {
return this.parentName;
}
}
BeanDefinition的加载与注册时序图
正式分析代码前先给出BeanDefinition的加载与注册时序图，如下所示
读取xml并生成BeanDefinition
BeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
根据resources加载BeanDefinition，
public class XmlBeanFactory extends DefaultListableBeanFactory {
//句柄对象从xml文件中读取并生成BeanDefinition对象
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource); //加载bean的定义
}
}
XmlBeanDefinitionReader.java
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource)); //将resources包装成可编码的EncodedResource
}
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isInfoEnabled()) {
logger.info("Loading XML bean definitions from " + encodedResource);
}
//这一段排除并检查是否是循环加载资源
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
//获取resources的inputstream
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
//根据inputStream生成InputSource,便于xml的sax解析
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//加载BeanDefinitions
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
//将xml的resources资源加载成Document对象表示，便于解析bean的各种属性，xml解析不做具体分析
Document doc = doLoadDocument(inputSource, resource);
//注册BeanDefinitions
return registerBeanDefinitions(doc, resource);
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (SAXParseException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
}
catch (SAXException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
}
catch (ParserConfigurationException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
}
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//DefaultBeanDefinitionDocumentReader对象,该对象是document的BeanDefinition的阅读器对象
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
//获取beanfactory中已加载的BeanDefinition数量
int countBefore = getRegistry().getBeanDefinitionCount();
//当前注册BeanDefinition
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
//返回本次注册BeanDefinition的数量
return getRegistry().getBeanDefinitionCount() - countBefore;
}
DefaultBeanDefinitionDocumentReader.java
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
//阅读器的上下文
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
//获取xml文档的根对象(<beans xmlns="http://www.springframework.org/schema/beans">)
Element root = doc.getDocumentElement();
//根据root对象加载各种子元素(bean)的定义
doRegisterBeanDefinitions(root);
}
protected void doRegisterBeanDefinitions(Element root) {
BeanDefinitionParserDelegate parent = this.delegate;
//创建BeanDefinition的解析器
this.delegate = createDelegate(getReaderContext(), root, parent);
//判断根节点的命名空间是否是(http://www.springframework.org/schema/beans)
if (this.delegate.isDefaultNamespace(root)) {
//判断根节点是否有profile熟悉
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
//判断当前的阅读器的上下文所处的Environmen环境是否接受已配置的profile，如不接受解析终止
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isInfoEnabled()) {
logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
//预处理，空实现留给用户去实现
preProcessXml(root);
//开始解析Definitions
parseBeanDefinitions(root, this.delegate);
//后置处理，空实现留给用户去实现
postProcessXml(root);
this.delegate = parent;
}
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//判断根节点是否是默认的命名空间(http://www.springframework.org/schema/beans)
//非默认例如(http://www.springframework.org/schema/context)
//默认命名空间走parseDefaultElement逻辑非默认走parseCustomElement
//parseCustomElement在我们将applicationContext时再分析，举个例子componetscan走的就是parseCustomElement解析
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);
}
}
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//如果节点的名称是import，走importBeanDefinitionResource逻辑
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
//如果节点的名称是alias，走processAliasRegistration逻辑
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//如果节点的名称是bean，走processBeanDefinition逻辑,也是我要讲的中心，其他解析BeanDefinition逻辑在讲完processBeanDefinition时都会很好理解
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
//注册内部bean
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//利用BeanDefinitionParserDelegate委托类解析bean的定义元素，并返回bean的定义持有者BeanDefinitionHolder，该对象包含已解析到BeanDefinition，是一个包装类
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
//如果需要（客户有自定义的属性），装饰Bean定义
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//注册最终的已装饰好的BeanDefinitionHolder到注册中心
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// 发送组件已注册事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
BeanDefinitionParserDelegate.java
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
/**
* 解析已经提供的bean的定义
*/
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
//获取bean的id属性
String id = ele.getAttribute(ID_ATTRIBUTE);
//获取bean的name属性
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<String>();
//如果bean有设定name属性则将name属性增加到别名中
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
//bean名称字段
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) {
//验证在bean元素嵌套的当前级别中尚未使用指定的bean名称和别名
checkNameUniqueness(beanName, aliases, ele);
}
//解析并声称bean的定义
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 {
//生成bean的名称通过beanDefinition
beanName = this.readerContext.generateBeanName(beanDefinition);
//如果可能的话，为普通bean类名注册一个别名
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);
//返回bean的定义持有者BeanDefinitionHolder
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);//beanDefinition的生成过程
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
//判断并获取bean的class属性
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
try {
String parent = null;
//判断并获取bean的parent，常用于内部bean的定义
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
//创建bean的定义
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//解析bean的定义的属性
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
//解析并设置bean的描述
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//解析bean的元数据
parseMetaElements(ele, bd);
//解析查找覆盖子元素
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析替换的方法子元素
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//解析bean的构造器参数，并赋值给ConstructorArgumentValues成员属性，代表当前bean的一系列构造器参数
parseConstructorArgElements(ele, bd);
//解析bean的属性字段,并赋值给MutablePropertyValues成员属性，代表当前bean的一系列属性
parsePropertyElements(ele, bd);
//解析限定符元素
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}
BeanDefinition的创建是通过BeanDefinitionReaderUtils工具类的静态方法
public static AbstractBeanDefinition createBeanDefinition(String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
//new一个GenericBeanDefinition对象该对象就是BeanDefinition的子类
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setParentName(parentName);
//设置bean的类加载器以及类名称
if (className != null) {
if (classLoader != null) {
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
解析bean的定义的属性parseBeanDefinitionAttributes
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
BeanDefinition containingBean, AbstractBeanDefinition bd) {
if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
}
读取并设置bean的作用域
else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
}
else if (containingBean != null) {
// Take default from containing bean in case of an inner bean definition.
bd.setScope(containingBean.getScope());
}
//读取并设置bean的抽象属性
if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
}
//读取并设置bean的懒加载属性
String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
if (DEFAULT_VALUE.equals(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
//读取并设置bean的自动装配模式
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
//读取并设置bean的依赖检查模式
String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
//读取并设置bean的依赖
if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
}
String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
String candidatePattern = this.defaults.getAutowireCandidates();
if (candidatePattern != null) {
String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
}
}
else {
bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
}
if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
}
//读取并设置初始化方法
if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
if (!"".equals(initMethodName)) {
bd.setInitMethodName(initMethodName);
}
}
else {
if (this.defaults.getInitMethod() != null) {
bd.setInitMethodName(this.defaults.getInitMethod());
bd.setEnforceInitMethod(false);
}
}
//读取并设置销毁方法
if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
bd.setDestroyMethodName(destroyMethodName);
}
else {
if (this.defaults.getDestroyMethod() != null) {
bd.setDestroyMethodName(this.defaults.getDestroyMethod());
bd.setEnforceDestroyMethod(false);
}
}
//如果bean是FactoryBean的实例则获取FactoryMethod工厂方法
if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
}
//如果bean是FactoryBean的实例则FactoryBean的属性
if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
}
return bd;
}
BeanDefinition的注册
DefaultBeanDefinitionDocumentReader.java
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//这一步骤完成BeanDefinition的加载
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 注册BeanDefinition到BeanDefinitionRegistry中
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
BeanDefinitionReaderUtils.java
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// 获取bean的名称
String beanName = definitionHolder.getBeanName();
//利用BeanDefinitionRegistry将BeanDefinition注册
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
DefaultListableBeanFactory.java
BeanDefinition的注册主要是通过BeanDefinitionRegistry的void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;方法
所以具体的实现则是由DefaultListableBeanFactory来完成注册逻辑，通过前文开篇分析到，DefaultListableBeanFactory处于BeanFactory的体系结构的最底层，
DefaultListableBeanFactory同时也实现了registerBeanDefinition方法
其主要是将保存在内存中
/** bean定义对象的映射，按bean名称作为键 */ private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
/** bean定义名称的列表，按注册顺序排列 */ private volatile List<String> beanDefinitionNames = new ArrayList<String>(256);
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
//判断是否能重复注册，如果可以则进行覆盖
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + existingDefinition + "] bound.");
}
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isWarnEnabled()) {
logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isInfoEnabled()) {
logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
//检查bean的创建实例化阶段是否已经开始
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
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;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// 启动注册阶段还没有进行实例化
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
