Spring 启动记录(4)
1、AbstractRefreshableConfigApplicationContext
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.context.support;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* {@link AbstractRefreshableApplicationContext} subclass that adds common handling
* of specified config locations. Serves as base class for XML-based application
* context implementations such as {@link ClassPathXmlApplicationContext} and
* {@link FileSystemXmlApplicationContext}, as well as
* {@link org.springframework.web.context.support.XmlWebApplicationContext} and
* {@link org.springframework.web.portlet.context.XmlPortletApplicationContext}.
*
* @author Juergen Hoeller
* @since 2.5.2
* @see #setConfigLocation
* @see #setConfigLocations
* @see #getDefaultConfigLocations
* 这个类负责的是特殊的spring配置资源的加载实现如ClassPathXmlApplicationContext、
* FileSystemXmlApplicationContext 的父类,抽象了怎么加载获取特殊资源
*/
public abstract class AbstractRefreshableConfigApplicationContext extends AbstractRefreshableApplicationContext
implements BeanNameAware, InitializingBean {
private String[] configLocations;
private boolean setIdCalled = false;
/**
* Create a new AbstractRefreshableConfigApplicationContext with no parent.
*/
public AbstractRefreshableConfigApplicationContext() {
}
/**
* Create a new AbstractRefreshableConfigApplicationContext with the given parent context.
* @param parent the parent context
*/
public AbstractRefreshableConfigApplicationContext(ApplicationContext parent) {
super(parent);
}
/**
* Set the config locations for this application context in init-param style,
* i.e. with distinct locations separated by commas, semicolons or whitespace.
* <p>If not set, the implementation may use a default as appropriate.
*/
public void setConfigLocation(String location) {
setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
}
/**
* Set the config locations for this application context.
* <p>If not set, the implementation may use a default as appropriate.
*/
public void setConfigLocations(String... locations) {
if (locations != null) {
Assert.noNullElements(locations, "Config locations must not be null");
this.configLocations = new String[locations.length];
for (int i = 0; i < locations.length; i++) {
this.configLocations[i] = resolvePath(locations[i]).trim();
}
}
else {
this.configLocations = null;
}
}
/**
* Return an array of resource locations, referring to the XML bean definition
* files that this context should be built with. Can also include location
* patterns, which will get resolved via a ResourcePatternResolver.
* <p>The default implementation returns {@code null}. Subclasses can override
* this to provide a set of resource locations to load bean definitions from.
* @return an array of resource locations, or {@code null} if none
* @see #getResources
* @see #getResourcePatternResolver
*/
protected String[] getConfigLocations() {
return (this.configLocations != null ? this.configLocations : getDefaultConfigLocations());
}
/**
* Return the default config locations to use, for the case where no
* explicit config locations have been specified.
* <p>The default implementation returns {@code null},
* requiring explicit config locations.
* @return an array of default config locations, if any
* @see #setConfigLocations
*/
protected String[] getDefaultConfigLocations() {
return null;
}
/**
* Resolve the given path, replacing placeholders with corresponding
* environment property values if necessary. Applied to config locations.
* @param path the original file path
* @return the resolved file path
* @see org.springframework.core.env.Environment#resolveRequiredPlaceholders(String)
*/
protected String resolvePath(String path) {
return getEnvironment().resolveRequiredPlaceholders(path);
}
@Override
public void setId(String id) {
super.setId(id);
this.setIdCalled = true;
}
/**
* Sets the id of this context to the bean name by default,
* for cases where the context instance is itself defined as a bean.
*/
@Override
public void setBeanName(String name) {
if (!this.setIdCalled) {
super.setId(name);
setDisplayName("ApplicationContext '" + name + "'");
}
}
/**
* Triggers {@link #refresh()} if not refreshed in the concrete context's
* constructor already.
*/
@Override
public void afterPropertiesSet() {
if (!isActive()) {
refresh();
}
}
}
2、AbstractRefreshableWebApplicationContext
/* * Copyright 2002-2013 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.web.context.support; /** * {@link org.springframework.context.support.AbstractRefreshableApplicationContext} * subclass which implements the * {@link org.springframework.web.context.ConfigurableWebApplicationContext} * interface for web environments. Provides a "configLocations" property, * to be populated through the ConfigurableWebApplicationContext interface * on web application startup. * * <p>This class is as easy to subclass as AbstractRefreshableApplicationContext: * All you need to implements is the {@link #loadBeanDefinitions} method; * see the superclass javadoc for details. Note that implementations are supposed * to load bean definitions from the files specified by the locations returned * by the {@link #getConfigLocations} method. * * <p>Interprets resource paths as servlet context resources, i.e. as paths beneath * the web application root. Absolute paths, e.g. for files outside the web app root, * can be accessed via "file:" URLs, as implemented by * {@link org.springframework.core.io.DefaultResourceLoader}. * * <p>In addition to the special beans detected by * {@link org.springframework.context.support.AbstractApplicationContext}, * this class detects a bean of type {@link org.springframework.ui.context.ThemeSource} * in the context, under the special bean name "themeSource". * * <p><b>This is the web context to be subclassed for a different bean definition format.</b> * Such a context implementation can be specified as "contextClass" context-param * for {@link org.springframework.web.context.ContextLoader} or as "contextClass" * init-param for {@link org.springframework.web.servlet.FrameworkServlet}, * replacing the default {@link XmlWebApplicationContext}. It will then automatically * receive the "contextConfigLocation" context-param or init-param, respectively. * * <p>Note that WebApplicationContext implementations are generally supposed * to configure themselves based on the configuration received through the * {@link ConfigurableWebApplicationContext} interface. In contrast, a standalone * application context might allow for configuration in custom startup code * (for example, {@link org.springframework.context.support.GenericApplicationContext}). * 定义了web环境的实现以及加载资源的spring接口, * @author Juergen Hoeller * @since 1.1.3 * @see #loadBeanDefinitions * @see org.springframework.web.context.ConfigurableWebApplicationContext#setConfigLocations * @see org.springframework.ui.context.ThemeSource * @see XmlWebApplicationContext */ public abstract class AbstractRefreshableWebApplicationContext extends AbstractRefreshableConfigApplicationContext implements ConfigurableWebApplicationContext, ThemeSource { /** Servlet context that this context runs in */ private ServletContext servletContext; /** Servlet config that this context runs in, if any */ private ServletConfig servletConfig; /** Namespace of this context, or {@code null} if root */ private String namespace; /** the ThemeSource for this ApplicationContext */ private ThemeSource themeSource; public AbstractRefreshableWebApplicationContext() { setDisplayName("Root WebApplicationContext"); } @Override public void setServletContext(ServletContext servletContext) { this.servletContext = servletContext; } @Override public ServletContext getServletContext() { return this.servletContext; } @Override public void setServletConfig(ServletConfig servletConfig) { this.servletConfig = servletConfig; if (servletConfig != null && this.servletContext == null) { setServletContext(servletConfig.getServletContext()); } } @Override public ServletConfig getServletConfig() { return this.servletConfig; } @Override public void setNamespace(String namespace) { this.namespace = namespace; if (namespace != null) { setDisplayName("WebApplicationContext for namespace '" + namespace + "'"); } } @Override public String getNamespace() { return this.namespace; } //调用父类获取xml的资源类配置 @Override public String[] getConfigLocations() { return super.getConfigLocations(); } @Override public String getApplicationName() { return (this.servletContext != null ? this.servletContext.getContextPath() : ""); } /** * Create and return a new {@link StandardServletEnvironment}. Subclasses may override * in order to configure the environment or specialize the environment type returned. */ //复写父类创建Environment 为StandardServletEnvironment @Override protected ConfigurableEnvironment createEnvironment() { return new StandardServletEnvironment(); } /** * Register request/session scopes, a {@link ServletContextAwareProcessor}, etc. * 注册域对象scope */ @Override protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor (this.servletContext, this.servletConfig)); beanFactory.ignoreDependencyInterface(ServletContextAware.class); beanFactory.ignoreDependencyInterface(ServletConfigAware.class); WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext); WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig); } /** * This implementation supports file paths beneath the root of the ServletContext. * @see ServletContextResource */ @Override protected Resource getResourceByPath(String path) { return new ServletContextResource(this.servletContext, path); } /** * This implementation supports pattern matching in unexpanded WARs too. * @see ServletContextResourcePatternResolver */ @Override protected ResourcePatternResolver getResourcePatternResolver() { return new ServletContextResourcePatternResolver(this); } /** * Initialize the theme capability. */ @Override protected void onRefresh() { this.themeSource = UiApplicationContextUtils.initThemeSource(this); } /** * {@inheritDoc} * <p>Replace {@code Servlet}-related property sources. */ @Override protected void initPropertySources() { ConfigurableEnvironment env = getEnvironment(); if (env instanceof ConfigurableWebEnvironment) { ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, this.servletConfig); } } @Override public Theme getTheme(String themeName) { return this.themeSource.getTheme(themeName); } }
3、
/* * Copyright 2002-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.web.context.support; import java.io.IOException; /** * {@link org.springframework.web.context.WebApplicationContext} implementation * which takes its configuration from XML documents, understood by an * {@link org.springframework.beans.factory.xml.XmlBeanDefinitionReader}. * This is essentially the equivalent of * {@link org.springframework.context.support.GenericXmlApplicationContext} * for a web environment. * * <p>By default, the configuration will be taken from "/WEB-INF/applicationContext.xml" * for the root context, and "/WEB-INF/test-servlet.xml" for a context with the namespace * "test-servlet" (like for a DispatcherServlet instance with the servlet-name "test"). * * <p>The config location defaults can be overridden via the "contextConfigLocation" * context-param of {@link org.springframework.web.context.ContextLoader} and servlet * init-param of {@link org.springframework.web.servlet.FrameworkServlet}. Config locations * can either denote concrete files like "/WEB-INF/context.xml" or Ant-style patterns * like "/WEB-INF/*-context.xml" (see {@link org.springframework.util.PathMatcher} * javadoc for pattern details). * * <p>Note: In case of multiple config locations, later bean definitions will * override ones defined in earlier loaded files. This can be leveraged to * deliberately override certain bean definitions via an extra XML file. * * <p><b>For a WebApplicationContext that reads in a different bean definition format, * create an analogous subclass of {@link AbstractRefreshableWebApplicationContext}.</b> * Such a context implementation can be specified as "contextClass" context-param * for ContextLoader or "contextClass" init-param for FrameworkServlet. * * @author Rod Johnson * @author Juergen Hoeller * @see #setNamespace * @see #setConfigLocations * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader * @see org.springframework.web.context.ContextLoader#initWebApplicationContext * @see org.springframework.web.servlet.FrameworkServlet#initWebApplicationContext * 该类是底层的实现类,实现了loadBeanDefinitions、getDefaultConfigLocations方法明确了loadBean */ public class XmlWebApplicationContext extends AbstractRefreshableWebApplicationContext { /** Default config location for the root context */ public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml"; /** Default prefix for building a config location for a namespace */ public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/"; /** Default suffix for building a config location for a namespace */ public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml"; /** * Loads the bean definitions via an XmlBeanDefinitionReader. * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader * @see #initBeanDefinitionReader * @see #loadBeanDefinitions */ @Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { // Create a new XmlBeanDefinitionReader for the given BeanFactory. XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); // Configure the bean definition reader with this context's // resource loading environment. beanDefinitionReader.setEnvironment(getEnvironment()); beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // Allow a subclass to provide custom initialization of the reader, // then proceed with actually loading the bean definitions. initBeanDefinitionReader(beanDefinitionReader); loadBeanDefinitions(beanDefinitionReader); } /** * Initialize the bean definition reader used for loading the bean * definitions of this context. Default implementation is empty. * <p>Can be overridden in subclasses, e.g. for turning off XML validation * or using a different XmlBeanDefinitionParser implementation. * @param beanDefinitionReader the bean definition reader used by this context * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader#setValidationMode * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader#setDocumentReaderClass */ protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) { } /** * Load the bean definitions with the given XmlBeanDefinitionReader. * <p>The lifecycle of the bean factory is handled by the refreshBeanFactory method; * therefore this method is just supposed to load and/or register bean definitions. * <p>Delegates to a ResourcePatternResolver for resolving location patterns * into Resource instances. * @throws IOException if the required XML document isn't found * @see #refreshBeanFactory * @see #getConfigLocations * @see #getResources * @see #getResourcePatternResolver */ protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException { String[] configLocations = getConfigLocations(); if (configLocations != null) { for (String configLocation : configLocations) { reader.loadBeanDefinitions(configLocation); } } } /** * The default location for the root context is "/WEB-INF/applicationContext.xml", * and "/WEB-INF/test-servlet.xml" for a context with the namespace "test-servlet" * (like for a DispatcherServlet instance with the servlet-name "test"). */ @Override protected String[] getDefaultConfigLocations() { if (getNamespace() != null) { return new String[] {DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX}; } else { return new String[] {DEFAULT_CONFIG_LOCATION}; } } }
至此FrameworkServlet 的
ConfigurableWebApplicationContext wac=
(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
既XmlWebApplicationContext构造完成