protected HandlerInterceptor adaptInterceptor(Object interceptor) 
{
		if (interceptor instanceof HandlerInterceptor) {
			return (HandlerInterceptor) interceptor;
		}
		else if (interceptor instanceof WebRequestInterceptor) {
			return new WebRequestHandlerInterceptorAdapter((WebRequestInterceptor) interceptor);
		}
		else {
			throw new IllegalArgumentException("Interceptor type not supported: " + interceptor.getClass().getName());
		}
}

Adapt the given interceptor object to the HandlerInterceptor interface.

Supported interceptor types are HandlerInterceptor and WebRequestInterceptor. Each given WebRequestInterceptor will be wrapped in a WebRequestHandlerInterceptorAdapter. Can be overridden in subclasses.

 protected  void extendInterceptors(List interceptors) 
{

}

Extension hook that subclasses can override to register additional interceptors, given the configured interceptors (see #setInterceptors ).

Will be invoked before #initInterceptors() adapts the specified interceptors into HandlerInterceptor instances.

The default implementation is empty.

 protected final HandlerInterceptor[] getAdaptedInterceptors() 
{
		return this.adaptedInterceptors;
}

Return the adapted interceptors as HandlerInterceptor array.

 public Object getDefaultHandler() 
{
		return this.defaultHandler;
}

Return the default handler for this handler mapping, or null if none.

 public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception 
{
		Object handler = getHandlerInternal(request);
		if (handler == null) {
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		// Bean name or resolved handler?
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = getApplicationContext().getBean(handlerName);
		}
		return getHandlerExecutionChain(handler, request);
}

Look up a handler for the given request, falling back to the default handler if no specific one is found.

 protected HandlerExecutionChain getHandlerExecutionChain(Object handler,
    HttpServletRequest request) 
{
		if (handler instanceof HandlerExecutionChain) {
			HandlerExecutionChain chain = (HandlerExecutionChain) handler;
			chain.addInterceptors(getAdaptedInterceptors());
			return chain;
		}
		else {
			return new HandlerExecutionChain(handler, getAdaptedInterceptors());
		}
}

Build a HandlerExecutionChain for the given handler, including applicable interceptors.

The default implementation simply builds a standard HandlerExecutionChain with the given handler and this handler mapping's common interceptors. Subclasses may override this in order to extend/rearrange the list of interceptors.

NOTE: The passed-in handler object may be a raw handler or a pre-built HandlerExecutionChain. This method should handle those two cases explicitly, either building a new HandlerExecutionChain or extending the existing chain.

For simply adding an interceptor, consider calling super.getHandlerExecutionChain and invoking HandlerExecutionChain#addInterceptor on the returned chain object.

 abstract protected Object getHandlerInternal(HttpServletRequest request) throws Exception
Look up a handler for the given request, returning null if no
specific one is found. This method is called by #getHandler ;
a null return value will lead to the default handler, if one is set.
Note: This method may also return a pre-built HandlerExecutionChain ,
combining a handler object with dynamically determined interceptors.
Statically specified interceptors will get merged into such an existing chain.

 public final int getOrder() 
{
	  return this.order;
}

 protected  void initApplicationContext() throws BeansException 
{
		extendInterceptors(this.interceptors);
		initInterceptors();
}

Initializes the interceptors.

 protected  void initInterceptors() 
{
		if (!this.interceptors.isEmpty()) {
			this.adaptedInterceptors = new HandlerInterceptor[this.interceptors.size()];
			for (int i = 0; i <  this.interceptors.size(); i++) {
				Object interceptor = this.interceptors.get(i);
				if (interceptor == null) {
					throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
				}
				this.adaptedInterceptors[i] = adaptInterceptor(interceptor);
			}
		}
}

Initialize the specified interceptors, adapting them where necessary.

 public  void setDefaultHandler(Object defaultHandler) 
{
		this.defaultHandler = defaultHandler;
}

Set the default handler for this handler mapping. This handler will be returned if no specific mapping was found.

Default is null, indicating no default handler.

 public  void setInterceptors(Object[] interceptors) 
{
		this.interceptors.addAll(Arrays.asList(interceptors));
}

Set the interceptors to apply for all handlers mapped by this handler mapping.

Supported interceptor types are HandlerInterceptor and WebRequestInterceptor.

 public final  void setOrder(int order) 
{
	                  	 
	  this.order = order;
}

Specify the order value for this HandlerMapping bean.

Default value is Integer.MAX_VALUE, meaning that it's non-ordered.