//这里是对DispatcherServlet的初始化方法，根据名字我们很方面的看到对各个Spring MVC主要元素的初始化  
protected void initFrameworkServlet() throws ServletException, BeansException {  
    initMultipartResolver();  
    initLocaleResolver();  
    initThemeResolver();  
    initHandlerMappings();  
    initHandlerAdapters();  
    initHandlerExceptionResolvers();  
    initRequestToViewNameTranslator();  
    initViewResolvers();  
}

private void initHandlerMappings() throws BeansException {  
    if (this.detectAllHandlerMappings) {  
         // 这里找到所有在上下文中定义的HandlerMapping,同时把他们排序  
         // 因为在同一个上下文中可以有不止一个handlerMapping,所以我们把他们都载入到一个链里进行维护和管理  
        Map matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(  
                getWebApplicationContext(), HandlerMapping.class, true, false);  
        if (!matchingBeans.isEmpty()) {  
            this.handlerMappings = new ArrayList(matchingBeans.values());  
            // 这里通过order属性来对handlerMapping来在list中排序  
            Collections.sort(this.handlerMappings, new OrderComparator());  
        }
    }
    else {  
        try {  
            Object hm = getWebApplicationContext().getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);  
            this.handlerMappings = Collections.singletonList(hm);  
        }
        catch (NoSuchBeanDefinitionException ex) {  
            // Ignore, we'll add a default HandlerMapping later.  
        }
    }
  
    //如果在上下文中没有定义的话，那么我们使用默认的BeanNameUrlHandlerMapping  
    if (this.handlerMappings == null) {  
        this.handlerMappings = getDefaultStrategies(HandlerMapping.class);  
    ........  
    }
}

public interface HandlerMapping {  
  public static final String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE =  
                    Conventions.getQualifiedAttributeName(HandlerMapping.class, "pathWithinHandlerMapping");  
      //实际上维护一个HandlerExecutionChain,这是典型的Command的模式的使用，这个执行链里面维护handler和拦截器  
    HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;  
}

public class HandlerExecutionChain {  
  
    private Object handler;  
  
    private HandlerInterceptor[] interceptors;  
     
    ........  
}

protected void registerHandlers(Map urlMap) throws BeansException {  
    if (urlMap.isEmpty()) {  
        logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");  
    }
    else {  
        //这里迭代在SimpleUrlHandlerMapping中定义的所有映射元素  
        Iterator it = urlMap.keySet().iterator();  
        while (it.hasNext()) {  
            //这里取得配置的url  
            String url = (String) it.next();  
            //这里根据url在bean定义中取得对应的handler  
            Object handler = urlMap.get(url);  
            // Prepend with slash if not already present.  
            if (!url.startsWith("/")) {  
                url = "/" + url;  
            }
            //这里调用AbstractHandlerMapping中的注册过程  
            registerHandler(url, handler);  
        }
    }
}

protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {  
    //试图从handlerMap中取handler,看看是否已经存在同样的Url映射关系  
    Object mappedHandler = this.handlerMap.get(urlPath);  
    if (mappedHandler != null) {  
    ........  
    }
  
    //如果是直接用bean名做映射那就直接从容器中取handler  
    if (!this.lazyInitHandlers && handler instanceof String) {  
        String handlerName = (String) handler;  
        if (getApplicationContext().isSingleton(handlerName)) {  
            handler = getApplicationContext().getBean(handlerName);  
        }
    }
    //或者使用默认的handler.  
    if (urlPath.equals("/*")) {  
        setDefaultHandler(handler);  
    }
    else {  
   //把url和handler的对应关系放到handlerMap中去  
        this.handlerMap.put(urlPath, handler);  
        ........  
    }
}

private final Map handlerMap = new HashMap();

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {  
    //这里根据request中的参数得到其对应的handler,具体处理在AbstractUrlHandlerMapping中  
    Object handler = getHandlerInternal(request);  
    //如果找不到对应的，就使用缺省的handler  
    if (handler == null) {  
        handler = this.defaultHandler;  
    }
    //如果缺省的也没有，那就没办法了  
    if (handler == null) {  
        return null;  
    }
    // 如果handler不是一个具体的handler,那我们还要到上下文中取  
    if (handler instanceof String) {  
        String handlerName = (String) handler;  
        handler = getApplicationContext().getBean(handlerName);  
    }
    //生成一个HandlerExecutionChain,其中放了我们匹配上的handler和定义好的拦截器，就像我们在HandlerExecutionChain中看到的那样，它持有一个handler和一个拦截器组。  
    return new HandlerExecutionChain(handler, this.adaptedInterceptors);  
}

