摘要：類的本質(zhì)是，通過文章開始的講解可知，在應(yīng)用部署到容器后進(jìn)行初始化時(shí)會(huì)調(diào)用相關(guān)的方法，因此，類的初始化過程也由該方法開始。上述調(diào)用邏輯中比較重要的就是抽象類中的方法方法以及類中的方法，接下來會(huì)逐一進(jìn)行講解。

當(dāng)一個(gè)Web應(yīng)用部署到容器內(nèi)時(shí)(eg.tomcat)，在Web應(yīng)用開始響應(yīng)執(zhí)行用戶請(qǐng)求前，以下步驟會(huì)被依次執(zhí)行:

部署描述文件中(eg.tomcat的web.xml)由元素標(biāo)記的事件監(jiān)聽器會(huì)被創(chuàng)建和初始化

對(duì)于所有事件監(jiān)聽器，如果實(shí)現(xiàn)了ServletContextListener接口，將會(huì)執(zhí)行其實(shí)現(xiàn)的contextInitialized()方法

部署描述文件中由元素標(biāo)記的過濾器會(huì)被創(chuàng)建和初始化，并調(diào)用其init()方法

部署描述文件中由元素標(biāo)記的servlet會(huì)根據(jù)的權(quán)值按順序創(chuàng)建和初始化，并調(diào)用其init()方法

web初始化流程圖如下：

接下來以一個(gè)常見的簡單web.xml配置進(jìn)行Spring MVC啟動(dòng)過程的分析，web.xml配置內(nèi)容如下:

  Web Application

  
  
    contextConfigLocation
    classpath:applicationContext-*.xml
  

  
  
    org.springframework.web.context.ContextLoaderListener
  
  
  
  
    CharacterEncodingFilter
    org.springframework.web.filter.CharacterEncodingFilter
    
      encoding
      utf-8
    
  

  
    CharacterEncodingFilter
    /*
  

  
  
    springMVC_rest
    org.springframework.web.servlet.DispatcherServlet
    
    1
  

  
  
    default
    *.css
  

在web初始化的時(shí)候會(huì)去加載web.xml文件，會(huì)按照配置的內(nèi)容進(jìn)行初始化

首先定義了標(biāo)簽，用于配置一個(gè)全局變量，標(biāo)簽的內(nèi)容讀取后會(huì)被放進(jìn)application中，做為Web應(yīng)用的全局變量使用，加載bean的時(shí)候作為application的configLocation參數(shù)，因此，Web應(yīng)用在容器中部署后，進(jìn)行初始化時(shí)會(huì)先讀取這個(gè)全局變量，之后再進(jìn)行上述講解的初始化啟動(dòng)過程。
接著定義了一個(gè)ContextLoaderListener類的listener。查看ContextLoaderListener的類聲明源碼如下圖:

ContextLoaderListener類繼承了ContextLoader類并實(shí)現(xiàn)了ServletContextListener接口，首先看一下前面講述的ServletContextListener接口源碼:

該接口只有兩個(gè)方法contextInitialized和contextDestroyed，這里采用的是觀察者模式，也稱為為訂閱-發(fā)布模式，實(shí)現(xiàn)了該接口的listener會(huì)向發(fā)布者進(jìn)行訂閱，當(dāng)Web應(yīng)用初始化或銷毀時(shí)會(huì)分別調(diào)用上述兩個(gè)方法。
繼續(xù)看ContextLoaderListener，該listener實(shí)現(xiàn)了ServletContextListener接口，因此在Web應(yīng)用初始化時(shí)會(huì)調(diào)用該方法，該方法的具體實(shí)現(xiàn)如下：

 * Initialize the root web application context.*/
    @Override
    public void contextInitialized(ServletContextEvent event) {
        initWebApplicationContext(event.getServletContext());
    }

