Interpretação do código -fonte Springmvc: Handlermapping - AbstractUrlHandlerMapping Series Solicitação de Solicitação de Distribuição

Abstracthandlermapping implementa o Gethandler especificado pela interface de manutenção

1. Forneça o método de modelo GethandlerInternal para a implementação da subclasse

2. Se o manipulador não for obtido, o padrão padrão é usado.

3. Se o manipulador for do tipo string, obtenha a instância do contexto

4. Encapsular o manipulador através de GethandlerexecutionChain e adicione o interceptador

 // abstacthandlermapping/*** Procure um manipulador para obter a solicitação fornecida, voltando ao manipulador* padrão* se não houver um específico. gethandlerinternal (request); if (handler == null) {handler = getDefaultHandler ();} if (handler == null) {return null;} // nome de bean ou resolvido manipulador? se (handler instância de string) {string handlename = (string) handler; handler; gethandlerexecutionChain (manipulador, request);} // abstracthandlermapping/*** Construa um HandleRexecutionChain para o manipulador fornecido, incluindo interceptors aplicáveis. solicitar url. As subclasses podem* substituir isso para estender/reorganizar a lista de interceptores. Este método deve lidar com esses dois casos explicitamente:* Construindo uma nova HandleRexecutionChain ou estendendo a cadeia existente. null})* @param request current HTTP request* @return the HandlerExecutionChain (never {@code null})* @see #getAdaptedInterceptors()*/protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {HandlerExecutionChain chain =(handler instanceof HandlerexecutionChain) manipulador: new handlerexecutionChain (manipulador); Chain.AddInterceptores (GetAdaptedInterceptores ()); String lookuppath = urlpathhelper.getLeoppathForRequest (request); para (MappEdInterceptor mapedInterceptor: mapedInterceptores) {if (mapepedIntercept.matches (LookuPath, pathmatcher)) {Chain.addintercept (mapedIntercept.getIntercept ());}} Cadeia de retorno;}