protected Object getHandlerInternal(HttpServletRequest request) throws Exception {  
    //这里的HTTP Request传进来的参数进行分析，得到具体的路径信息。  
    String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);  
    .......//下面是根据请求信息的查找  
    return lookupHandler(lookupPath, request);  
}
  
protected Object lookupHandler(String urlPath, HttpServletRequest request) {  
    // 如果能够直接能在SimpleUrlHandlerMapping的映射表中找到，那最好。  
    Object handler = this.handlerMap.get(urlPath);  
    if (handler == null) {  
        // 这里使用模式来对map中的所有handler进行匹配，调用了Jre中的Matcher类来完成匹配处理。  
        String bestPathMatch = null;  
        for (Iterator it = this.handlerMap.keySet().iterator(); it.hasNext();) {  
            String registeredPath = (String) it.next();  
            if (this.pathMatcher.match(registeredPath, urlPath) &&  
                            (bestPathMatch == null || bestPathMatch.length() <= registeredPath.length())) {  
                //这里根据匹配路径找到最象的一个  
                handler = this.handlerMap.get(registeredPath);  
                bestPathMatch = registeredPath;  
            }
        }
  
        if (handler != null) {  
            exposePathWithinMapping(this.pathMatcher.extractPathWithinPattern(bestPathMatch, urlPath), request);  
        }
    }
    else {  
        exposePathWithinMapping(urlPath, request);  
    }
    //  
    return handler;  
}

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {  
    .......  
    //这里把属性信息进行保存  
    Map attributesSnapshot = null;  
    if (WebUtils.isIncludeRequest(request)) {  
        logger.debug("Taking snapshot of request attributes before include");  
        attributesSnapshot = new HashMap();  
        Enumeration attrNames = request.getAttributeNames();  
        while (attrNames.hasMoreElements()) {  
            String attrName = (String) attrNames.nextElement();  
            if (this.cleanupAfterInclude || attrName.startsWith(DispatcherServlet.class.getName())) {  
                attributesSnapshot.put(attrName, request.getAttribute(attrName));  
            }
        }
    }
  
    // Make framework objects available to handlers and view objects.  
    request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());  
    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);  
    request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);  
    request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());  
  
    try {  
         //这里使实际的处理入口  
        doDispatch(request, response);  
    }
    finally {  
        // Restore the original attribute snapshot, in case of an include.  
        if (attributesSnapshot != null) {  
            restoreAttributesAfterInclude(request, attributesSnapshot);  
        }
    }
}

protected void doDispatch(final HttpServletRequest request, HttpServletResponse response) throws Exception {  
    HttpServletRequest processedRequest = request;  
    //这是从handlerMapping中得到的执行链  
    HandlerExecutionChain mappedHandler = null;  
    int interceptorIndex = -1;  
     
    ........  
    try {  
        //我们熟悉的ModelAndView开始出现了。  
        ModelAndView mv = null;  
        try {  
            processedRequest = checkMultipart(request);  
  
            // 这是我们得到handler的过程  
            mappedHandler = getHandler(processedRequest, false);  
            if (mappedHandler == null || mappedHandler.getHandler() == null) {  
                noHandlerFound(processedRequest, response);  
                return;  
            }
  
            // 这里取出执行链中的Interceptor进行前处理  
            if (mappedHandler.getInterceptors() != null) {  
                for (int i = 0; i < mappedHandler.getInterceptors().length; i++) {  
                    HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i];  
                    if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {  
                        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
                        return;  
                    }
                    interceptorIndex = i;  
                }
            }
  
            //在执行handler之前，用HandlerAdapter先检查一下handler的合法性：是不是按Spring的要求编写的。  
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  
            // 这里取出执行链中的Interceptor进行后处理  
            if (mappedHandler.getInterceptors() != null) {  
                for (int i = mappedHandler.getInterceptors().length - 1; i >= 0; i--) {  
                    HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i];  
                    interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);  
                }
            }
        }
         
        ........  
  
        // Did the handler return a view to render?  
        //这里对视图生成进行处理  
        if (mv != null && !mv.wasCleared()) {  
            render(mv, processedRequest, response);  
        }
        .......  
}