ContextLoaderListener的contextInitialized()方法直接調(diào)用了initWebApplicationContext()方法，這個(gè)方法是繼承自ContextLoader類，通過函數(shù)名可以知道，該方法是用于初始化Web應(yīng)用上下文，即IoC容器，這里使用的是代理模式，繼續(xù)查看ContextLoader類的initWebApplicationContext()方法的源碼如下:

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    /*
    首先通過WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
    這個(gè)String類型的靜態(tài)變量獲取一個(gè)根IoC容器，根IoC容器作為全局變量
    存儲(chǔ)在application對(duì)象中，如果存在則有且只能有一個(gè)
    如果在初始化根WebApplicationContext即根IoC容器時(shí)發(fā)現(xiàn)已經(jīng)存在
    則直接拋出異常，因此web.xml中只允許存在一個(gè)ContextLoader類或其子類的對(duì)象
    */
        if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
            throw new IllegalStateException(
                    "Cannot initialize context because there is already a root application context present - " +
                    "check whether you have multiple ContextLoader* definitions in your web.xml!");
        }

        Log logger = LogFactory.getLog(ContextLoader.class);
        servletContext.log("Initializing Spring root WebApplicationContext");
        if (logger.isInfoEnabled()) {
            logger.info("Root WebApplicationContext: initialization started");
        }
        long startTime = System.currentTimeMillis();

        try {
            // Store context in local instance variable, to guarantee that
            // it is available on ServletContext shutdown.
            // 如果當(dāng)前成員變量中不存在WebApplicationContext則創(chuàng)建一個(gè)根WebApplicationContext
            if (this.context == null) {
                this.context = createWebApplicationContext(servletContext);
            }
            if (this.context instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
                if (!cwac.isActive()) {
                    // The context has not yet been refreshed -> provide services such as
                    // setting the parent context, setting the application context id, etc
                    if (cwac.getParent() == null) {
                        // The context instance was injected without an explicit parent ->
                        // determine parent for root web application context, if any.
                        //為根WebApplicationContext設(shè)置一個(gè)父容器
                        ApplicationContext parent = loadParentContext(servletContext);
                        cwac.setParent(parent);
                    }
                    //配置并刷新整個(gè)根IoC容器，在這里會(huì)進(jìn)行Bean的創(chuàng)建和初始化
                    configureAndRefreshWebApplicationContext(cwac, servletContext);
                }
            }
            /*
            將創(chuàng)建好的IoC容器放入到application對(duì)象中，并設(shè)置key為WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
            因此，在SpringMVC開發(fā)中可以在jsp中通過該key在application對(duì)象中獲取到根IoC容器，進(jìn)而獲取到相應(yīng)的Ben
            */
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

            ClassLoader ccl = Thread.currentThread().getContextClassLoader();
            if (ccl == ContextLoader.class.getClassLoader()) {
                currentContext = this.context;
            }
            else if (ccl != null) {
                currentContextPerThread.put(ccl, this.context);
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
                        WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
            }
            if (logger.isInfoEnabled()) {
                long elapsedTime = System.currentTimeMillis() - startTime;
                logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
            }

            return this.context;
        }
        catch (RuntimeException ex) {
            logger.error("Context initialization failed", ex);
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
            throw ex;
        }
        catch (Error err) {
            logger.error("Context initialization failed", err);
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
            throw err;
        }
    }

initWebApplicationContext()方法如上注解講述，主要目的就是創(chuàng)建root WebApplicationContext對(duì)象即根IoC容器，其中比較重要的就是，整個(gè)Web應(yīng)用如果存在根IoC容器則有且只能有一個(gè)，根IoC容器作為全局變量存儲(chǔ)在ServletContext即application對(duì)象中。將根IoC容器放入到application對(duì)象之前進(jìn)行了IoC容器的配置和刷新操作，調(diào)用了configureAndRefreshWebApplicationContext()方法，該方法源碼如下:

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
        if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
            // The application context id is still set to its original default value
            // -> assign a more useful id based on available information
            String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
            if (idParam != null) {
                wac.setId(idParam);
            }
            else {
                // Generate default id...
                wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
                        ObjectUtils.getDisplayString(sc.getContextPath()));
            }
        }

        wac.setServletContext(sc);
        /*
        CONFIG_LOCATION_PARAM = "contextConfigLocation"
        獲取web.xml中標(biāo)簽配置的全局變量，其中key為CONFIG_LOCATION_PARAM
        也就是我們配置的相應(yīng)Bean的xml文件名，并將其放入到WebApplicationContext中
        */
        String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
        if (configLocationParam != null) {
            wac.setConfigLocation(configLocationParam);
        }

        // The wac environment"s #initPropertySources will be called in any case when the context
        // is refreshed; do it eagerly here to ensure servlet property sources are in place for
        // use in any post-processing or initialization that occurs below prior to #refresh
        ConfigurableEnvironment env = wac.getEnvironment();
        if (env instanceof ConfigurableWebEnvironment) {
            ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
        }

        customizeContext(sc, wac);
        wac.refresh();
    }

