<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/ApplicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
ruid/*</url-pattern>
</web-app>
//上下文加载监听器
public class ContextLoaderListener extends ContextLoader
implements ServletContextListener
{
public ContextLoaderListener(WebApplicationContext context)
{
super(context);
}
public void contextInitialized(ServletContextEvent event)
{
//初始化WebApplicationContext
initWebApplicationContext(event.getServletContext());
}
public void contextDestroyed(ServletContextEvent event)
{
closeWebApplicationContext(event.getServletContext());
ContextCleanupListener.cleanupAttributes(event.getServletContext());
}
}
//上下文加载器
public class ContextLoader
{
public ContextLoader(WebApplicationContext context)
{
this.context = context;
}
public WebApplicationContext initWebApplicationContext(ServletContext servletContext)
{
Log logger;
long startTime;
//如果servletContext的WebApplicationContext.root属性存在，则抛出根应用上下文已经初始化异常
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!");
logger = LogFactory.getLog(org/springframework/web/context/ContextLoader);
servletContext.log("Initializing Spring root WebApplicationContext");
if(logger.isInfoEnabled())
logger.info("Root WebApplicationContext: initialization started");
startTime = System.currentTimeMillis();
if(context == null)
context = createWebApplicationContext(servletContext);
if(context instanceof ConfigurableWebApplicationContext)
{
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)context;
if(!cwac.isActive())
{
if(cwac.getParent() == null)
{
//加载应用上下文
ApplicationContext parent = loadParentContext(servletContext);
//设置web上下文的父上下文
cwac.setParent(parent);
}
//设置并刷新WebApplicationContext
configureAndRefreshWebApplicationContext(cwac, servletContext);
}
}
//设置WebApplicationContext的root属性
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, context);
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
if(ccl == org/springframework/web/context/ContextLoader.getClassLoader())
currentContext = context;
else
if(ccl != null)
//设置当前线程的上下文
currentContextPerThread.put(ccl, context);
if(logger.isDebugEnabled())
logger.debug((new StringBuilder()).append("Published root WebApplicationContext as ServletContext attribute with name [").append(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE).append("]").toString());
if(logger.isInfoEnabled())
{
long elapsedTime = System.currentTimeMillis() - startTime;
logger.info((new StringBuilder()).append("Root WebApplicationContext: initialization completed in ").append(elapsedTime).append(" ms").toString());
}
return context;
RuntimeException ex;
ex;
logger.error("Context initialization failed", ex);
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
throw ex;
Error err;
err;
logger.error("Context initialization failed", err);
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
throw err;
}
//创建WebApplicationContext
protected WebApplicationContext createWebApplicationContext(ServletContext sc)
{
Class contextClass = determineContextClass(sc);
if(!org/springframework/web/context/ConfigurableWebApplicationContext.isAssignableFrom(contextClass))
throw new ApplicationContextException((new StringBuilder()).append("Custom context class [").append(contextClass.getName()).append("] is not of type [").append(org/springframework/web/context/ConfigurableWebApplicationContext.getName()).append("]").toString());
else
return (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
}
//获取ContextClass
protected Class determineContextClass(ServletContext servletContext)
{
String contextClassName;
contextClassName = servletContext.getInitParameter("contextClass");
if(contextClassName == null)
break MISSING_BLOCK_LABEL_55;
return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
throw new ApplicationContextException((new StringBuilder()).append("Failed to load custom context class [").append(contextClassName).append("]").toString(), ex);
contextClassName = defaultStrategies.getProperty(org/springframework/web/context/WebApplicationContext.getName());
return ClassUtils.forName(contextClassName, org/springframework/web/context/ContextLoader.getClassLoader());
throw new ApplicationContextException((new StringBuilder()).append("Failed to load default context class [").append(contextClassName).append("]").toString(), ex);
}
//加载应用上下文
protected ApplicationContext loadParentContext(ServletContext servletContext)
{
ApplicationContext parentContext = null;
String locatorFactorySelector = servletContext.getInitParameter("locatorFactorySelector");
String parentContextKey = servletContext.getInitParameter("parentContextKey");
if(parentContextKey != null)
{
BeanFactoryLocator locator = ContextSingletonBeanFactoryLocator.getInstance(locatorFactorySelector);
Log logger = LogFactory.getLog(org/springframework/web/context/ContextLoader);
if(logger.isDebugEnabled())
logger.debug((new StringBuilder()).append("Getting parent context definition: using parent context key of '").append(parentContextKey).append("' with BeanFactoryLocator").toString());
parentContextRef = locator.useBeanFactory(parentContextKey);
//获取父应用上下文
parentContext = (ApplicationContext)parentContextRef.getFactory();
}
return parentContext;
}
//设置并刷新WebApplicationContext
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc)
{
if(ObjectUtils.identityToString(wac).equals(wac.getId()))
{
String idParam = sc.getInitParameter("contextId");
if(idParam != null)
wac.setId(idParam);
else
wac.setId((new StringBuilder()).append(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX).append(ObjectUtils.getDisplayString(sc.getContextPath())).toString());
}
//设置web上下文的ServletContext
wac.setServletContext(sc);
//获取上下文位置
String configLocationParam = sc.getInitParameter("contextConfigLocation");
if(configLocationParam != null)
wac.setConfigLocation(configLocationParam);
ConfigurableEnvironment env = wac.getEnvironment();
if(env instanceof ConfigurableWebEnvironment)
((ConfigurableWebEnvironment)env).initPropertySources(sc, null);
customizeContext(sc, wac);
//bean容器初始化，关键
wac.refresh();
}
protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac)
{
List initializerClasses = determineContextInitializerClasses(sc);
if(initializerClasses.isEmpty())
return;
ArrayList initializerInstances = new ArrayList();
Class initializerClass;
for(Iterator iterator = initializerClasses.iterator(); iterator.hasNext(); initializerInstances.add(BeanUtils.instantiateClass(initializerClass)))
{
initializerClass = (Class)iterator.next();
//解决初始化类，类型问题
Class initializerContextClass = GenericTypeResolver.resolveTypeArgument(initializerClass, org/springframework/context/ApplicationContextInitializer);
if(initializerContextClass != null)
Assert.isAssignable(initializerContextClass, wac.getClass(), String.format("Could not add context initializer [%s] since its generic parameter [%s] is not assignable from the type of application context used by this context loader [%s]: ", new Object[] {
initializerClass.getName(), initializerContextClass.getName(), wac.getClass().getName()
}));
}
AnnotationAwareOrderComparator.sort(initializerInstances);
ApplicationContextInitializer initializer;
for(Iterator iterator1 = initializerInstances.iterator(); iterator1.hasNext(); initializer.initialize(wac))
initializer = (ApplicationContextInitializer)iterator1.next();
}
//获取需要上下文需要初始化的类
protected List determineContextInitializerClasses(ServletContext servletContext)
{
List classes = new ArrayList();
String globalClassNames = servletContext.getInitParameter("globalInitializerClasses");
if(globalClassNames != null)
{
String as[] = StringUtils.tokenizeToStringArray(globalClassNames, ",; \t\n");
int i = as.length;
for(int j = 0; j < i; j++)
{
String className = as[j];
classes.add(loadInitializerClass(className));
}
}
String localClassNames = servletContext.getInitParameter("contextInitializerClasses");
if(localClassNames != null)
{
String as1[] = StringUtils.tokenizeToStringArray(localClassNames, ",; \t\n");
int k = as1.length;
for(int l = 0; l < k; l++)
{
String className = as1[l];
classes.add(loadInitializerClass(className));
}
}
return classes;
}
//根据className获取需要加载的Class
private Class loadInitializerClass(String className)
{
Class clazz;
clazz = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());
Assert.isAssignable(org/springframework/context/ApplicationContextInitializer, clazz);
return clazz;
ClassNotFoundException ex;
ex;
throw new ApplicationContextException((new StringBuilder()).append("Failed to load context initializer class [").append(className).append("]").toString(), ex);
}
public static final String CONTEXT_ID_PARAM = "contextId";
public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";
public static final String CONTEXT_CLASS_PARAM = "contextClass";
public static final String CONTEXT_INITIALIZER_CLASSES_PARAM = "contextInitializerClasses";
public static final String GLOBAL_INITIALIZER_CLASSES_PARAM = "globalInitializerClasses";
public static final String LOCATOR_FACTORY_SELECTOR_PARAM = "locatorFactorySelector";
public static final String LOCATOR_FACTORY_KEY_PARAM = "parentContextKey";
private static final String INIT_PARAM_DELIMITERS = ",; \t\n";
private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";
private static final Properties defaultStrategies;
private static final Map currentContextPerThread = new ConcurrentHashMap(1);
private static volatile WebApplicationContext currentContext;
private WebApplicationContext context;//web应用上下恩
private BeanFactoryReference parentContextRef;//父上下文的bean工厂引用
static
{
try
{ //创建上下文配置文件资源
ClassPathResource resource = new ClassPathResource("ContextLoader.properties", org/springframework/web/context/ContextLoader);
//加载上下文配置文件
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch(IOException ex)
{
throw new IllegalStateException((new StringBuilder()).append("Could not load 'ContextLoader.properties': ").append(ex.getMessage()).toString());
}
}
}
//抽象应用上下文
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext, DisposableBean
{
public AbstractApplicationContext()
{
logger = LogFactory.getLog(getClass());
id = ObjectUtils.identityToString(this);
displayName = ObjectUtils.identityToString(this);
beanFactoryPostProcessors = new ArrayList();
active = false;
closed = false;
activeMonitor = new Object();
startupShutdownMonitor = new Object();
applicationListeners = new LinkedHashSet();
resourcePatternResolver = getResourcePatternResolver();
}
public AbstractApplicationContext(ApplicationContext parent)
{
this();
setParent(parent);
}
//设置父应用上下文
public void setParent(ApplicationContext parent)
{
this.parent = parent;
if(parent != null)
{
Environment parentEnvironment = parent.getEnvironment();
if(parentEnvironment instanceof ConfigurableEnvironment)
getEnvironment().merge((ConfigurableEnvironment)parentEnvironment);
}
}
public void refresh()
throws BeansException, IllegalStateException
{
synchronized(startupShutdownMonitor)
{
//准备刷新
prepareRefresh();
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//bean容器准备工作
prepareBeanFactory(beanFactory);
try
{
//bean后置处理器配置
postProcessBeanFactory(beanFactory);
//bean容器解析构造bean，关键
invokeBeanFactoryPostProcessors(beanFactory);
registerBeanPostProcessors(beanFactory);
//初始化消息源
initMessageSource();
initApplicationEventMulticaster();
onRefresh();
//注册应用监听器
registerListeners();
//初始化bean容器
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
}
catch(BeansException ex)
{
destroyBeans();
cancelRefresh(ex);
throw ex;
}
}
}
//准备刷新
protected void prepareRefresh()
{
startupDate = System.currentTimeMillis();
synchronized(activeMonitor)
{
active = true;
}
if(logger.isInfoEnabled())
logger.info((new StringBuilder()).append("Refreshing ").append(this).toString());
//初始化属性员
initPropertySources();
//校验必须的属性
getEnvironment().validateRequiredProperties();
}
protected void initPropertySources()
{
}
//获取ConfigurableListableBeanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory()
{
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if(logger.isDebugEnabled())
logger.debug((new StringBuilder()).append("Bean factory for ").append(getDisplayName()).append(": ").append(beanFactory).toString());
return beanFactory;
}
//获取内部父bean容器
protected BeanFactory getInternalParentBeanFactory()
{
return ((BeanFactory) ((getParent() instanceof ConfigurableApplicationContext) ? ((ConfigurableApplicationContext)getParent()).getBeanFactory() : getParent()));
}
//bean容器准备工作
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory)
{
//bean容器类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//bean容器Expression解决器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
//添加bean后置处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(org/springframework/context/ResourceLoaderAware);
beanFactory.ignoreDependencyInterface(org/springframework/context/ApplicationEventPublisherAware);
beanFactory.ignoreDependencyInterface(org/springframework/context/MessageSourceAware);
beanFactory.ignoreDependencyInterface(org/springframework/context/ApplicationContextAware);
beanFactory.ignoreDependencyInterface(org/springframework/context/EnvironmentAware);
beanFactory.registerResolvableDependency(org/springframework/beans/factory/BeanFactory, beanFactory);
beanFactory.registerResolvableDependency(org/springframework/core/io/ResourceLoader, this);
beanFactory.registerResolvableDependency(org/springframework/context/ApplicationEventPublisher, this);
beanFactory.registerResolvableDependency(org/springframework/context/ApplicationContext, this);
if(beanFactory.containsBean("loadTimeWeaver"))
{
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
if(!beanFactory.containsLocalBean("environment"))
beanFactory.registerSingleton("environment", getEnvironment());
if(!beanFactory.containsLocalBean("systemProperties"))
beanFactory.registerSingleton("systemProperties", getEnvironment().getSystemProperties());
if(!beanFactory.containsLocalBean("systemEnvironment"))
beanFactory.registerSingleton("systemEnvironment", getEnvironment().getSystemEnvironment());
}
//bean后置处理器配置
protected void postProcessBeanFactory(ConfigurableListableBeanFactory configurablelistablebeanfactory)
{
}
//bean容器解析构造bean
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory)
{
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}
//初始化消息源
protected void initMessageSource()
{
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if(beanFactory.containsLocalBean("messageSource"))
{
messageSource = (MessageSource)beanFactory.getBean("messageSource", org/springframework/context/MessageSource);
if(parent != null && (messageSource instanceof HierarchicalMessageSource))
{
HierarchicalMessageSource hms = (HierarchicalMessageSource)messageSource;
if(hms.getParentMessageSource() == null)
hms.setParentMessageSource(getInternalParentMessageSource());
}
if(logger.isDebugEnabled())
logger.debug((new StringBuilder()).append("Using MessageSource [").append(messageSource).append("]").toString());
} else
{
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
messageSource = dms;
beanFactory.registerSingleton("messageSource", messageSource);
if(logger.isDebugEnabled())
logger.debug((new StringBuilder()).append("Unable to locate MessageSource with name 'messageSource': using default [").append(messageSource).append("]").toString());
}
}
protected void onRefresh()
throws BeansException
{
}
//注册应用监听器
protected void registerListeners()
{
ApplicationListener listener;
for(Iterator iterator = getApplicationListeners().iterator(); iterator.hasNext(); getApplicationEventMulticaster().addApplicationListener(listener))
listener = (ApplicationListener)iterator.next();
String listenerBeanNames[] = getBeanNamesForType(org/springframework/context/ApplicationListener, true, false);
String as[] = listenerBeanNames;
int i = as.length;
for(int j = 0; j < i; j++)
{
String lisName = as[j];
getApplicationEventMulticaster().addApplicationListenerBean(lisName);
}
}
//初始化bean容器
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)
{
if(beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", org/springframework/core/convert/ConversionService))
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", org/springframework/core/convert/ConversionService));
String weaverAwareNames[] = beanFactory.getBeanNamesForType(org/springframework/context/weaving/LoadTimeWeaverAware, false, false);
String as[] = weaverAwareNames;
int i = as.length;
for(int j = 0; j < i; j++)
{
String weaverAwareName = as[j];
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
beanFactory.freezeConfiguration();
beanFactory.preInstantiateSingletons();
}
public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
protected final Log logger;
private String id;
private String displayName;
private ApplicationContext parent;
private final List beanFactoryPostProcessors;//bean后置处理器
private long startupDate;
private boolean active;
private boolean closed;
private final Object activeMonitor;//激活同步监控锁
private final Object startupShutdownMonitor;//启动关闭同步监控锁
private Thread shutdownHook;
private ResourcePatternResolver resourcePatternResolver;//资源解决其
private LifecycleProcessor lifecycleProcessor;
private MessageSource messageSource;//国际化消息处理
private ApplicationEventMulticaster applicationEventMulticaster;
private Set applicationListeners;
private ConfigurableEnvironment environment;
static
{
org/springframework/context/event/ContextClosedEvent.getName();
}
}
//AbstractRefreshableApplicationContext
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext
{
//刷新bean容器
protected final void refreshBeanFactory()
throws BeansException
{
if(hasBeanFactory())
{
destroyBeans();
closeBeanFactory();
}
try
{
//创建bean容器
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
//定制bean容器
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized(beanFactoryMonitor)
{
this.beanFactory = beanFactory;
}
}
}
//创建bean容器
protected DefaultListableBeanFactory createBeanFactory()
{
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
//定制bean容器
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory)
{
if(allowBeanDefinitionOverriding != null)
beanFactory.setAllowBeanDefinitionOverriding(allowBeanDefinitionOverriding.booleanValue());
if(allowCircularReferences != null)
//是否允许环路引用
beanFactory.setAllowCircularReferences(allowCircularReferences.booleanValue());
}
//加载bean容器定义
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory defaultlistablebeanfactory)
throws BeansException, IOException;
private Boolean allowBeanDefinitionOverriding;
private Boolean allowCircularReferences;
private DefaultListableBeanFactory beanFactory;
private final Object beanFactoryMonitor;
}
//默认bean容器
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable
{
private static Class javaxInjectProviderClass = null;
private static final Map serializableFactories = new ConcurrentHashMap(8);
private String serializationId;
private boolean allowBeanDefinitionOverriding;
private boolean allowEagerClassLoading;
private Comparator dependencyComparator;
private AutowireCandidateResolver autowireCandidateResolver;
private final Map resolvableDependencies;
private final Map beanDefinitionMap;//bean定义
private final Map allBeanNamesByType;
private final Map singletonBeanNamesByType;//单例bean
private final List beanDefinitionNames;//beanNames,List
private boolean configurationFrozen;
private String frozenBeanDefinitionNames[];
static
{
try
{
javaxInjectProviderClass = ClassUtils.forName("javax.inject.Provider", org/springframework/beans/factory/support/DefaultListableBeanFactory.getClassLoader());
}
}
}
//bean注册代理
class PostProcessorRegistrationDelegate
{
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors)
{
Set processedBeans = new HashSet();
if(beanFactory instanceof BeanDefinitionRegistry)
{
BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
List regularPostProcessors = new LinkedList();
List registryPostProcessors = new LinkedList();
for(Iterator iterator = beanFactoryPostProcessors.iterator(); iterator.hasNext();)
{
BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)iterator.next();
if(postProcessor instanceof BeanDefinitionRegistryPostProcessor)
{
BeanDefinitionRegistryPostProcessor registryPostProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
registryPostProcessors.add(registryPostProcessor);
} else
{
regularPostProcessors.add(postProcessor);
}
}
for(boolean reiterate = true; reiterate;)
{
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(org/springframework/beans/factory/support/BeanDefinitionRegistryPostProcessor, true, false);
String as3[] = postProcessorNames;
int k1 = as3.length;
int l1 = 0;
while(l1 < k1)
{
String ppName = as3[l1];
if(!processedBeans.contains(ppName))
{
BeanDefinitionRegistryPostProcessor pp = (BeanDefinitionRegistryPostProcessor)beanFactory.getBean(ppName, org/springframework/beans/factory/support/BeanDefinitionRegistryPostProcessor);
registryPostProcessors.add(pp);
processedBeans.add(ppName);
//注册bean，关键在这
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
l1++;
}
}
}
}
//bean配置处理器
public class ConfigurationClassPostProcessor
implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware
{
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
{
if(factoriesPostProcessed.contains(Integer.valueOf(registryId)))
{
throw new IllegalStateException((new StringBuilder()).append("postProcessBeanFactory already called for this post-processor against ").append(registry).toString());
} else
{
//处理bean的定义
processConfigBeanDefinitions(registry);
}
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry)
{
Set configCandidates = new LinkedHashSet();
String as[] = registry.getBeanDefinitionNames();
int i = as.length;
for(int j = 0; j < i; j++)
{
String beanName = as[j];
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if(ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, metadataReaderFactory))
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
ConfigurationClassParser parser = new ConfigurationClassParser(metadataReaderFactory, problemReporter, environment, resourceLoader, componentScanBeanNameGenerator, registry);
//根据bean配置，解析bean
parser.parse(configCandidates);
parser.validate();
}
}
//bean配置解析
class ConfigurationClassParser
{
public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory, ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader, BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry)
{
this.metadataReaderFactory = metadataReaderFactory;
this.problemReporter = problemReporter;
this.environment = environment;
this.resourceLoader = resourceLoader;
this.registry = registry;
//组件注解扫面解析器
componentScanParser = new ComponentScanAnnotationParser(resourceLoader, environment, componentScanBeanNameGenerator, registry);
conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
}
//根据bean配置，解析bean
public void parse(Set configCandidates)
{
for(Iterator iterator = configCandidates.iterator(); iterator.hasNext();)
{
BeanDefinitionHolder holder = (BeanDefinitionHolder)iterator.next();
BeanDefinition bd = holder.getBeanDefinition();
try
{
if((bd instanceof AbstractBeanDefinition) && ((AbstractBeanDefinition)bd).hasBeanClass())
parse(((AbstractBeanDefinition)bd).getBeanClass(), holder.getBeanName());
else
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
}
protected final void parse(String className, String beanName)
throws IOException
{
MetadataReader reader = metadataReaderFactory.getMetadataReader(className);
processConfigurationClass(new ConfigurationClass(reader, beanName));
}
}
//扫描组件注解配置解析器
class ComponentScanAnnotationParser
{
public ComponentScanAnnotationParser(ResourceLoader resourceLoader, Environment environment, BeanNameGenerator beanNameGenerator, BeanDefinitionRegistry registry)
{
this.resourceLoader = resourceLoader;
this.environment = environment;
this.beanNameGenerator = beanNameGenerator;
this.registry = registry;
}
//解析注解配置
public Set parse(AnnotationAttributes componentScan, String declaringClass)
{
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, componentScan.getBoolean("useDefaultFilters"));
Assert.notNull(environment, "Environment must not be null");
scanner.setEnvironment(environment);
Assert.notNull(resourceLoader, "ResourceLoader must not be null");
scanner.setResourceLoader(resourceLoader);
Class generatorClass = componentScan.getClass("nameGenerator");
boolean useInheritedGenerator = org/springframework/beans/factory/support/BeanNameGenerator.equals(generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? beanNameGenerator : (BeanNameGenerator)BeanUtils.instantiateClass(generatorClass));
ScopedProxyMode scopedProxyMode = (ScopedProxyMode)componentScan.getEnum("scopedProxy");
if(scopedProxyMode != ScopedProxyMode.DEFAULT)
{
scanner.setScopedProxyMode(scopedProxyMode);
} else
{
Class resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver((ScopeMetadataResolver)BeanUtils.instantiateClass(resolverClass));
}
//包含注解类
AnnotationAttributes aannotationattributes[] = componentScan.getAnnotationArray("includeFilters");
int i = aannotationattributes.length;
for(int j = 0; j < i; j++)
{
AnnotationAttributes filter = aannotationattributes[j];
TypeFilter typeFilter;
for(Iterator iterator = typeFiltersFor(filter).iterator(); iterator.hasNext(); scanner.addIncludeFilter(typeFilter))
typeFilter = (TypeFilter)iterator.next();
}
//剔除注解类
aannotationattributes = componentScan.getAnnotationArray("excludeFilters");
i = aannotationattributes.length;
for(int k = 0; k < i; k++)
{
AnnotationAttributes filter = aannotationattributes[k];
TypeFilter typeFilter;
for(Iterator iterator1 = typeFiltersFor(filter).iterator(); iterator1.hasNext(); scanner.addExcludeFilter(typeFilter))
typeFilter = (TypeFilter)iterator1.next();
}
List basePackages = new ArrayList();
Object aobj[] = componentScan.getStringArray("value");
int l = aobj.length;
for(int i1 = 0; i1 < l; i1++)
{
String pkg = aobj[i1];
if(StringUtils.hasText(pkg))
basePackages.add(pkg);
}
aobj = componentScan.getStringArray("basePackages");
l = aobj.length;
for(int j1 = 0; j1 < l; j1++)
{
String pkg = aobj[j1];
if(StringUtils.hasText(pkg))
basePackages.add(pkg);
}
aobj = componentScan.getClassArray("basePackageClasses");
l = aobj.length;
for(int k1 = 0; k1 < l; k1++)
{
Class clazz = aobj[k1];
basePackages.add(ClassUtils.getPackageName(clazz));
}
//扫描基本包
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
}
//ClassPathBeanDefinitionScanner，bean定义扫描
public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider
{
protected transient Set doScan(String basePackages[])
{
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set beanDefinitions = new LinkedHashSet();
String as[] = basePackages;
int i = as.length;
label0:
for(int j = 0; j < i; j++)
{
String basePackage = as[j];
Set candidates = findCandidateComponents(basePackage);
Iterator iterator = candidates.iterator();
do
{
if(!iterator.hasNext())
continue label0;
BeanDefinition candidate = (BeanDefinition)iterator.next();
ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(candidate);
//设置bean作用域
candidate.setScope(scopeMetadata.getScopeName());
String beanName = beanNameGenerator.generateBeanName(candidate, registry);
if(candidate instanceof AbstractBeanDefinition)
//bean自动注入auotwired处理
postProcessBeanDefinition((AbstractBeanDefinition)candidate, beanName);
if(candidate instanceof AnnotatedBeanDefinition)
//处理lazy等注解
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition)candidate);
if(checkCandidate(beanName, candidate))
{
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, registry);
}
} while(true);
}
return beanDefinitions;
}
//bean自动注入@auotwired处理
protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName)
{
beanDefinition.applyDefaults(beanDefinitionDefaults);
if(autowireCandidatePatterns != null)
beanDefinition.setAutowireCandidate(PatternMatchUtils.simpleMatch(autowireCandidatePatterns, beanName));
}
}
//Servlet上下文监听器
public interface ServletContextListener
extends EventListener
{
public abstract void contextInitialized(ServletContextEvent servletcontextevent);
public abstract void contextDestroyed(ServletContextEvent servletcontextevent);
}
//上下文配置文件资源
public class ClassPathResource extends AbstractFileResolvingResource
{
//构遭上下文配置文件资源
public ClassPathResource(String path, ClassLoader classLoader)
{
Assert.notNull(path, "Path must not be null");
String pathToUse = StringUtils.cleanPath(path);
if(pathToUse.startsWith("/"))
pathToUse = pathToUse.substring(1);
this.path = pathToUse;
this.classLoader = classLoader == null ? ClassUtils.getDefaultClassLoader() : classLoader;
}
//解决上下文配置文件URL
protected URL resolveURL()
{
if(clazz != null)
return clazz.getResource(path);
if(classLoader != null)
return classLoader.getResource(path);
else
return ClassLoader.getSystemResource(path);
}
//获取上下文配置文件输入流
public InputStream getInputStream()
throws IOException
{
InputStream is;
if(clazz != null)
is = clazz.getResourceAsStream(path);
else
if(classLoader != null)
is = classLoader.getResourceAsStream(path);
else
is = ClassLoader.getSystemResourceAsStream(path);
if(is == null)
throw new FileNotFoundException((new StringBuilder()).append(getDescription()).append(" cannot be opened because it does not exist").toString());
else
return is;
}
//获取上下文配置文件URL
public URL getURL()
throws IOException
{
URL url = resolveURL();
if(url == null)
throw new FileNotFoundException((new StringBuilder()).append(getDescription()).append(" cannot be resolved to URL because it does not exist").toString());
else
return url;
}
//创建相对路径上下文配置文件资源
public Resource createRelative(String relativePath)
{
String pathToUse = StringUtils.applyRelativePath(path, relativePath);
return new ClassPathResource(pathToUse, classLoader, clazz);
}
//获取配置文件名
public String getFilename()
{
return StringUtils.getFilename(path);
}
private final String path;//路径
private ClassLoader classLoader;//上下文加载类
private Class clazz;
}
//属性配置文件加载工具
public abstract class PropertiesLoaderUtils
{
//加载配置文件
public static Properties loadProperties(Resource resource)
throws IOException
{
Properties props = new Properties();
fillProperties(props, resource);
return props;
}
//填充配置属性
public static void fillProperties(Properties props, Resource resource)
throws IOException
{
InputStream is = resource.getInputStream();
String filename = resource.getFilename();
if(filename != null && filename.endsWith(".xml"))
props.loadFromXML(is);
else
props.load(is);
is.close();
is.close();
}
private static final String XML_FILE_EXTENSION = ".xml";
}
//Properties
public class Properties extends Hashtable
{
//从XML文件输入流加载配置文件
public synchronized void loadFromXML(InputStream inputstream)
throws IOException, InvalidPropertiesFormatException
{
if(inputstream == null)
{
throw new NullPointerException();
} else
{
XMLUtils.load(this, inputstream);
inputstream.close();
return;
}
}
}
//ServletContextEvent
public class ServletContextEvent extends EventObject
{
public ServletContextEvent(ServletContext source)
{
super(source);
}
public ServletContext getServletContext()
{
return (ServletContext)super.getSource();
}
}
//ApplicationContext
public interface ApplicationContext
extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver
{
public abstract String getId();
public abstract String getApplicationName();
public abstract String getDisplayName();
public abstract long getStartupDate();
public abstract ApplicationContext getParent();
public abstract AutowireCapableBeanFactory getAutowireCapableBeanFactory()
throws IllegalStateException;
}
//WebApplicationContext
public interface WebApplicationContext
extends ApplicationContext
{
public abstract ServletContext getServletContext();
public static final String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = (new StringBuilder()).append(org/springframework/web/context/WebApplicationContext.getName()).append(".ROOT").toString();
public static final String SCOPE_REQUEST = "request";
public static final String SCOPE_SESSION = "session";
public static final String SCOPE_GLOBAL_SESSION = "globalSession";
public static final String SCOPE_APPLICATION = "application";
public static final String SERVLET_CONTEXT_BEAN_NAME = "servletContext";
public static final String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";
public static final String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";
}
//ConfigurableWebApplicationContext
public interface ConfigurableWebApplicationContext
extends WebApplicationContext, ConfigurableApplicationContext
{
public abstract void setServletContext(ServletContext servletcontext);
public abstract void setServletConfig(ServletConfig servletconfig);
public abstract ServletConfig getServletConfig();
public abstract void setNamespace(String s);
public abstract String getNamespace();
public abstract void setConfigLocation(String s);
public abstract void setConfigLocations(String as[]);
public abstract String[] getConfigLocations();
public static final String APPLICATION_CONTEXT_ID_PREFIX = (new StringBuilder()).append(org/springframework/web/context/WebApplicationContext.getName()).append(":").toString();
public static final String SERVLET_CONFIG_BEAN_NAME = "servletConfig";
}
//StandardServletEnvironment
public class StandardServletEnvironment extends StandardEnvironment
implements ConfigurableWebEnvironment
{
public void initPropertySources(ServletContext servletContext, ServletConfig servletConfig)
{
//初始化ServletPropertySources
WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);
}
public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME = "servletContextInitParams";
public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = "servletConfigInitParams";
public static final String JNDI_PROPERTY_SOURCE_NAME = "jndiProperties";
}
//WebApplicationContext工具类
public abstract class WebApplicationContextUtils
{
//初始化servletContextInitParams
public static void initServletPropertySources(MutablePropertySources propertySources, ServletContext servletContext, ServletConfig servletConfig)
{
Assert.notNull(propertySources, "propertySources must not be null");
if(servletContext != null && propertySources.contains("servletContextInitParams") && (propertySources.get("servletContextInitParams") instanceof org.springframework.core.env.PropertySource.StubPropertySource))
propertySources.replace("servletContextInitParams", new ServletContextPropertySource("servletContextInitParams", servletContext));
if(servletConfig != null && propertySources.contains("servletConfigInitParams") && (propertySources.get("servletConfigInitParams") instanceof org.springframework.core.env.PropertySource.StubPropertySource))
propertySources.replace("servletConfigInitParams", new ServletConfigPropertySource("servletConfigInitParams", servletConfig));
}
}
//ApplicationContextInitializer
public interface ApplicationContextInitializer
{
public abstract void initialize(ConfigurableApplicationContext configurableapplicationcontext);
}
//bean工具类
public abstract class BeanUtils
{
//初始化Class
public static Object instantiateClass(Class clazz)
throws BeanInstantiationException
{
Assert.notNull(clazz, "Class must not be null");
if(clazz.isInterface())
throw new BeanInstantiationException(clazz, "Specified class is an interface");
return instantiateClass(clazz.getDeclaredConstructor(new Class[0]), new Object[0]);
NoSuchMethodException ex;
ex;
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
//根据构造函数初始化Object
public static transient Object instantiateClass(Constructor ctor, Object args[])
throws BeanInstantiationException
{
Assert.notNull(ctor, "Constructor must not be null");
ReflectionUtils.makeAccessible(ctor);
return ctor.newInstance(args);
InstantiationException ex;
ex;
throw new BeanInstantiationException(ctor.getDeclaringClass(), "Is it an abstract class?", ex);
ex;
throw new BeanInstantiationException(ctor.getDeclaringClass(), "Is the constructor accessible?", ex);
ex;
throw new BeanInstantiationException(ctor.getDeclaringClass(), "Illegal arguments for constructor", ex);
ex;
throw new BeanInstantiationException(ctor.getDeclaringClass(), "Constructor threw exception", ex.getTargetException());
}
}
总结：
Spring上下文加载监听，在静态语句块中加载配置文件contextConfigLocation，
然后初始化ServletContext，以便spring容器可以直接访问web容器上下文，注册bean后置处理器，构造bean，初始化消息源，监听器；在构造bean的过程中通过ConfigurationClassParser来解析bean，处理注解，IOC等。