<?xml version="1.0" encoding="UTF-8"?>
<!-- 注意 schema 位置，最后两行是我新增的自定义配置  -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:myname="http://vip-augus.github.io/schema/product"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://vip-augus.github.io/schema/product
       http://vip-augus.github.io/schema/product.xsd">

    <!-- 自定义标签使用 -->
    <myname:product id="product" productId="1" name="Apple" unit="台"/>
</beans>

public class ProductBootstrap {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("custom/custom-label.xml");
        Product product = (Product) context.getBean("product");
        // 输出 Product{, productId ='1', unit='台', name='Apple'}
        System.out.println(product.toString());
    }
}

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
        // 注释 3.8 ① 找到命名空间
        String namespaceUri = getNamespaceURI(ele);
        // ② 根据命名空间找到对应的 NamespaceHandler
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        // ③ 调用自定义的 NamespaceHandler 进行解析
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    }

public String getNamespaceURI(Node node) {
        return node.getNamespaceURI();
    }

public NamespaceHandler resolve(String namespaceUri) {
    // 注释 3.9 获取所有已经配置的 handler 映射
    Map<String, Object> handlerMappings = getHandlerMappings();
    // 从 map 中取出命名空间对应的 NamespaceHandler 的 className
    // 这个映射 map 值，没有的话，会进行实例化类，然后放入 map，等下次同样命名空间进来就能直接使用了
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    if (handlerOrClassName == null) {
        return null;
    }
    else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler) handlerOrClassName;
    }
    else {
        String className = (String) handlerOrClassName;

        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);
        // 调用 handler 的 init() 方法
        namespaceHandler.init();
        // 放入 handler 映射中
        handlerMappings.put(namespaceUri, namespaceHandler);
        return namespaceHandler;
    }
}

private Map<String, Object> getHandlerMappings() {
    Map<String, Object> handlerMappings = this.handlerMappings;
    // 如果没有缓存，进行缓存加载，公共变量，加锁进行操作，细节好评????
    if (handlerMappings == null) {
        synchronized (this) {
            handlerMappings = this.handlerMappings;
            if (handlerMappings == null) {
                Properties mappings =
                        PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
                handlerMappings = new ConcurrentHashMap<>(mappings.size());
                CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
                this.handlerMappings = handlerMappings;
            }
        }
    }
    return handlerMappings;
}

public BeanDefinition parse(Element element, ParserContext parserContext) {
        // 寻找解析器并进行解析操作
        BeanDefinitionParser parser = findParserForElement(element, parserContext);
        // 真正解析调用调用的方法
        return (parser != null ? parser.parse(element, parserContext) : null);
    }

public final BeanDefinition parse(Element element, ParserContext parserContext) {
        // 注释 3.10 实际自定义标签解析器调用的方法，在 parseInternal 方法中，调用了我们重载的方法
        AbstractBeanDefinition definition = parseInternal(element, parserContext);
    ...
    return definition;
}

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    String parentName = getParentName(element);
    if (parentName != null) {
        builder.getRawBeanDefinition().setParentName(parentName);
    }
    Class<?> beanClass = getBeanClass(element);
    if (beanClass != null) {
        builder.getRawBeanDefinition().setBeanClass(beanClass);
    }
    else {
        String beanClassName = getBeanClassName(element);
        if (beanClassName != null) {
            builder.getRawBeanDefinition().setBeanClassName(beanClassName);
        }
    }
    builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
    BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
    if (containingBd != null) {
        // Inner bean definition must receive same scope as containing bean.
        builder.setScope(containingBd.getScope());
    }
    if (parserContext.isDefaultLazyInit()) {
        // Default-lazy-init applies to custom bean definitions as well.
        builder.setLazyInit(true);
    }
    // 注释 3.11 在这里调用了我们写的解析方法
    doParse(element, parserContext, builder);
    return builder.getBeanDefinition();
}