protected HandlerExecutionChain getHandler(HttpServletRequest request, boolean cache) throws Exception {  
  //在ServletContext取得执行链 - 实际上第一次得到它的时候，我们把它放在ServletContext进行了缓存。  
  HandlerExecutionChain handler =  
            (HandlerExecutionChain) request.getAttribute(HANDLER_EXECUTION_CHAIN_ATTRIBUTE);  
    if (handler != null) {  
        if (!cache) {  
            request.removeAttribute(HANDLER_EXECUTION_CHAIN_ATTRIBUTE);  
        }
        return handler;  
    }
    //这里的迭代器迭代的时在initHandlerMapping中载入的上下文所有的HandlerMapping  
    Iterator it = this.handlerMappings.iterator();  
    while (it.hasNext()) {  
        HandlerMapping hm = (HandlerMapping) it.next();  
        .......  
        //这里是实际取得handler的过程,在每个HandlerMapping中建立的映射表进行检索得到请求对应的handler  
        handler = hm.getHandler(request);  
  
        //然后把handler存到ServletContext中去进行缓存  
        if (handler != null) {  
            if (cache) {  
                request.setAttribute(HANDLER_EXECUTION_CHAIN_ATTRIBUTE, handler);  
            }
            return handler;  
        }
    }
    return null;  
}

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {  
    Iterator it = this.handlerAdapters.iterator();  
    while (it.hasNext()) {  
        //同样对持有的所有adapter进行匹配  
        HandlerAdapter ha = (HandlerAdapter) it.next();  
        if (ha.supports(handler)) {  
            return ha;  
        }
    }
    ........  
}

public class SimpleControllerHandlerAdapter implements HandlerAdapter {  
     
    public boolean supports(Object handler) {  
        return (handler instanceof Controller);  
    }
    .......  
}

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  