Em seguida, dê uma olhada no Gethandlerinternal implementado pelo abstrumlhandlerMapping

 // AbstractUrlHandlerMapping/*** Procure um manipulador para o caminho da URL da solicitação fornecida. getUrlPathHelper (). GetLhopathForRequest (request); // Encontre HandleroBject Handler = LookUpHandler (Lookupppath, request); se (Handler == null) {// se não houver para o manipulador, você precisará, precisar de um padrão, você precisa de um padrão, que precisará de carojamento, que precisará de carojamento, precisará, precisar, precisar de cache/ pathin_happing_mapping, que precisará, precisar, precisar de cache/ cache para covar para // expor o path_within_handler_mapping_attribute para ele também.Object RawHandler = null; if ("/".equals(lookupppath)) {RawHandler = getroothandler ();} se (RawHandler == null) {RawHandler = getDaLuln;}; manipulador? if (instância rawHandler de string) {string handlername = (string) RawHandler; RawHandler = getApplicationContext (). getBean (handlername);} // O modelo de manipulador de verificação reservado (RawHandler, o Modelo de LankArtHandUrtHerTerTeTHArtHerTerTeTHLATHLATHLING (RAWHANDLER); PARTIDATELTING (RAWHANDLER); lookuppath, null);}} if (handler! = null && logger.isdebugenabled ()) {logger.debug ("mapeando [" + lookuppath + "] para" foundler);); else (handler == null & in Logger.istaceEnabled () {Logger.Tro.Tro.Tre (handler == null & & Logger.istaceEnabled ()); "]");} Return Handler;} // abstractUrlHandlerMapping/*** Procure uma instância de manipulador para o caminho da URL fornecido. Para detalhes, consulte a classe Antpathatcher. org.springframework.util.antpathmatcher*/Protected Object LookUpHandler (String urlpath, httpServletRequest Solicy) lança exceção {// correspondência direta? Pesquise diretamente HandlerObject Handler = this.HandlerMap.get (urlpath); if (manipulador! = Null) {// Nome do feijão ou manipulador resolvido? If (manipulador instanceof string) {string handLername = (string) handler; handler = getApplicationContext (). urlpath, urlpath, null);} // padronizar? A correspondência através de expressões é implementada através do Antpathmatcher. A análise específica é fornecida abaixo da lista <String> MatchingPatterns = new ArrayList <String> (); para (string registredPattern: this.HandlerMap.KeySet ()) {if (getPathMatcher (). Match (RegisterDPattern, urlpath)) {matchingPatterns.add (registringPattern);}} string bestpatternmatch = null; comparador <trattern). if (! MatchingPatterns.isEmpty ()) {collectionS.sort (MatchingPatterns, padringComParator); if (Logger.isDebugEnabled ()) {Logger.debug ("Matching Patterns para solicitação [" + urlpath + "] são" + matchingPatterns);} // MatchingPatterns.get ();} if (bestpatternmatch! = null) {handler = this.handlerMap.get (bestpatternmatch); // nome de bean ou manipulador resolvido? se (}} {) {string handLername = (string) handler; handler = getApplicationContet (). PathWithInMapping = getPathMatcher (). ExtractPathWithInPattern (BestPatternMatch, urlpath); // pode haver vários 'melhores padrões', vamos garantir que o modelo URI correto variáveis ​​// para todos os outros, String, String> Uritemplate) Para (String MatchingPattern: MatchingPatterns) {if (padringComParator.comPare (BestPatternMatch, MatchingPattern) ==) {map <String, String> vars = getPathMatcher (). ExtractURitEMplateVariables (MatchingPattern, urlpath); map <stractUritEdEdVariables (MatchingPattern, urlpath); map <stractUritEdEdVariBles (MatchingPattern, urlpath); map <stractUritEdEn. vars);uriTemplateVariables.putAll(decodedVars);}}if (logger.isDebugEnabled()) {logger.debug("URI Template variables for request [" + urlPath + "] are " + uriTemplateVariables);} return buildPathExposedHandler(handler, bestPatternMatch, pathWithinMapping, uritemplateVariables);} // nenhum manipulador encontrado ... retornar nulo;}

Projetado para verificar os manipuladores, nada é feito, incluindo subclasses.

 /*** Valide o manipulador fornecido em relação à solicitação atual.* <p> A implementação padrão está vazia. Pode ser substituído em subclasses,* por exemplo, para aplicar pré -condições específicas expressas em mapeamentos de URL.

Encapsular o manipulador como HandlerexecutionChain e adicione PathexpositingHandlerInterceptor e URITEMPLATEVARIABLESHANDLERLERINTERCECTOR INTERCECTOR.

 /*** Construa um objeto manipulador para o manipulador bruto dado, expondo o manipulador* real, o {@link #path_within_handler_mapping_attribute}, bem como* o {@link #uri_template_variables_attribute} antes do manipulador. Expondo o atributo do caminho e o modelo URI Variáveis* @param RawHandler O manipulador Raw para expor* @param pathwithinMaping o caminho para expor antes de executar o manipulador* @param uritemplateVariAbles As variáveis ​​de Model de Uri, podem ser {@code null} BestMatchingPattern, String pathwithinMapping, mapa <string, string> uritemplateVariables) {handlerexecutionChain cadeia = new HandlerexecutionChain (RawHandler); Chain.AddIntercept (novo PathExposedHandlerIntercept (BestMatchingPattern, PathwithinMapping)); if (! collectionutils.isEmpty (URITEMPLATEVARIABLES)) {CHELEDDINTERCECTOR (New UritemplateVariaBelAndlerCetor (URITEMPLATEVARIABLES);

O conteúdo acima é o conhecimento relevante da interpretação do código -fonte Springmvc do manutenção de manobras - a distribuição de solicitações de séries abstrataHandlerMapping introduzida a você. Espero que seja útil para todos!