spring源码读书笔记

如果我们在web项目里面使用spring的话,通常会在web.xml里面配置一个listener.

<listener>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

这个litener实现了ServletContextListener接口，并从ContextLoader继承。由于实现了ServletContextListener接口，所以在web容器启动的时候会调用contextInitialized方法。以下是这个方法的实现：

public void contextInitialized(ServletContextEvent event) {

//createContextLoader是一个废弃了的方法，什么也没有做。返回null值

this.contextLoader = createContextLoader();

//所以this.contextLoader为null，这里把自身赋值给contextLoader

//因为ContextLoaderListerner继承了ContextLoader,所以可把自身赋值给

//ContextLoader（这里有点别扭）

if (this.contextLoader == null) {

this.contextLoader = this;

}

//接着就实例化webApplicationContext，由父类ContextLoader实现

this.contextLoader.initWebApplicationContext(event.getServletContext());

}

我们现在来看一下ContextLoader的initWebApplicationContext方法，这个方法比较长，我们分段逐步跟进去看一下。(会省略一些不重要的代码)

以下这段代码主要判断是否重复实例化的问题，因为实例化webApplicationContext后，会把它放到servletContext的一个属性里，所以我们可以从servletContext的属性取出webApplicationContext，如果不为空，则已经实例化，接着就会抛出异常.

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!");

}

接着就会创建webApplicationContext

if (this.context == null) {

this.context = createWebApplicationContext(servletContext);

}

我们跟进去createWebApplicationContext这个方法看一下

protected WebApplicationContext createWebApplicationContext(ServletContext sc)

{

//获取相应的class,其实就是ConfigurableWebApplicationContext.class

Class<?> contextClass = determineContextClass(sc);

//判断是否为 ConfigurableWebApplicationContext.class或从它继承   if(!ConfigurableWebApplicationContext.class.isAssignableFrom(cont         extClass))

{

//若非ConfigurableWebApplicationContext.class或非其子类则抛出异常

throw new ApplicationContextException("Custom context class [" + contextClass.getName() +

"] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");

}

//创建一个contextClass的实例对象返回

return(ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);

}

我们看一下determineContextClass是怎么实现的

protected Class<?> determineContextClass(ServletContext servletContext) {

//从servletContext读取contextClassName

String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);

if (contextClassName != null) {

//如果从servletContext读取到的contextClassName不为空，就返回对应

//的class类

try {

//返回className对应的Class类

return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());

}//如果找不到该类名的类就抛出异常

catch (ClassNotFoundException ex) {

throw new ApplicationContextException(

"Failed to load custom context class [" + contextClassName + "]", ex);

}

}

else {//如果从servletContext读取到得contextClassName为空就取默认的className

contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());

try {//返回className对应的Class类

return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());

}

catch (ClassNotFoundException ex) {

throw new ApplicationContextException(

"Failed to load default context class [" + contextClassName + "]", ex);

}

}

}

至于BeanUtils.instantiateClass(contextClass);

则是通过反射创建对应class的实体对象。

//然后就是把context强制转换为configrableWebApplicationContext

configrableWebApplicationContext cwac = (configrableWebApplicationContext) this.context;

//接着就是核心方法configureAndRefreshWebApplicationContext

configureAndRefreshWebApplicationContext(cwac, servletContext);

//最后把它放到servletContext的属性里

servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

这样webApplicationContext就算加载完成了。

我们现在来看一下核心方法configureAndRefreshWebApplicationContext(cwac, servletContext);(省略一些不重要的代码)

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {

//把servletContext放到webApplicationContext中，以后可以直接取出来用

wac.setServletContext(sc)；

//用户自己的一些设置

customizeContext(sc, wac);

//进行加载

wac.refresh();

}

我们进入webApplicationContext的refresh方法看一下

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) {

// Destroy already created singletons to avoid dangling resources.

destroyBeans();

// Reset 'active' flag.

cancelRefresh(ex);

// Propagate exception to caller.

throw ex;

}

}

}

这是一个同步的方法，这里最核心的方法就是obtainFreshBeanFactory方法。其他的方法都是对webApplicationContext和beanFactory做一些前后的装饰和准备。

我们进入obtainFreshBeanFactoty方法看看

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

refreshBeanFactory();

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isDebugEnabled()) {

logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

}

return beanFactory;

}