这个就是对handle的具体调用！相当于Command模式里的Command.execute();理所当然的返回一个ModelAndView，下面就是一个对View进行处理的过程： 
```java
if (mv != null && !mv.wasCleared()) {  
    render(mv, processedRequest, response);  
}

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response)  
         throws Exception {response.setLocale(locale);  
  
     View view = null;  
     //这里把默认的视图放到ModelAndView中去。  
     if (!mv.hasView()) {  
         mv.setViewName(getDefaultViewName(request));  
     }
  
     if (mv.isReference()) {  
         // 这里对视图名字进行解析  
         view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);  
     .......  
     }
     else {  
         // 有可能在ModelAndView里已经直接包含了View对象，那我们就直接使用。  
         view = mv.getView();  
     ........  
     }
  
     //得到具体的View对象以后，我们用它来生成视图。  
     view.render(mv.getModelInternal(), request, response);  
 }

public void render(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception {  
    ......  
    // 这里把所有的相关信息都收集到一个Map里  
    Map mergedModel = new HashMap(this.staticAttributes.size() + (model != null ? model.size() : 0));  
    mergedModel.putAll(this.staticAttributes);  
    if (model != null) {  
        mergedModel.putAll(model);  
    }
  
    // Expose RequestContext?  
    if (this.requestContextAttribute != null) {  
        mergedModel.put(this.requestContextAttribute, createRequestContext(request, mergedModel));  
    }
    //这是实际的展现模型数据到视图的调用。  
    renderMergedOutputModel(mergedModel, request, response);  
}

protected void renderMergedOutputModel(  
       Map model, HttpServletRequest request, HttpServletResponse response) throws Exception {  
  
   // Expose the model object as request attributes.  
   exposeModelAsRequestAttributes(model, request);  
  
   // Expose helpers as request attributes, if any.  
   exposeHelpers(request);  
  
   // 这里得到InternalResource定义的内部资源路径。  
   String dispatcherPath = prepareForRendering(request, response);  
  
   //这里把请求转发到前面得到的内部资源路径中去。  
   RequestDispatcher rd = request.getRequestDispatcher(dispatcherPath);  
   if (rd == null) {  
       throw new ServletException(  
               "Could not get RequestDispatcher for [" + getUrl() + "]: check that this file exists within your WAR");  
   }
   .......

protected void exposeModelAsRequestAttributes(Map model, HttpServletRequest request) throws Exception {  
      Iterator it = model.entrySet().iterator();  
      while (it.hasNext()) {  
          Map.Entry entry = (Map.Entry) it.next();  
          ..........  
          String modelName = (String) entry.getKey();  
          Object modelValue = entry.getValue();  
          if (modelValue != null) {  
              request.setAttribute(modelName, modelValue);  
          ...........  
          }
          else {  
              request.removeAttribute(modelName);  
              .......  
          }
      }
  }

public class JstlView extends InternalResourceView {  
  
    private MessageSource jstlAwareMessageSource;  
  
  
    protected void initApplicationContext() {  
        super.initApplicationContext();  
        this.jstlAwareMessageSource =  
                JstlUtils.getJstlAwareMessageSource(getServletContext(), getApplicationContext());  
    }
  
    protected void exposeHelpers(HttpServletRequest request) throws Exception {  
        JstlUtils.exposeLocalizationContext(request, this.jstlAwareMessageSource);  
    }
  
}

protected String prepareForRendering(HttpServletRequest request, HttpServletResponse response)  
       throws Exception {  
  
   return getUrl();

protected AbstractUrlBasedView buildView(String viewName) throws Exception {  
    AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(getViewClass());  
    view.setUrl(getPrefix() + viewName + getSuffix());  
    String contentType = getContentType();  
    if (contentType != null) {  
        view.setContentType(contentType);  
    }
    view.setRequestContextAttribute(getRequestContextAttribute());  
    view.setAttributesMap(getAttributesMap());  
    return view;  
}

 protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response)  
         throws Exception {  
  
     ........  
     View view = null;  
  
     // 这里设置视图名为默认的名字  
     if (!mv.hasView()) {  
         mv.setViewName(getDefaultViewName(request));  
     }
  
     if (mv.isReference()) {  
         //这里对视图名进行解析，在解析的过程中根据需要生成实际需要的视图对象。  
         view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);  
        ..........  
     }
    ......  
}

protected View resolveViewName(String viewName, Map model, Locale locale, HttpServletRequest request)  
            throws Exception {  
         //我们有可能不止一个视图解析器  
        for (Iterator it = this.viewResolvers.iterator(); it.hasNext();) {  
            ViewResolver viewResolver = (ViewResolver) it.next();  
            //这里是视图解析器进行解析并生成视图的过程。  
            View view = viewResolver.resolveViewName(viewName, locale);  
            if (view != null) {  
                return view;  
            }
        }
        return null;  
    }

public View resolveViewName(String viewName, Locale locale) throws Exception {  
    //如果没有打开缓存设置，那创建需要的视图  
    if (!isCache()) {  
        logger.warn("View caching is SWITCHED OFF -- DEVELOPMENT SETTING ONLY: This can severely impair performance");  
        return createView(viewName, locale);  
    }
    else {  
        Object cacheKey = getCacheKey(viewName, locale);  
        // No synchronization, as we can live with occasional double caching.  
        synchronized (this.viewCache) {  
            //这里查找缓存里的视图对象  
            View view = (View) this.viewCache.get(cacheKey);  
            if (view == null) {  
                //如果在缓存中没有找到，创建一个并把创建的放到缓存中去  
                view = createView(viewName, locale);  
                this.viewCache.put(cacheKey, view);  
            ........  
            }
            return view;  
        }
    }
}

protected final void renderMergedOutputModel(  
        Map model, HttpServletRequest request, HttpServletResponse response) throws Exception {  
    .........  
    // response.setContentLength(workbook.getBytes().length);  
    response.setContentType(getContentType());  
    ServletOutputStream out = response.getOutputStream();  
    workbook.write(out);  
    out.flush();  
}

public interface Advice {

}

public interface BeforeAdvice extends Advice {

}

public interface AfterAdvice extends Advice {

}

public interface ThrowsAdvice extends AfterAdvice {

}

// 前置增强接口，使用这个前置接口需要实现一个回调函数
public interface MethodBeforeAdvice extends BeforeAdvice {

    /**
     * 作为回调函数，该方法的实现在Advice中被配置到目标方法后，会调用目标方法时被回调
     * @param method Method对象，是目标方法的反射对象
     * @param args 对象数组，包含目标方法的输入参数
     * @param target
     * @throws Throwable
     */
    void before(Method method, Object[] args, Object target) throws Throwable;

}

public interface AfterReturningAdvice extends AfterAdvice {
    /**
     * 作为回调函数，该方法的实现在Advice中被配置到目标方法返回后，对目标返回结果进行增强
     * @param returnValue 返回值
     * @param method Method对象，是目标方法的反射对象
     * @param args 对象数组，包含目标方法的输入参数
     * @param target
     * @throws Throwable
     */
    void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;

}

public interface Pointcut {  
    //获取类过滤器  
    ClassFilter getClassFilter();  

    //获取匹配切入点的方法      
    MethodMatcher getMethodMatcher();  

    //总匹配的标准切入点实例  
    Pointcut TRUE = TruePointcut.INSTANCE;  
}

public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {  
    //要编译的正则表达式模式  
    private Pattern[] compiledPatterns = new Pattern[0];  
    //编译时要排除的正则表达式模式  
    private Pattern[] compiledExclusionPatterns = new Pattern[0];  

    //将给定的模式字符串数组初始化为编译的正则表达式模式  
    protected void initPatternRepresentation(String[] patterns) throws PatternSyntaxException {  
        this.compiledPatterns = compilePatterns(patterns);  
    }

    //将给定的模式字符串数组初始化为编译时要排除的正则表达式模式  
    protected void initExcludedPatternRepresentation(String[] excludedPatterns) throws PatternSyntaxException {  
        this.compiledExclusionPatterns = compilePatterns(excludedPatterns);  
    }

    //使用正则表达式匹配给定的名称  
    protected boolean matches(String pattern, int patternIndex) {  
        Matcher matcher = this.compiledPatterns[patternIndex].matcher(pattern);  
        return matcher.matches();  
    }

    //使用要排除的正则表达式匹配给定的名称  
    protected boolean matchesExclusion(String candidate, int patternIndex) {  
        Matcher matcher = this.compiledExclusionPatterns[patternIndex].matcher(candidate);  
        return matcher.matches();  
    }

    //将给定的字符串数组编译为正则表达的模式  
    private Pattern[] compilePatterns(String[] source) throws PatternSyntaxException {  
        Pattern[] destination = new Pattern[source.length];  
        for (int i = 0; i < source.length; i++) {  
            destination[i] = Pattern.compile(source[i]);  
        }  
        return destination;  
    }
}

public interface Advisor {  
    //获取切面的通知Advice  
    Advice getAdvice();  

    //判断这个通知是否和某个特定的实例对象相关  
    boolean isPerInstance();  
}

public interface BeanFactory {  
  
    //这里是对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，  
    //如果需要得到工厂本身，需要转义         
    String FACTORY_BEAN_PREFIX = "&";  
  
  
    //这里根据bean的名字，在IOC容器中得到bean实例，这个IOC容器就是一个大的抽象工厂。  
    Object getBean(String name) throws BeansException;  
  
    //这里根据bean的名字和Class类型来得到bean实例，和上面的方法不同在于它会抛出异常：如果根据名字取得的bean实例的Class类型和需要的不同的话。  
    Object getBean(String name, Class requiredType) throws BeansException;  
  
    //这里提供对bean的检索，看看是否在IOC容器有这个名字的bean  
    boolean containsBean(String name);  
  
    //这里根据bean名字得到bean实例，并同时判断这个bean是不是单件  
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;  
  
    //这里对得到bean实例的Class类型  
    Class getType(String name) throws NoSuchBeanDefinitionException;  
  
    //这里得到bean的别名，如果根据别名检索，那么其原名也会被检索出来  
    String[] getAliases(String name);  
  
}

ClassPathResource res = new ClassPathResource("beans.xml");  
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();  
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);  
reader.loadBeanDefinitions(res);

public class XmlBeanFactory extends DefaultListableBeanFactory {  
    //这里为容器定义了一个默认使用的bean定义读取器  
    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);  
    public XmlBeanFactory(Resource resource) throws BeansException {  
        this(resource, null);  
    }
    //在初始化函数中使用读取器来对资源进行读取，得到bean定义信息。  
    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {  
        super(parentBeanFactory);  
        this.reader.loadBeanDefinitions(resource);  
    }

ApplicationContext = new FileSystemXmlApplicationContext(xmlPath);

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)  
        throws BeansException {  
    super(parent);  
    this.configLocations = configLocations;  
    if (refresh) {  
      　//这里是IoC容器的初始化过程，其初始化过程的大致步骤由AbstractApplicationContext来定义  
        refresh();  
    }
}

public void refresh() throws BeansException, IllegalStateException {  
    synchronized (this.startupShutdownMonitor) {  
        synchronized (this.activeMonitor) {  
            this.active = true;  
        }
  
        // 这里需要子类来协助完成资源位置定义,bean载入和向IOC容器注册的过程  
        refreshBeanFactory();  
        ............  
 }

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {  
    // 这里使用XMLBeanDefinitionReader来载入bean定义信息的XML文件  
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  
  
    //这里配置reader的环境，其中ResourceLoader是我们用来定位bean定义信息资源位置的  
    ///因为上下文本身实现了ResourceLoader接口，所以可以直接把上下文作为ResourceLoader传递给XmlBeanDefinitionReader  
    beanDefinitionReader.setResourceLoader(this);  
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  
  
    initBeanDefinitionReader(beanDefinitionReader);  
    //这里转到定义好的XmlBeanDefinitionReader中对载入bean信息进行处理  
    loadBeanDefinitions(beanDefinitionReader);  
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {  
    Resource[] configResources = getConfigResources();  
    if (configResources != null) {  
        //调用XmlBeanDefinitionReader来载入bean定义信息。  
        reader.loadBeanDefinitions(configResources);  
    }
    String[] configLocations = getConfigLocations();  
    if (configLocations != null) {  
        reader.loadBeanDefinitions(configLocations);  
    }
}

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {  
 //这里得到当前定义的ResourceLoader,默认的我们使用DefaultResourceLoader  
 ResourceLoader resourceLoader = getResourceLoader();  
 .........//如果没有找到我们需要的ResourceLoader，直接抛出异常  
    if (resourceLoader instanceof ResourcePatternResolver) {  
        // 这里处理我们在定义位置时使用的各种pattern,需要ResourcePatternResolver来完成  
        try {  
            Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);  
            int loadCount = loadBeanDefinitions(resources);  
            return loadCount;  
        }
      ........  
    }
    else {  
        // 这里通过ResourceLoader来完成位置定位  
        Resource resource = resourceLoader.getResource(location);  
        // 这里已经把一个位置定义转化为Resource接口，可以供XmlBeanDefinitionReader来使用了  
        int loadCount = loadBeanDefinitions(resource);  
        return loadCount;  
    }
}

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {  
    public Resource getResource(String location) {  
        //这里调用当前的loader也就是DefaultResourceLoader来完成载入  
        if (this.resourceLoader != null) {  
            return this.resourceLoader.getResource(location);  
        }
        return super.getResource(location);  
    }
.......  
}

public Resource getResource(String location) {  
    //如果是类路径的方式，那需要使用ClassPathResource来得到bean文件的资源对象  
    if (location.startsWith(CLASSPATH_URL_PREFIX)) {  
        return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());  
    }
    else {  
        try {  
            // 如果是URL方式，使用UrlResource作为bean文件的资源对象  
            URL url = new URL(location);  
            return new UrlResource(url);  
        }
        catch (MalformedURLException ex) {  
            // 如果都不是，那我们只能委托给子类由子类来决定使用什么样的资源对象了  
            return getResourceByPath(location);  
        }
    }
}

protected Resource getResourceByPath(String path) {  
    if (path != null && path.startsWith("/")) {  
        path = path.substring(1);  
    }
    //这里使用文件系统资源对象来定义bean文件  
    return new FileSystemResource(path);  
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {  
    .......  
    try {  
        //这里通过Resource得到InputStream的IO流  
        InputStream inputStream = encodedResource.getResource().getInputStream();  
        try {  
            //从InputStream中得到XML的解析源  
            InputSource inputSource = new InputSource(inputStream);  
            if (encodedResource.getEncoding() != null) {  
                inputSource.setEncoding(encodedResource.getEncoding());  
            }
            //这里是具体的解析和注册过程  
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());  
        }
        finally {  
            //关闭从Resource中得到的IO流  
            inputStream.close();  
        }
    }
       .........  
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)  
        throws BeanDefinitionStoreException {  
    try {  
        int validationMode = getValidationModeForResource(resource);  
        //通过解析得到DOM，然后完成bean在IOC容器中的注册  
        Document doc = this.documentLoader.loadDocument(  
                inputSource, this.entityResolver, this.errorHandler, validationMode, this.namespaceAware);  
        return registerBeanDefinitions(doc, resource);  
    }
.......  
}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {  
    // 这里定义解析器，使用XmlBeanDefinitionParser来解析xml方式的bean定义文件 - 现在的版本不用这个解析器了，使用的是XmlBeanDefinitionReader  
    if (this.parserClass != null) {  
        XmlBeanDefinitionParser parser =  
                (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);  
        return parser.registerBeanDefinitions(this, doc, resource);  
    }
    // 具体的注册过程,首先得到XmlBeanDefinitionReader,来处理xml的bean定义文件  
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();  
    int countBefore = getBeanFactory().getBeanDefinitionCount();  
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));  
    return getBeanFactory().getBeanDefinitionCount() - countBefore;  
}

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {  
    this.readerContext = readerContext;  
  
    logger.debug("Loading bean definitions");  
    Element root = doc.getDocumentElement();  
  
    BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);  
  
    preProcessXml(root);  
    parseBeanDefinitions(root, delegate);  
    postProcessXml(root);  
}
  
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {  
    if (delegate.isDefaultNamespace(root.getNamespaceURI())) {  
        //这里得到xml文件的子节点，比如各个bean节点           
        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;  
                String namespaceUri = ele.getNamespaceURI();  
                if (delegate.isDefaultNamespace(namespaceUri)) {  
                    //这里是解析过程的调用，对缺省的元素进行分析比如bean元素  
                    parseDefaultElement(ele, delegate);  
                }
                else {  
                    delegate.parseCustomElement(ele);  
                }
            }
        }
    } else {  
        delegate.parseCustomElement(root);  
    }
}
  
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {  
    //这里对元素Import进行处理  
    if (DomUtils.nodeNameEquals(ele, IMPORT_ELEMENT)) {  
        importBeanDefinitionResource(ele);  
    }
    else if (DomUtils.nodeNameEquals(ele, ALIAS_ELEMENT)) {  
        String name = ele.getAttribute(NAME_ATTRIBUTE);  
        String alias = ele.getAttribute(ALIAS_ATTRIBUTE);  
        getReaderContext().getReader().getBeanFactory().registerAlias(name, alias);  
        getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));  
    }
    //这里对我们最熟悉的bean元素进行处理  
    else if (DomUtils.nodeNameEquals(ele, BEAN_ELEMENT)) {  
        //委托给BeanDefinitionParserDelegate来完成对bean元素的处理，这个类包含了具体的bean解析的过程。  
        // 把解析bean文件得到的信息放到BeanDefinition里，他是bean信息的主要载体，也是IOC容器的管理对象。  
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  
        if (bdHolder != null) {  
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);  
            // 这里是向IOC容器注册，实际上是放到IOC容器的一个map里  
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());  
  
            // 这里向IOC容器发送事件，表示解析和注册完成。  
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));  
        }
    }
}

public static void registerBeanDefinition(  
        BeanDefinitionHolder bdHolder, BeanDefinitionRegistry beanFactory) throws BeansException {  
  
    // 这里得到需要注册bean的名字；  
    String beanName = bdHolder.getBeanName();  
    //这是调用IOC来注册的bean的过程，需要得到BeanDefinition  
    beanFactory.registerBeanDefinition(beanName, bdHolder.getBeanDefinition());  
  
    // 别名也是可以通过IOC容器和bean联系起来的进行注册  
    String[] aliases = bdHolder.getAliases();  
    if (aliases != null) {  
        for (int i = 0; i < aliases.length; i++) {  
            beanFactory.registerAlias(beanName, aliases[i]);  
        }
    }
}

//---------------------------------------------------------------------  
// 这里是IOC容器对BeanDefinitionRegistry接口的实现  
//---------------------------------------------------------------------  
  
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
        throws BeanDefinitionStoreException {  
  
    .....//这里省略了对BeanDefinition的验证过程  
    //先看看在容器里是不是已经有了同名的bean,如果有抛出异常。  
    Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);  
    if (oldBeanDefinition != null) {  
        if (!this.allowBeanDefinitionOverriding) {  
        ...........  
    }
    else {  
        //把bean的名字加到IOC容器中去  
        this.beanDefinitionNames.add(beanName);  
    }
    //这里把bean的名字和Bean定义联系起来放到一个HashMap中去,IOC容器通过这个Map来维护容器里的Bean定义信息。  
    this.beanDefinitionMap.put(beanName, beanDefinition);  
    removeSingleton(beanName);  
}

public class ContextClosedEvent extends ApplicationEvent {  
  
    public ContextClosedEvent(ApplicationContext source) {  
        super(source);  
    }
  
    public ApplicationContext getApplicationContext() {  
        return (ApplicationContext) getSource();  
    }
}

// Map of bean definition objects, keyed by bean name
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();