比較重要的就是獲取到了web.xml中的標(biāo)簽配置的全局變量contextConfigLocation，并最后一行調(diào)用了refresh()方法，ConfigurableWebApplicationContext是一個(gè)接口，通過對(duì)常用實(shí)現(xiàn)類ClassPathXmlApplicationContext逐層查找后可以找到一個(gè)抽象類AbstractApplicationContext實(shí)現(xiàn)了refresh()方法，其源碼如下:

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset "active" flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring"s core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

該方法主要用于創(chuàng)建并初始化contextConfigLocation類配置的xml文件中的Bean，因此，如果我們?cè)谂渲肂ean時(shí)出錯(cuò)，在Web應(yīng)用啟動(dòng)時(shí)就會(huì)拋出異常，而不是等到運(yùn)行時(shí)才拋出異常。
整個(gè)ContextLoaderListener類的啟動(dòng)過程到此就結(jié)束了，可以發(fā)現(xiàn)，創(chuàng)建ContextLoaderListener是比較核心的一個(gè)步驟，主要工作就是為了創(chuàng)建根IoC容器并使用特定的key將其放入到application對(duì)象中，供整個(gè)Web應(yīng)用使用，由于在ContextLoaderListener類中構(gòu)造的根IoC容器配置的Bean是全局共享的，因此，在標(biāo)識(shí)的contextConfigLocation的xml配置文件一般包括:數(shù)據(jù)庫DataSource、DAO層、Service層、事務(wù)等相關(guān)Bean。

在監(jiān)聽器listener初始化完成后，按照文章開始的講解，接下來會(huì)進(jìn)行filter的初始化操作，filter的創(chuàng)建和初始化中沒有涉及IoC容器的相關(guān)操作，因此不是本文講解的重點(diǎn)，本文舉例的filter是一個(gè)用于編碼用戶請(qǐng)求和響應(yīng)的過濾器，采用utf-8編碼用于適配中文。

Servlet的初始化過程可以通過一張圖來總結(jié)，如下所示：

通過類圖和相關(guān)初始化函數(shù)調(diào)用的邏輯來看，DispatcherServlet類的初始化過程將模板方法使用的淋漓盡致，其父類完成不同的統(tǒng)一的工作，并預(yù)留出相關(guān)方法用于子類覆蓋去完成不同的可變工作。

DispatcherServelt類的本質(zhì)是Servlet，通過文章開始的講解可知，在Web應(yīng)用部署到容器后進(jìn)行Servlet初始化時(shí)會(huì)調(diào)用相關(guān)的init(ServletConfig)方法，因此，DispatchServlet類的初始化過程也由該方法開始。上述調(diào)用邏輯中比較重要的就是FrameworkServlet抽象類中的initServletBean()方法、initWebApplicationContext()方法以及DispatcherServlet類中的onRefresh()方法，接下來會(huì)逐一進(jìn)行講解。

首先來看initServletBean()方法：

    @Override
    protected final void initServletBean() throws ServletException {
        getServletContext().log("Initializing Spring FrameworkServlet "" + getServletName() + """);
        if (this.logger.isInfoEnabled()) {
            this.logger.info("FrameworkServlet "" + getServletName() + "": initialization started");
        }
        long startTime = System.currentTimeMillis();

        try {
            //這里是重點(diǎn)，用于初始化子ApplicationContext對(duì)象，主要是用來加載對(duì)應(yīng)的servletName-servlet.xml文件如：springMVC_rest-servlet.xml
            this.webApplicationContext = initWebApplicationContext();
            initFrameworkServlet();
        }
        catch (ServletException ex) {
            this.logger.error("Context initialization failed", ex);
            throw ex;
        }
        catch (RuntimeException ex) {
            this.logger.error("Context initialization failed", ex);
            throw ex;
        }

        if (this.logger.isInfoEnabled()) {
            long elapsedTime = System.currentTimeMillis() - startTime;
            this.logger.info("FrameworkServlet "" + getServletName() + "": initialization completed in " +
                    elapsedTime + " ms");
        }
    }

接下來來著重分析initWebApplicationContext()方法，

