Spring 이 자리 차지 자 를 어떻게 해석 하 는 지 상세 하 게 설명 합 니 다.

무엇이 Spring 의 자리 표시 자 입 니까?
이전 Spring Xml 설정 에 서 는 다음 과 같은 설정 이 있 을 수 있 습 니 다.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd>
    <context:property-placeholder ignore-unresolvable="true"   location="classpath:jdbc.properties"/>

    <bean id="jdbc"  class="com.john.properties.jdbcBean" >
        <property name="url" value="${jdbc.url}"/>
    </bean></beans>

위 설정 에서 jdbc 이 Bean 의 url 속성 값${jdbc.url}은 자리 표시 자 를 의미 합 니 다.자리 표시 자의 실제 값 은 위 설정 에서 사용자 정의 요소 의 location 속성 이 대표 하 는 프로필 jdbc.properties 에 저 장 됩 니 다.이 프로필 에는 한 줄 의 내용 이 있 습 니 다.

jdbc.url=127.0.0.1

그 문제 가 왔 습 니 다.Spring 은 또 어떤 단계 에서 해석 하고 대체 자 를 실제 값 으로 바 꾸 었 습 니까?
Spring 은 언제 해석 하고 자리 표시 자 를 차지 합 니까?
사용자 정의 xml 태그 라 는 것 을 알 수 있 습 니 다.Spring 은 반드시 해석 해 야 합 니 다.저 는 Spring 이 사용자 정의 요 소 를 분석 하 는 입구 코드 를 직접 붙 여 보 여 드 리 겠 습 니 다.이 코드 는 BeanDefinition ParserDelegate 클래스 에 있 습 니 다.

/**
     * Parse the elements at the root level in the document:
     * "import", "alias", "bean".
     * @param root the DOM root element of the document
     */
    //todo doRegisterBeanDefinitions ->  parseBeanDefinitions -> parseDefaultElement
    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;

                    //    beans    
                    if (delegate.isDefaultNamespace(ele)) {
                        //      
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        //     
                        //   parser
                        //todo parser      BeanDefinition 2021-3-15
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
    }

주요 관심 사:delegate.parseCustomElement(ele);

    @Nullable
    public BeanDefinition parseCustomElement(Element ele) {
        return parseCustomElement(ele, null);
    }

    //todo property                  parsePropertySubElement
    @Nullable
    public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
        String namespaceUri = getNamespaceURI(ele);
        if (namespaceUri == null) {
            return null;
        }
        //resolve       
        //      uri   NamespaceHandler

        //todo            handler    ContextNamespaceHandler
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler == null) {
            //todo    spring.handlers                 handler        2020-09-14
            error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        }
        //  parse  
        //  ParserContext  registry
        //readerContext  reader->XmlBeanDefinitionReader      registry
        //TODO       ParserContext  
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    }

여기 서 우 리 는 이 NamespaceHandler 가 어떻게 얻 었 는 지 에 관심 을 가 져 야 합 니 다.위의 코드 에서 알 수 있 듯 이 Spring 은 현재 reader Context 에서 NamespaceHandler Resolver 를 얻 은 후에 resolve 방법 을 통 해 들 어 오 는 현재 namespaceUri 에 따라 현재 적합 한 NamespaceHandler 를 얻 을 수 있 습 니 다.

/**
     * Create the {@link XmlReaderContext} to pass over to the document reader.
     */
    public XmlReaderContext createReaderContext(Resource resource) {
        //   reader    ,reader    beanRegistry
        //beanRegistry      registerBeanDefinition        
        return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
                this.sourceExtractor, this, getNamespaceHandlerResolver());
    }

    /**
     * Lazily create a default NamespaceHandlerResolver, if not set before.
     *           
     * @see #createDefaultNamespaceHandlerResolver()
     */
    public NamespaceHandlerResolver getNamespaceHandlerResolver() {
        if (this.namespaceHandlerResolver == null) {
            this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
        }
        return this.namespaceHandlerResolver;
    }

    /**
     * Create the default implementation of {@link NamespaceHandlerResolver} used if none is specified.
     * <p>The default implementation returns an instance of {@link DefaultNamespaceHandlerResolver}.
     * @see DefaultNamespaceHandlerResolver#DefaultNamespaceHandlerResolver(ClassLoader)
     */
    protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
        ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
        return new DefaultNamespaceHandlerResolver(cl);
    }

    //     
    public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
        this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION);
    }

위의 코드 에서 알 수 있 듯 이 Spring 은 기본 Default NamespaceHandlerResolver 를 사용 합 니 다.물론 개발 자 에 게 NamespaceHandlerResolver 를 사용자 정의 할 기 회 를 남 겼 습 니 다.그럼 Default NamespaceHandler Resolver 가 namespaceUri 에 따라 대응 하 는 NamespaceHandler 를 어떻게 해석 하 는 지 알 수 있 습 니 다.
우선 context 네 임 스페이스 를 가 져 옵 니 다.전체 경 로 는 http\\:/www.springframework.org/schema/context 입 니 다.Default NamespaceHandler Resolver 클래스 에서 이 네 임 스페이스 를 어떻게 해석 하 는 지 볼 수 있 습 니 다.

