在上一节XmlBeanFactory容器分析中，在parseDefaultElement方法中是对默认的标签进行解析的
/**
* 对四种不同的标签进行处理
*
* @param ele
* @param delegate
*/
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { // 对import标签进行处理
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { // 对alias标签进行处理
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { // 对bean标签进行处理
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // 对beans标签进行处理
doRegisterBeanDefinitions(ele);
}
}
在parseDefaultElement对四种不同的标签进行处理
对bean标签的解析最为复杂也最为重要，理解了bean标签的解析，其他标签解析就很轻松了
/**
* 调用decorateBeanDefinitionIfRequired方法解析bean标签并调用registerBeanDefinition方法注册bean
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); // 对Element对象进行解析，返回BeanDefinitionHolder对象，BeanDefinitionHolder对象中已经包含了class、name、id、alias之类的属性
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); // 当存在默认标签的子节点下还有自定义属性时，再对其进行解析
try {
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); // 将解析后的bdHolder进行注册
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); // 发出响应事件，通知相关的监听器，这个bean已经加载完成了
}
}
下面主要看一下parseBeanDefinitionElement()方法和registerBeanDefinition()方法的源码
/**
* 在BeanDefinitionParserDelegate类中
*/
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
/**
* 解析bean元素标签中各种属性
*/
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
String id = ele.getAttribute(ID_ATTRIBUTE); // 解析id属性
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // 解析name属性
// 分割name属性
List<String> aliases = new ArrayList<>();
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); // bean的名称默认是为<bean>标签的id，如果alias存在的话就是alias
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); // 解析BeanDefinition元素
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) { // 如果beanName不存在，那么按照Spring提供的命名规则为当前bean生成对应的beanName
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
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元素
*/
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
// 解析class属性
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
// 解析parent属性
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
// 创建用于保存bean属性的AbstractBeanDefinition子类GenericBeanDefinition对象
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
// 硬编码解析默认bean的各种属性
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
// 提取description
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 解析元数据
parseMetaElements(ele, bd);
// 解析lookup-method属性
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
// 解析replaced-method属性
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
parseConstructorArgElements(ele, bd);
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;
}
parseBeanDefinitionElement()方法主要是解析Bean标签的属性，然后封装到BeanDefinition类中
/**
* 在BeanDefinitionReaderUtils类中
* 将bean的信息和bean的别名注册到BeanDefinitionRegistry中
*/
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // 将bean的信息注册到BeanDefinitionRegistry中
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias); // 将bean的别名注册到BeanDefinitionRegistry中
}
}
}
registerBeanDefinition主要是将封装好的BeanDefinition对象进行注册
/**
* 在DefaultListableBeanFactory类中
* 注册bean到beanDefinitionMap中，beanDefinitionMap是Spring容器实际存储bean的map集合
*/
@Override
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); // 先从beanDefinitionMap中根据beanName获取value值
if (existingDefinition != null) { // 当beanDefinitionMap中已经存在该bean
if (!isAllowBeanDefinitionOverriding()) { // 不允许覆盖bean时
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()) {
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); // 当允许覆盖bean时覆盖该bean
}
else { // 当beanDefinitionMap中已经不存在该bean
if (hasBeanCreationStarted()) {
synchronized (this.beanDefinitionMap) { // 保证线程安全
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<>(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);
}
}
registerBeanDefinition方法主要是具体实现将BeanDefinition注册到beanDefinitionMap，beanDefinitionMap是BeanDefinitionRegistry中的属性，beanDefinitionMap实现是一个ConcurrentHashMap，key为beanName，value为BeanDefinition对象，在Spring容器中，bean属性都储存在beanDefinitionMap中
总结
在默认标签的解析过程中，有三个类或者变量很重要
- BeanDefinition
BeanDefinition是一个接口，是元素标签在Spring容器的内部表现形式。在Spring中存在三种实现RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition，均继承了AbstractBeanDefinition抽象类，在元素标签中的class、scope、lazy-init等配置属性，在BeanDefinition提供了相应了beanClass、scope、lazyInit属性。BeanDefinition中的属性是通过集成父类AbstractBeanDefinition中的和配置属性保持一一对应。
private volatile Object beanClass; // 对应class属性
private String scope = SCOPE_DEFAULT; // 对应scope属性
private boolean lazyInit = false; // 对lazy-init属性
......
- BeanDefinitionRegistry
Spring通过BeanDefinition将配置文件中的配置信息转换为容器的内部表示，并将这些BeanDefinition注册到BeanDefinitionRegistry中，Spring容器的BeanDefinitionRegistry就像是Spring配置信息的内存数据库，主要以map的形式保存，从Spring容器中获取bean也是从BeanDefinitionRegistry中获取bean的信息的，对外提供对BeanDefinition的增删改查操作
XmlBeanFactory继承了实现了BeanDefinitionRegistry接口的父类DefaultListableBeanFactory，在接口中定义了对BeanDefinition的增删改查操作
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException; // 注册BeanDefinition
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 移除BeanDefinition
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 获取BeanDefinition
boolean containsBeanDefinition(String beanName); // 判断是否包含BeanDefinition
String[] getBeanDefinitionNames(); // 获取beanName
int getBeanDefinitionCount(); // 获取BeanDefinition总数
- beanDefinitionMap
beanDefinitionMap是BeanDefinitionRegistry中的属性，beanDefinitionMap实现是一个ConcurrentHashMap，key为beanName，value为BeanDefinition对象，bean属性都储存在beanDefinitionMap中
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);