这里的核心方法就是refreshBeanFactory();它负责生成BeanFactory并加载bean

protected final void refreshBeanFactory() throws BeansException {

//判断是否已经存在beanFactory如果有则销毁。

if (hasBeanFactory()) {

destroyBeans();

closeBeanFactory();

}

try {

DefaultListableBeanFactory beanFactory = createBeanFactory();//创建一个beanFactory

beanFactory.setSerializationId(getId());//给它一个标识

customizeBeanFactory(beanFactory);//用户自己做一些设置

//这个方法很关键，负责加载所有的bean

loadBeanDefinitions(beanFactory);

synchronized (this.beanFactoryMonitor) {

this.beanFactory = beanFactory;

}

}

catch (IOException ex) {

throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

}

}

然后我们进入loadBeanDefinitions(beanFactory);看一下

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(this.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);

}

这里主要工作就是new一个XmlBeanDefinitionReader，给它设置environment,resourceLoader和entityResolver,注意一下由于webApplicationContext实现了ResouceLoader接口，所以它本身就是一个ResourceLoader.

我们可以看到它并不自己去实现lobeanDefinitions方法，而是委托给XmlBeanDefinitionReader去实现。

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {

String[] configLocations = getConfigLocations();

if (configLocations != null) {

for (String configLocation : configLocations) {

reader.loadBeanDefinitions(configLocation);

}

}

}

这里就对configLocations进行bean的加载，调用重载的方法（spring重载的方法好多啊）

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {

return loadBeanDefinitions(location, null);

}

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {

ResourceLoader resourceLoader = getResourceLoader();

if (resourceLoader == null) {

throw new BeanDefinitionStoreException(

"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");

}

if (resourceLoader instanceof ResourcePatternResolver) {

// Resource pattern matching available.

try {

Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

int loadCount = loadBeanDefinitions(resources);

if (actualResources != null) {

for (Resource resource : resources) {

actualResources.add(resource);

}

}

if (logger.isDebugEnabled()) {

logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");

}

return loadCount;

}

catch (IOException ex) {

throw new BeanDefinitionStoreException(

"Could not resolve bean definition resource pattern [" + location + "]", ex);

}

}

else {

// Can only load single resources by absolute URL.

Resource resource = resourceLoader.getResource(location);

int loadCount = loadBeanDefinitions(resource);

if (actualResources != null) {

actualResources.add(resource);

}

if (logger.isDebugEnabled()) {

logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");

}

return loadCount;

}

}

上面这段代码其实就是取得resourceLoader，通过location取得resouces,然后调用

loadBeanDefinitions(resource)，这里又是一个重载的方法。

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

return loadBeanDefinitions(new EncodedResource(resource));

}

这个方法把resource进行一下编码，再调用一下重载的方法

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

Assert.notNull(encodedResource, "EncodedResource must not be null");

if (logger.isInfoEnabled()) {

logger.info("Loading XML bean definitions from " + encodedResource.getResource());

}

Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

if (currentResources == null) {

currentResources = new HashSet<EncodedResource>(4);

this.resourcesCurrentlyBeingLoaded.set(currentResources);

}

if (!currentResources.add(encodedResource)) {

throw new BeanDefinitionStoreException(

"Detected cyclic loading of " + encodedResource + " - check your import definitions!");

}

try {

InputStream inputStream = encodedResource.getResource().getInputStream();

try {

InputSource inputSource = new InputSource(inputStream);

if (encodedResource.getEncoding() != null) {

inputSource.setEncoding(encodedResource.getEncoding());

}

return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

}

finally {

inputStream.close();

}

}

catch (IOException ex) {

throw new BeanDefinitionStoreException(

"IOException parsing XML document from " + encodedResource.getResource(), ex);

}

finally {

currentResources.remove(encodedResource);

if (currentResources.isEmpty()) {

this.resourcesCurrentlyBeingLoaded.remove();

}

}

}

通过resource取出inpustream,封装一个inputSource，调用doLoadBeanDefinitions(inputSource, encodedResource.getResource());

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

throws BeanDefinitionStoreException {

int validationMode = getValidationModeForResource(resource);

Document doc = this.documentLoader.loadDocument(

inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());

return registerBeanDefinitions(doc, resource);

}

这个方法是从resource中读取一个doc对象，值得注意的是，这个doc是w3c的标准。然后进行bean的注册。

registerBeanDefinitions这个方法还没看完。