protected WebApplicationContext initWebApplicationContext() {
        /*
        獲取由ContextLoaderListener創(chuàng)建的根IoC容器
        獲取根IoC容器有兩種方法，還可通過key直接獲取
        */
        WebApplicationContext rootContext =
                WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        WebApplicationContext wac = null;

        if (this.webApplicationContext != null) {
            // A context instance was injected at construction time -> use it
            wac = this.webApplicationContext;
            if (wac instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
                if (!cwac.isActive()) {
                    // The context has not yet been refreshed -> provide services such as
                    // setting the parent context, setting the application context id, etc
                    if (cwac.getParent() == null) {
                        // The context instance was injected without an explicit parent -> set
                        // the root application context (if any; may be null) as the parent
                        /*
                        如果當(dāng)前Servelt存在一個(gè)WebApplicationContext即子IoC容器
                        并且上文獲取的根IoC容器存在，則將根IoC容器作為子IoC容器的父容器
                        */
                        cwac.setParent(rootContext);
                    }
                    //配置并刷新當(dāng)前的子IoC容器，功能與前文講解根IoC容器時(shí)的配置刷新一致，用于構(gòu)建相關(guān)Bean
                    configureAndRefreshWebApplicationContext(cwac);
                }
            }
        }
        if (wac == null) {
            // No context instance was injected at construction time -> see if one
            // has been registered in the servlet context. If one exists, it is assumed
            // that the parent context (if any) has already been set and that the
            // user has performed any initialization such as setting the context id
            //如果當(dāng)前Servlet不存在一個(gè)子IoC容器則去查找一下
            wac = findWebApplicationContext();
        }
        if (wac == null) {
            // No context instance is defined for this servlet -> create a local one
            //如果仍舊沒有查找到子IoC容器則創(chuàng)建一個(gè)子IoC容器
            wac = createWebApplicationContext(rootContext);
        }

        if (!this.refreshEventReceived) {
            // Either the context is not a ConfigurableApplicationContext with refresh
            // support or the context injected at construction time had already been
            // refreshed -> trigger initial onRefresh manually here.
            //調(diào)用子類覆蓋的onRefresh方法完成“可變”的初始化過程
            onRefresh(wac);
        }

        if (this.publishContext) {
            // Publish the context as a servlet context attribute.
            String attrName = getServletContextAttributeName();
            getServletContext().setAttribute(attrName, wac);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Published WebApplicationContext of servlet "" + getServletName() +
                        "" as ServletContext attribute with name [" + attrName + "]");
            }
        }

        return wac;
    }

通過函數(shù)名不難發(fā)現(xiàn)，該方法的主要作用同樣是創(chuàng)建一個(gè)WebApplicationContext對(duì)象，即Ioc容器，不過前文講過每個(gè)Web應(yīng)用最多只能存在一個(gè)根IoC容器，這里創(chuàng)建的則是特定Servlet擁有的子IoC容器，可能有些讀者會(huì)有疑問，為什么需要多個(gè)Ioc容器，首先介紹一個(gè)父子IoC容器的訪問特性，有興趣的讀者可以自行實(shí)驗(yàn)。

在學(xué)習(xí)Spring時(shí)，我們都是從讀取xml配置文件來構(gòu)造IoC容器，常用的類有ClassPathXmlApplicationContext類，該類存在一個(gè)初始化方法用于傳入xml文件路徑以及一個(gè)父容器，我們可以創(chuàng)建兩個(gè)不同的xml配置文件并實(shí)現(xiàn)如下代碼:

//applicationContext1.xml文件中配置一個(gè)id為baseBean的Bean
ApplicationContext baseContext = new ClassPathXmlApplicationContext("applicationContext1.xml");

Object obj1 = baseContext.getBean("baseBean");

System.out.println("baseContext Get Bean " + obj1);

//applicationContext2.xml文件中配置一個(gè)id未subBean的Bean
ApplicationContext subContext = new ClassPathXmlApplicationContext(new String[]{"applicationContext2.xml"}, baseContext);

Object obj2 = subContext.getBean("baseBean");

System.out.println("subContext get baseContext Bean " + obj2);

Object obj3 = subContext.getBean("subBean");

System.out.println("subContext get subContext Bean " + obj3);

//拋出NoSuchBeanDefinitionException異常
Object obj4 = baseContext.getBean("subBean");

