La fragua de los fusiones implementa el gethandler especificado por la interfaz de mano a mano
1. Proporcione el método de plantilla gethandlerinternal para subclase la implementación
2. Si no se obtiene el controlador, se usa el desfalador predeterminado.
3. Si el controlador es de tipo de cadena, obtenga la instancia del contexto
4. Encapsula el controlador a través de GethandlerExecutionchain y agregue el interceptor
// AbstractThandLermapping/*** busque un controlador para la solicitud dada, volviendo al controlador* predeterminado si no se encuentra ningún específico.* @Param solicitud actual http solicitud* @return la instancia del controlador correspondiente, o el controlador predeterminado* @See #gethandlerinternal*/public final final handleRexecutionChain Gethandler (httpServletRequest Solicitud) #excepción #excepción de objeto = ObjectNer = Public Final HandleReMeReXECUTion gethandlerInternal (request); if (handler == null) {handler = getdefaUntHandler ();} if (handler == null) {return null;} // bean name o resolved Handler? if (instancia handler de string) {string handlerneM getHandLerExecutionChain (Handler, Solicitue);} // AbstractThandLermapping/*** Build a HandLerExecutionChain para el controlador dado, incluidos los interceptores aplicables.* <p> La implementación predeterminada simplemente construye un Interceptein de HandLeRexecution estándar con* el manejador dado, el manejador de manejador, los interceptores comunes del manejador y cualquier {@@@@link MapePedinterceptor} Url. Las subclases pueden* anular esto para extender/reorganizar la lista de interceptores.* <p> <b> Nota: </b> El objeto del controlador aprobado puede ser un controlador sin procesar o una cadena de manejo de HandleReXeRex de precipitado. Este método debe manejar esos dos casos explícitamente,* ya sea construir un nuevo handleRexecutionChain o extender la cadena existente.* <p> Para simplemente agregar un interceptor, considere llamar a {@code super.gethandlerExecutionChain}* e invocar {@link HandleReCutionChain#addinterceptor} en el objeto de la cadena de cadena devuelto (@param Handler The Resolped Handler (la instancia de Handler resuelta (la instancia de Handler@@Coder@@Coder@@code@@code @Coder@@code@@code @Coder@@Coder@@code. null})* @param solicitud actual solicitud http* @return el handleReXecutionChain (nunca {@code null})* @see #getAdaptedInterceptors ()*/protegido HandleReXECutionChain getHandLeReXECUTUCIONCHAIN (Handler de objetos, HTTPSERVERTRETRECES HandleRexecutionChain) Handler: New HandleRexecutionChain (Handler); Chain.addinterceptors (getAdaptedInterceptors ()); string lookUppath = urlpathHelper.getLoightUppathForRequest (solicitud); para (MappedInterceptor MappedInterceptor: Mappedinterceptors) {if (MappedInterceptor.Matches (Lookuppath, Pathmatcher))) {Chain.addinterceptor (mappedinterceptor.getinterceptor ());}} cadena de retorno;} A continuación, eche un vistazo al Gethandlerinternal implementado por ResumenRlhandlermapping
// abstractUrlHandlermapping/*** Busque un controlador para la ruta de URL de la solicitud dada.* @Param solicitud actual solicitud http* @return la instancia del controlador, o {@code null} si ninguno encontrado*/ @overrideProtected Object gethandlerinternal (htttpServletRequest Solicitud) lanza excepción {// obtener urlstring getUrlPathHelper (). a // Expone la ruta_within_handler_mapping_attribute para él también. (instancia rawHandler de string) {String handlername = (String) rawHandler; rawHandler = getApplicationContext (). getBean (handlername);} // El método de plantilla de controlador de verificación reservado no usa validateHandler (rawHandler, request); // Agregar el atributo de exposición al controlador interceptora del controlador de solicitud = buildPathExpessEntler (RawHandler, RawHandler); LookUppath, Null);}} if (Handler! = Null && logger.isDebugeNable ()) {logger.debug ("mapping [" + lookUppath + "] a" + handler);} else if (handler == null && logger.istraceEnabled () {logger.trace (no handler mapepping found para [" "]");} Handler de retorno;} // abstractUrlHandlermapping/*** Busque una instancia de controlador para la ruta de URL dada.* <P> Admite coincidencias directas, por ejemplo, un "coincidencias"/test "/test",* y varias coincidencias de patrones de estilo HAND, por ejemplo, un "/T*" Matches* ambas "/Test" y "/"/"/". Para obtener más detalles, consulte la clase AntpathMatcher.* <P> busca el patrón más exacto, donde más exacto se define como* el patrón de ruta más largo.* @Param urlpath url La frijol se asigna a* @param solicitud actual http (no exponer la ruta dentro de la asignación a)* @return la instancia del manejador asociado o {@code nulL} @see org.springframework.util.antpathmatcher*/Protected Object LookupHandler (String urlPath, httpservletRequest solicitud) lanza una excepción {// coincidencia directa? Se busque directamente handleroBject Handler = this.handlermap.get (urlPath); if (handler! = Null) {// name o controlador resuelto? If (handler instanceOf string) {string handlername = (string) Handler; Handler = GetApplicationContext (). Urlpath, Urlpath, NULL);} // ¿Patrón coincidente? La coincidencia a través de expresiones se implementa a través de AntpathMatcher. El análisis específico se proporciona a continuación List <String> MatchingPatherns = new ArrayList <String> (); for (String RegisterPattern: this.handlermap.KeySet ()) {if (getPathMatcher (). Match (registrado (registrado, urlPath)) {MatchingPatterns.Add (registrado);}} string bestPatternMatch = null; comparador <String> Patterncomparator = GetPathMatchMer (). if (! MatchingPatherns.isEmpty ()) {Collections.sort (MatchingPatterns, PatternComparator); if (logger.isdeBugeNabled ()) {logger.debug ("Los patrones de coincidencia para solicitud [" + urlpath + "] son" + Pattins de matching);} // El número de orden más bajo tiene el mejor prioridad más alto Priority BestPatternmatch = MatchingPatterns.get ();} if (bestPatternMatch! = NULL) {Handler = this.handlermap.get (bestPatternMatch); // name de frijol o controlador resuelto? if (handler instancef string) {string handlername = (string) Handler; Handler = getApplicationContext (). PathWithInMapping = getPathMatcher (). ExtractPathWithInPattern (bestPatternMatch, URLPath); // Puede haber múltiples 'los mejores patrones' ', asegurémonos de tener las variables de plantilla URI correctas // para todas lasmap <String, String> UritEmplateVariBles = new LinkedHashMap <String, String> (); for (String MatchingPathern: MatchingPatherns) {if (PatternComparator.Compare (BestPatherNMatch, MatchingPattern) ==) {MAP <String, String> Vars = getPathMatcher (). ExacturitEmplateVariables (MatchingPattern, Urlpath); Map <String, String, DecodedVars = = getUrlPathHelper (). decodePathVariAbles (solicitud, vars); uritaMateVariAbles.putall (decodeDVars);}} if (logger.isdeBugeNabled ()) {logger.deBug ("Uri Template Variables para solicitud [" + Urlpath +] Are BuildPathExposedHandler (Handler, BestPatternMatch, PathwithinMapping, UritEmplateVariables);} // No se encontró el controlador ... return null;} Diseñado para verificar los manejadores, no se hace nada, incluidas las subclases.
/*** Validar el controlador dado con la solicitud actual.* <p> La implementación predeterminada está vacía. Se puede anular en subclases,* Por ejemplo, para aplicar condiciones previas específicas expresadas en las asignaciones de URL.* @Param Handler El objeto del controlador para validar* @param solicitud actual http solicitud* @throws excepción si la validación fallida*/protegido void validateHandler (manejador de objetos, solicitud httPserveRepServrequest) lanzada excepción {}}}}}}}}}} Encapsular el controlador como HandleRexecutionChain, y agregue PathExpositingHandlerInterceptor y UritEmplateVariashandlerInterceptor Interceptor.
/*** construya un objeto de controlador para el controlador sin procesar dado, exponiendo el controlador* real*, el {@link #path_within_handler_mapping_attribute}, así como* la {@link #uri_template_variables_attribute} antes de ejecutar el manejador especial.* <p> La implementación predeterminada crea una {@@@link handlexeRiConion} con el controlador} con el manejador especial con el controlador} que expone las variables de la plantilla de atributo de ruta y URI* @param rawHandler El controlador sin procesar para exponer* @param rutawithInmapping la ruta para exponer antes de ejecutar el controlador* @param uritEmplateVariables El objeto de plantilla URI de URI, puede ser {@code objeco} si no se encontran variables* @@retrupurn el handler final*/objeto protegido objeto protegido String bestMatchingPathern, string rathWithInMapping, map <string, string> uritEmplateVariables) {handleRexecutionChain Chain = new HandleReXecutionChain (rawHandler); Chain.addinterceptor (New PathExposedHandlerInterceptor (BestMatchingPattern, PathWithInMapping)); if (! CollectionUtIls.isEmpty (uritaMeMateVariables)) {Chain.addinterceptor (new UritaMateVariashanderinterceptor (uritEplateVariables));} Chain;}El contenido anterior es el conocimiento relevante de la interpretación del código fuente de SpringMVC de la distribución de solicitudes de la serie de la serie ResumenRlhandlermapping introducida a usted. ¡Espero que sea útil para todos!