/**
     * Locate the {@link NamespaceHandler} for the supplied namespace URI
     * from the configured mappings.
     * @param namespaceUri the relevant namespace URI
     * @return the located {@link NamespaceHandler}, or {@code null} if none found
     */
    @Override
    @Nullable
    public NamespaceHandler resolve(String namespaceUri) {
        Map<String, Object> handlerMappings = getHandlerMappings();
        Object handlerOrClassName = handlerMappings.get(namespaceUri);
        if (handlerOrClassName == null) {
            return null;
        }
        else if (handlerOrClassName instanceof NamespaceHandler) {
            return (NamespaceHandler) handlerOrClassName;
        }
        else {
            String className = (String) handlerOrClassName;
            try {
                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);
                //todo                  2020-09-04
                namespaceHandler.init();
                handlerMappings.put(namespaceUri, namespaceHandler);
                return namespaceHandler;
            }
            catch (ClassNotFoundException ex) {
                throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
                        "] for namespace [" + namespaceUri + "]", ex);
            }
            catch (LinkageError err) {
                throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
                        className + "] for namespace [" + namespaceUri + "]", err);
            }
        }
    }

    /**
     * Load the specified NamespaceHandler mappings lazily.
     */
    private Map<String, Object> getHandlerMappings() {
        Map<String, Object> handlerMappings = this.handlerMappings;
        if (handlerMappings == null) {
            synchronized (this) {
                handlerMappings = this.handlerMappings;
                if (handlerMappings == null) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
                    }
                    try {
                        //todo handlerMappings               2020-09-04
                        //spring-aop spring-beans spring-context
                        Properties mappings =
                                PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
                        if (logger.isTraceEnabled()) {
                            logger.trace("Loaded NamespaceHandler mappings: " + mappings);
                        }
                        handlerMappings = new ConcurrentHashMap<>(mappings.size());
                        CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
                        this.handlerMappings = handlerMappings;
                    }
                    catch (IOException ex) {
                        throw new IllegalStateException(
                                "Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
                    }
                }
            }
        }
        return handlerMappings;
    }

위 코드 의 handler Mappings Location 는 일반적으로 Spring 의 기본 경로 입 니 다.

    //      handler   ，          
    /**
     * The location to look for the mapping files. Can be present in multiple JAR files.
     */
    public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";

spring-context 프로젝트 프로젝트 의 resoures/META-INF 폴 더 에 있 는 spring.handlers 파일 로 돌아 가 다음 과 같은 규칙 을 정의 합 니 다.

http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler
http\://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler
http\://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler
http\://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler
http\://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler

context 사용자 정의 네 임 스페이스 가 대응 하 는 ContextNamespaceHandler 임 을 볼 수 있 습 니 다.우리 이 종 류 를 열 어 보 자.

public class ContextNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        //     NamespaceHandlerSupport        
        registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
        registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
        registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
        registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
        registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    }
}

init 방법 만 정 의 된 것 을 발 견 했 습 니 다.말 그대로 초기 화 라 는 뜻 입 니 다.물론 언제 초기 화 를 실행 할 수 있 습 니까?우 리 는 Default NamespaceHandler 의 resolve 방법 으로 돌아 가 내부 에 namespaceHandler.init()가 있 는 것 을 발견 했다. 네 임 스페이스 프로세서 에 대한 초기 화 방법 이 실 행 됩 니 다.이어서 우 리 는 또 초기 화 되 어 무엇 을 했 는 지 살 펴 보 려 고 한다.우 리 는 그것 이 같은 방법 으로 registerBean Definition Parser 즉 등록 을 호출 한 것 을 발견 했다.
Bean 정의 해석 기,여기 서 일시 정지 버튼 을 누 르 고 위의 전체 절 차 를 훑 어 봅 니 다.

Spring 은 사용자 정의 탭 을 분석 할 때 사용자 정의 네 임 스페이스 에 따라 적당 한 NamespaceHandler 를 찾 습 니 다.

사용자 정의 NamespaceHandler 는 NamespaceHandler Resolver 에서 해석 할 수 있 습 니 다.

NamespaceHandler Resolver 는 classLoader.getResources 에 따라 모든 종류의 경로 에서 spring.handlers 를 찾 습 니 다.

찾 은 후 파일 내용 을 handler Mappings 로 변환 한 다음 들 어 오 는 사용자 정의 네 임 스페이스 에 따라 NamespaceHandler

에 일치 합 니 다.

NamespaceHandler 의 init 방법 을 실행 하여 BeanDefinitionParser 를 등록 합 니 다.

그럼 이 파 서 는 어떤 강력 한 기능 을 했 나 요?우 리 는 다음 에 분해한다.
이상 은 Spring 이 자리 차지 문 자 를 어떻게 해석 하 는 지 에 대한 상세 한 내용 입 니 다.Spring 이 자리 차지 문 자 를 해석 하 는 데 관 한 자 료 는 다른 관련 글 에 관심 을 가 져 주 십시오!