System.out.println("baseContext get subContext Bean " + obj4);

首先創(chuàng)建baseContext沒有為其設(shè)置父容器，接著可以成功獲取id為baseBean的Bean，接著創(chuàng)建subContext并將baseContext設(shè)置為其父容器，subContext可以成功獲取baseBean以及subBean，最后試圖使用baseContext去獲取subContext中定義的subBean，此時(shí)會(huì)拋出異常NoSuchBeanDefinitionException，由此可見，父子容器類似于類的繼承關(guān)系，子類可以訪問父類中的成員變量，而父類不可訪問子類的成員變量，同樣的，子容器可以訪問父容器中定義的Bean，但父容器無法訪問子容器定義的Bean。
通過上述實(shí)驗(yàn)我們可以理解為何需要?jiǎng)?chuàng)建多個(gè)Ioc容器，根IoC容器做為全局共享的IoC容器放入Web應(yīng)用需要共享的Bean，而子IoC容器根據(jù)需求的不同，放入不同的Bean，這樣能夠做到隔離，保證系統(tǒng)的安全性。

接下來繼續(xù)講解DispatcherServlet類的子IoC容器創(chuàng)建過程，如果當(dāng)前Servlet存在一個(gè)IoC容器則為其設(shè)置根IoC容器作為其父類，并配置刷新該容器，用于構(gòu)造其定義的Bean，這里的方法與前文講述的根IoC容器類似，同樣會(huì)讀取用戶在web.xml中配置的中的值，用于查找相關(guān)的xml配置文件用于構(gòu)造定義的Bean，這里不再贅述了。如果當(dāng)前Servlet不存在一個(gè)子IoC容器就去查找一個(gè)，如果仍然沒有查找到則調(diào)用
createWebApplicationContext()方法去創(chuàng)建一個(gè)，查看該方法的源碼如下圖所示:

該方法用于創(chuàng)建一個(gè)子IoC容器并將根IoC容器做為其父容器，接著進(jìn)行配置和刷新操作用于構(gòu)造相關(guān)的Bean。至此，根IoC容器以及相關(guān)Servlet的子IoC容器已經(jīng)配置完成，子容器中管理的Bean一般只被該Servlet使用，因此，其中管理的Bean一般是“局部”的，如SpringMVC中需要的各種重要組件，包括Controller、Interceptor、Converter、ExceptionResolver等。相關(guān)關(guān)系如下圖所示:

當(dāng)IoC子容器構(gòu)造完成后調(diào)用了onRefresh()方法，該方法的調(diào)用與initServletBean()方法的調(diào)用相同，由父類調(diào)用但具體實(shí)現(xiàn)由子類覆蓋，調(diào)用onRefresh()方法時(shí)將前文創(chuàng)建的IoC子容器作為參數(shù)傳入，查看DispatcherServletBean類的onRefresh()方法源碼如下:

@Override
    protected void onRefresh(ApplicationContext context) {
        initStrategies(context);
    }

    /**
     * Initialize the strategy objects that this servlet uses.
     * 
May be overridden in subclasses in order to initialize further strategy objects.
     */
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

onRefresh()方法直接調(diào)用了initStrategies()方法，源碼如上，通過函數(shù)名可以判斷，該方法用于初始化創(chuàng)建multipartResovle來支持圖片等文件的上傳、本地化解析器、主題解析器、HandlerMapping處理器映射器、HandlerAdapter處理器適配器、異常解析器、視圖解析器、flashMap管理器等，這些組件都是SpringMVC開發(fā)中的重要組件，相關(guān)組件的初始化創(chuàng)建過程均在此完成。
由于篇幅問題本文不再進(jìn)行更深入的探討，有興趣的讀者可以閱讀本系列文章的其他博客內(nèi)容。
至此，DispatcherServlet類的創(chuàng)建和初始化過程也就結(jié)束了，整個(gè)Web應(yīng)用部署到容器后的初始化啟動(dòng)過程的重要部分全部分析清楚了，通過前文的分析我們可以認(rèn)識(shí)到層次化設(shè)計(jì)的優(yōu)點(diǎn)，以及IoC容器的繼承關(guān)系所表現(xiàn)的隔離性。分析源碼能讓我們更清楚的理解和認(rèn)識(shí)到相關(guān)初始化邏輯以及配置文件的配置原理。