AbstractDetectingUrlHandlerMapping Registra Manipulador por meio da digitalização e é distribuído pelo Gethandlerinternal of AbstractUrlHandlerMapping ao receber a solicitação.
Existem 5 subclasses e uma classe abstrata.
Semelhante ao SimpleUrlHandlerMapping, é inicializado substituindo o InitApplicationContext e chamando os detecthandlers.
Os detecthandlers digitalizam o objeto de aplicação por meio de BeanFactoryUtils e, em seguida, reserve o determinante que a subclasse gerar o URL correspondente de acordo com o manipulador.
O registro registrado REGISTERHLER ainda é fornecido pelo abstrumlhandlerMapping.
// AbstractDetectingUrlHandlerMapping/*** chama o método {@link #deteCtHandlers ()}, além da*inicialização da*superclass.*/@@overridepublic void initapplicationContext () lança ApplicationContextexception {Super.IniTAppAcnicationContext (); Isso também é chamado de interceptor InitApplicationContext Inicialização do AbstracthandlerMapping.
O protagonista aparece, detecthandlers, manipuladores de digitalização
// AbstractDetectingUrlHandlerMapping/*** Registre todos os manipuladores encontrados no ApplicationContext atual. Um feijão para* que esses URLs não poderiam ser determinados simplesmente não é considerado um manipulador. {Logger.debug ("Procurando mapeamentos de URL no contexto do aplicativo:" + getApplicationContext ());} string [] beanNames = (this.deteCtHandlersInCestorContexts? : getApplicationContext (). getBeanNamesfortype (object.class)); // Pegue qualquer nome de feijão para o qual possamos determinar os URLs. if (! ObjecjectUtils.isempty (URLS)) {// Caminhos URL Encontrados: Vamos considerá -lo um Handler.RegisterHandler (URLS, Beanname);} else {if (Logger.isdebugenabled ()) {Logger.debug ("Rejeitou o nomes '" + Beanname + "" "" " + bEanname" "" O método de modelo reservado aqui é definido da seguinte forma:
/*** Determine os URLs para o feijão do manipulador. Vamos dar uma olhada na implementação do método de modelo no BeanNameurlHandlerMapping e AbstractControllerurlHandlerMapping. O BeanNameurlHandlerMapping é muito simples, por isso implementa o DetermeturlSForHandler. O alias nele deve ser configurado no arquivo de configuração através do nome beanname.// beannameurlhandlerMapping/*** verifica o nome e os aliases do feijão fornecido para URLs, começando com "/".*/@@overrideprotegted string [] determinerlsForHandler (string beaname) {list <> urls = urls = string [] (beanname.startswith ("/")) {urls.add (beanname);} string [] aliases = getApplicationContext (). getaliases (beanname); para (alias de string: aliases) {if (alias.startswith ("/")) {urls.add (alias);}} retorna stringUtils.ToStringArray (URLs);} Vamos dar uma olhada na implementação no AbstractControllerurlHandlerMapping
ISELigibleFormapap determina se o controlador está excluído (excluído por meio de pacote ou classe de classe).
BuildUrlsForHandler implementa regras específicas de geração de URL de subclasses
IsControllerType determina se a subclasse do controlador
BuildUrlsForHandler Reservas Modelo Método para URLs de produção de subclasse.
// AbstractControllerUrlHandlerMapping/*** Esta implementação delega para {@link #buildurlsforhandler},*desde que {@link #iseligibleForpApping} returns {@code true {/@@roverrideprotected [] String [] determineUrlsHandler (string beiname) {Banename) {Banename) {Banename). getApplicationContext (). GetType (Beanname); if (iseligibleFormapping (beanname, beansclass)) {return BuildUrlsForHandler (nome de beanname, beansclass); mais, não {Return null;}//abstrollerrollerLandLaPlapping/** justiça, se é que o bEanNeN, o que é, o nome do beanNeCl); @mais, o que é necessário, o nome do BEANSPRONCLASS); do bean do controlador* @param beansclass A classe de concreto do bean do controlador* @return se a classe especificada é excluída* @see #setexcludedPackages* @see #setexcludedclasses*/protegido boolean iseligibleformapping (string beanname, classe beanClass) {se (Logger.isdebugenabled ()) {Logger.debug ("Exclua o controlador Bean '" + Beanname + "' do mapeamento de nome da classe" + "porque seu tipo de feijão não pôde ser determinado");} retornar false;} se (this.excludedclasses. {Logger.debug ("Excluído controlador de bean '" + beanname + "' do nome da classe mapeando" + "porque sua classe de feijão é explicitamente excluída:" + beanclass.getName ());} retornar false;} string beanclasname = benclass. (beansclassName.startswith (packagename)) {if (logger.isdebugenabled ()) {logger.debug ("exclua o controlador bean '" + beanname + "' do nome da classe Mapping" + "porque sua classe Bean é definida em um pacote excluído:" + bean. isControllerType (BeansClass);} // AbstractControllerurlHandlerMapping/*** Determine se a classe de feijão indica um tipo de controlador* suportado por essa estratégia de mapeamento. this.predicate.iscontrollerType (beansclass);} // controllertypepredicate fornece 2 APIs para determinar se é uma subclasse do controlador ou uma subclasse de multiationController. iscontrollertype (classe beansclass) {return controller.class.isassignablefrom (beansclass);} public boolean ismultiactioncontrollertype (classe beansclass) {return multiectioncontroller.class.isAssignable (BeanClass);}} Reserve o método de modelo para gerar URL
// AbstractControllerUrlHandlerMapping/*** MOTEMENTO DE MELAS DE ABRAÇÃO A ser implementado por subclasses.
Vamos dar uma olhada nas duas implementações do AbstractControllerUrlHandlerMapping ControllerBeanNameurlHandlerMapping e ControlClassNameurlHandlerMapping.
De fato, esses dois são muito simples. Um é produzir URL com base no nome do feijão, e o outro é produzir URL com base no nome da classe.
// controlerBeanNameurlHandlerMapping@SubstituedProtected String [] BuildUrlsForHandler (String BeanName, classe beansclass) {list <string> urls = new ArrayList <string> (); urls.add (generatePathMapping (bEanName); string [] alias = getAppLication (getAplication (generatePathMappating (bEAnName); para (alias de string: aliases) {urls.add (generatePathMapping (alias));} retorna stringUtils.ToStringArray (urls);} // controlerBeanNameurlHandlerMapping/** adicione a '/' se necessário e anexa o sufixo url ao nome. (beanname.startswith ("/")? Beanname: "/" + beanname); stringbuilder path = new stringbuilder (); if (! name.startswith (this.urlPrefix)) {Path.append (this.urlPrefix);} Path.Append (Name); {Path.append (this.urlSuffix);} Return Path.ToString ();} // controlerclassNameurlHandlerMapping Delegar diretamente para gerar a implementação do GeratePathMappings
@OverrideProtected String [] BuildUrlsForHandler (String Beanname, classe beansclass) {return GeneratePathMappings (beansClass);} // controlerclassNameurlHandlerMapping Obtenha o prefixo do caminho através do BuildPathPrefix
Obtenha o ClassName através do Classutils, como o BookController (sem nome do pacote), e use o proxy do CGLIB para resolver o problema juntos.
Converta ClassName de acordo com o caso é sensível (Caso de Casos Padrão = Falso;)
IsmultiactionControllerType determina se o controlador é uma subclasse do controlador de multiation, ou seja, se o controlador contém vários manipuladores.
/*** Gere os caminhos de URL reais para a classe de controlador fornecida.* <p> As subclasses podem optar por personalizar os caminhos que são gerados* substituindo esse método. BuildPathPrefix (beansClass); string className = Classutils.getShortName (beansClass); String Path = (ClassName.endSwith (controller_suffix)? ClassName.substring (ClassName.LastIndexof (controller_suffix): ClassName) se (Path.LngthngthLength (). {pathmapping.append (path.substring (,) .tolowerCase ()). Append (path.substring ());} else {pathmapping.append (path.tolowercase ());}}} if (ismultiactionControllTyPe (BaanClass)); {Return string []. "/*"};} else {return new String [] {pathmapping.tostring () + "*"};}} // controlerclassNameurlHandlerMapping/*** Construa um prefixo de caminho para o caminho do controlador para a classe*Patroce para o caminho*@param o stroll, o controlador, a classificação para gerar um caminho para o caminho para o caminho de strong para o caminho do stro -path para o caminho do stroll, o que é o stroll, o que é o strolling, o que é o que o controlador é o que pode ser o que o controlador é o que o controlador é o que é o que é o que é o que é o que você está StringBuilder BuildPathPrefix (classe beansClass) {StringBuilder PathMapping = new StringBuilder (); if (this.PathPrefix! = Null) {pathmapping.append (this.pathPrefix); PathMapp.Append ("/");} else {PathMappAppend ("/"); packAgename = classutils.getpackagename (beansclass); if (packagename.startswith (this.basepackage)) {string subpackage = packagename.substring (this.basepackage.length (). subpackage: subpackage.tolowercase ()); pathmapping.append ("/");}} retornar pathmapping;} // abstractcontrollerurlhandlerMapping Predicate.MSULACTIONCONTROLLERTYPE Implementação específica, consulte o controllerTypePEDICATE ACIMA
/*** Determine se a classe de bean especificada indica um tipo de controlador* que despacha para vários métodos de ação.
O exposto acima é o conhecimento relevante sobre a inicialização da interpretação do código -fonte Springmvc do Handlermapping - Série AbstractETingUrlHandlerMapping que o editor apresentou a você. Espero que seja útil para todos!