dispatcherservlet.java

spring的源代码

		// a default HandlerAdapter if no other adapters are found.
		if (this.handlerAdapters.isEmpty()) {
			this.handlerAdapters.add(new SimpleControllerHandlerAdapter());
			this.handlerAdapters.add(new ThrowawayControllerHandlerAdapter());
			logger.info("No HandlerAdapters found in servlet '" + getServletName() + "': using defaults");
		}
		else {
			// we keep HandlerAdapters in sorted order
			Collections.sort(this.handlerAdapters, new OrderComparator());
		}
	}

	/**
	 * Initialize the HandlerExceptionResolver used by this class.
	 * If no bean is defined with the given name in the BeanFactory
	 * for this namespace, we default to no exception resolver.
	 */
	private void initHandlerExceptionResolvers() throws BeansException {
		// find all HandlerExceptionResolvers in the ApplicationContext
		Map matchingBeans = getWebApplicationContext().getBeansOfType(HandlerExceptionResolver.class, true, false);
		this.handlerExceptionResolvers = new ArrayList(matchingBeans.values());
		// we keep HandlerExceptionResolvers in sorted order
		Collections.sort(this.handlerExceptionResolvers, new OrderComparator());
	}

	/**
	 * Initialize the ViewResolver used by this class.
	 * If no bean is defined with the given name in the BeanFactory
	 * for this namespace, we default to InternalResourceViewResolver.
	 */
	private void initViewResolver() throws BeansException {
		try {
			this.viewResolver = (ViewResolver) getWebApplicationContext().getBean(VIEW_RESOLVER_BEAN_NAME);
			logger.info("Loaded view resolver [" + viewResolver + "]");
		}
		catch (NoSuchBeanDefinitionException ex) {
			// We need to use the default
			InternalResourceViewResolver vr = new InternalResourceViewResolver();
			vr.setApplicationContext(getWebApplicationContext());
			this.viewResolver = vr;
			logger.info("Unable to locate view resolver with name '" + VIEW_RESOLVER_BEAN_NAME +
									"': using default [" + this.viewResolver + "]");
		}
	}


	/**
	 * Obtain and use the handler for this method.
	 * The handler will be obtained by applying the servlet's HandlerMappings in order.
	 * The HandlerAdapter will be obtained by querying the servlet's
	 * installed HandlerAdapters to find the first that supports the handler class.
	 * Both doGet() and doPost() are handled by this method.
	 * It's up to HandlerAdapters to decide which methods are acceptable.
	 */
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		logger.debug("DispatcherServlet with name '" + getServletName() + "' received request for [" +
		             request.getRequestURI() + "]");

		// make framework objects available for handlers
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);

		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		int interceptorIndex = -1;
		try {
			ModelAndView mv = null;
			try {
				// Convert the request into a multipart request, and make multipart resolver available.
				// If no multipart resolver is set, simply use the existing request.
				if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
					if (request instanceof MultipartHttpServletRequest) {
						logger.info("Request is already a MultipartHttpServletRequest - if not in a forward, " +
												"this typically results from an additional MultipartFilter in web.xml");
					}
					else {
						request.setAttribute(MULTIPART_RESOLVER_ATTRIBUTE, this.multipartResolver);
						processedRequest = this.multipartResolver.resolveMultipart(request);
					}
				}

				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					// if we didn't find a handler
					pageNotFoundLogger.warn("No mapping for [" + request.getRequestURI() +
																	"] in DispatcherServlet with name '" + getServletName() + "'");
					response.sendError(HttpServletResponse.SC_NOT_FOUND);
					return;
				}

				// apply preHandle methods of registered interceptors
				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;
					}
				}

				// actually invoke the handler
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				// apply postHandle methods of registered interceptors
				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);
					}
				}
			}
			catch (ModelAndViewDefiningException ex) {
				logger.debug("ModelAndViewDefiningException encountered", ex);
				mv = ex.getModelAndView();
			}
			catch (Exception ex) {
				ModelAndView exMv = null;
				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
				for (Iterator it = this.handlerExceptionResolvers.iterator(); exMv == null && it.hasNext();) {
					HandlerExceptionResolver resolver = (HandlerExceptionResolver) it.next();
					exMv = resolver.resolveException(request, response, handler, ex);
				}
				if (exMv != null) {
					if (logger.isDebugEnabled()) {
						logger.debug("HandlerExceptionResolver returned ModelAndView [" + exMv + "] for exception");
					}
					logger.warn("Handler execution resulted in exception - forwarding to resolved error view", ex);
					mv = exMv;
				}
				else {
					throw ex;
				}
			}

			// did the handler return a view to render?
			if (mv != null) {
				logger.debug("Will render view in DispatcherServlet with name '" + getServletName() + "'");
				Locale locale = this.localeResolver.resolveLocale(processedRequest);
				response.setLocale(locale);
				render(mv, processedRequest, response, locale);
			}
			else {
				logger.debug("Null ModelAndView returned to DispatcherServlet with name '" +
										 getServletName() + "': assuming HandlerAdapter completed request handling");
			}

			triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
		}
		catch (Exception ex) {
			triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
		}
		finally {
			// clean up any resources used by a multipart request
			if (processedRequest instanceof MultipartHttpServletRequest && processedRequest != request) {
				this.multipartResolver.cleanupMultipart((MultipartHttpServletRequest) processedRequest);
			}
		}
	}

	/**
	 * Override HttpServlet's getLastModified to evaluate the Last-Modified
	 * value of the mapped handler.
	 */
	protected long getLastModified(HttpServletRequest request) {
		try {
			HandlerExecutionChain mappedHandler = getHandler(request);
			if (mappedHandler == null || mappedHandler.getHandler() == null) {
				// ignore -> will reappear on doService
				logger.debug("No handler found in getLastModified");
				return -1;
			}

			HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
			long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
			logger.debug("Last-Modified value for [" + request.getRequestURI() + "] is [" + lastModified + "]");
			return lastModified;
		}
		catch (Exception ex) {
			// ignore -> will reappear on doService
			logger.debug("Exception thrown in getLastModified", ex);
			return -1;
		}
	}

	/**
	 * Return the handler for this request.
	 * Try all handler mappings in order.
	 * @return the handler, or null if no handler could be found
	 */
	private HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		Iterator itr = this.handlerMappings.iterator();
		while (itr.hasNext()) {
			HandlerMapping hm = (HandlerMapping) itr.next();
			logger.debug("Testing handler map [" + hm  + "] in DispatcherServlet with name '" + getServletName() + "'");
			HandlerExecutionChain handler = hm.getHandler(request);
			if (handler != null)
				return handler;
		}
		return null;
	}

	/**
	 * Return the HandlerAdapter for this handler class.
	 * @throws ServletException if no HandlerAdapter can be found for the handler.
	 * This is a fatal error.
	 */
	private HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		Iterator itr = this.handlerAdapters.iterator();
		while (itr.hasNext()) {
			HandlerAdapter ha = (HandlerAdapter) itr.next();
			logger.debug("Testing handler adapter [" + ha + "]");
			if (ha.supports(handler)) {
				return ha;
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
		                           "]: Does your handler implement a supported interface like Controller?");
	}

	/**
	 * Render the given ModelAndView. This is the last stage in handling a request.
	 * It may involve resolving the view by name.
	 * @throws Exception if there's a problem rendering the view
	 */
	private void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response, Locale locale)
	    throws Exception {
		View view = null;
		if (mv.isReference()) {
			// we need to resolve this view name
			view = this.viewResolver.resolveViewName(mv.getViewName(), locale);
		}
		else {
			// no need to lookup: the ModelAndView object contains the actual View object
			view = mv.getView();
		}
		if (view == null) {
			throw new ServletException("Error in ModelAndView object or View resolution encountered by servlet with name '" +
																 getServletName() + "': View to render cannot be null with ModelAndView [" + mv + "]");
		}
		view.render(mv.getModel(), request, response);
	}

	/**
	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
	 * Will just invoke afterCompletion for all interceptors whose preHandle
	 * invocation has successfully completed and returned true.
	 * @param mappedHandler the mapped HandlerExecutionChain
	 * @param interceptorIndex index of last interceptor that successfully completed
	 * @param ex Exception thrown on handler execution, or null if none
	 * @see HandlerInterceptor#afterCompletion
	 */
	private void triggerAfterCompletion(HandlerExecutionChain mappedHandler, int interceptorIndex,
																					 HttpServletRequest request, HttpServletResponse response,
																					 Exception ex) throws Exception {
		// apply afterCompletion methods of registered interceptors
		Exception currEx = ex;
		if (mappedHandler != null) {
			if (mappedHandler.getInterceptors() != null) {
				for (int i = interceptorIndex; i >=0; i--) {
					HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i];
					try {
						interceptor.afterCompletion(request, response, mappedHandler.getHandler(), ex);
					}
					catch (Exception ex2) {
						if (currEx != null) {
							logger.error("Exception overridden by HandlerInterceptor.afterCompletion exception", currEx);
						}
						currEx = ex2;
					}
				}
			}
		}
		if (currEx != null) {
			throw currEx;
		}
	}

}